系统会将其推送到重临栈上,系统会由此该 Activity

Activity

图片 1

Activity是一个用到组件,用户可与其提供的屏幕进行互相。以推行拨打电话,拍摄照片,发送电子邮件或查看地图等操作。
每个 Activity
都会获取一个用于绘制其用户界面的窗口(window)。窗口常常会充满屏幕,但也可小于屏幕并扭转在任何窗口之上。
  一个拔取普通由多少个相互松散联系的 Activity 组成。
一般会指定应用中的某个 Activity 为“主”Activity(Main
Activity),即首次开行应用时表现给用户的丰硕 Activity。 而且每个 Activity
均可开行另一个 Activity,以便执行不一的操作。 每便新 Activity
启动时,前一 Activity 便会停下,但系统会在仓房(“重回栈”)中保存该
Activity。 当新 Activity
启动时,系统会将其推送到再次来到栈上,并取得用户宗旨。
再次来到栈遵从“后进先出”堆栈机制,因而,当用户完成方今 Activity 并按“再次回到”
按钮时,系统会从仓库少校其弹出(并销毁),然后还原前一
Activity。(职分和再次来到栈文档中对回到栈有更详尽的阐释。)
  当一个 Activity 因某个新 Activity 启动而告一段落时,系统会通过该 Activity
的生命周期回调方法布告其这一气象变化。Activity 因气象变化(系统是创造Activity、为止 Activity、恢复生机 Activity 依然销毁
Activity)而接受的回调方法恐怕有若干种,每一种回调方法都会为您提供执行与该场馆变化相应的特定操作的空子。
例如,甘休时,您的 Activity 应释放其余大型对象,例如网络或数据库连接。
当 Activity 复苏时,您能够重复得到所需资源,并上升执行中断的操作。
那么些意况转变都是 Activity 生命周期的一部分。
  本文的其他部分讲演有关怎么样创设和运用 Activity 的基础知识(蕴涵对
Activity 生命周期工作措施的健全论述),以便你不利管理各类 Activity
状态之间的变动。

本文内容

  1. 创建 Activity
    1. 心想事成用户界面
    2. 在清单文件中宣称 Activity
  2. 启动 Activity
    1. 启动 Activity 以得到结果
  3. 结束 Activity
  4. 管制 Activity 生命周期
    1. 兑现生命周期回调
    2. 保存 Activity 状态
    3. 拍卖配置变更
    4. 协调 Activity

Activity 是一个施用组件,用户可与其提供的屏幕进行互动,以进行拨打电话、拍摄照片、发送电子邮件或查看地图等操作。
每个 Activity
都会获取一个用于绘制其用户界面的窗口。窗口常常会充满屏幕,但也可小于屏幕并扭转在其他窗口之上。

一个选择普通由多少个互相松散联系的 Activity 组成。 一般会指定应用中的某个
Activity 为“主”Activity,即首次启动应用时表现给用户的不胜 Activity。
而且每个 Activity 均可启动另一个 Activity,以便执行差其他操作。 每一遍新
Activity 启动时,前一 Activity
便会终止,但系统会在仓库(“重回栈”)中保留该 Activity。 当新 Activity
启动时,系统会将其推送到再次回到栈上,并赢得用户主题。
再次回到栈听从基本的“后进先出”堆栈机制,因而,当用户已毕近年来 Activity
并按“重临”按钮时,系统会从仓库少将其弹出(并销毁),然后还原前一
Activity。 (职分和重返栈文档中对回到栈有更详细的解说。)

当一个 Activity 因某个新 Activity 启动而平息时,系统会透过该 Activity
的生命周期回调方法文告其这一意况变化。Activity 因场馆变化—系统是创立Activity、停止 Activity、苏醒 Activity 依旧销毁 Activity—
而接受的回调方法可能有几各个,每一种回调都会为你提供执行与该境况变化相应的一定操作的火候。
例如,停止时,您的 Activity 应释放其他大型对象,例如互连网或数据库连接。
当 Activity 复苏时,您能够重新得到所需资源,并回复执行中断的操作。
那一个景况转变都是 Activity 生命周期的一有些。

正文的其余部分演讲有关怎么着创设和采用 Activity 的基础知识(包蕴对
Activity 生命周期工作形式的天公地道阐释),以便你不利管理各样 Activity
状态之间的更动。


创建Activity

要创建 Activity,您必须创立
Activity
的子类(或行使其现有子类)。您须要在子类中落实 Activity
在其生命周期的各个意况之间变更时(例如创立 Activity、截至 Activity、復苏Activity 或销毁 Activity 时)系统调用的回调方法。
四个最要紧的回调方法是:

onCreate()

你必须贯彻此措施。系统会在创立您的 Activity
时调用此方法。您应该在完成内起头化 Activity 的画龙点睛组件。
最要紧的是,您必须在此措施内调用 setContentView(),以定义 Activity
用户界面的布局。

onPause()

系统将此措施作为用户距离 Activity 的第四个信号(但并不三番五次意味着
Activity 会被灭绝)举行调用。
您平常应该在此措施内肯定在此时此刻用户会话为止后仍然有效的其他改变(因为用户可能不会回来)。

您还应使用二种其余生命周期回调方法,以便提供流畅的 Activity
间用户体验,以及处理导致您的 Activity 为止甚至被销毁的意想不到中断。
后文的管制 Activity
生命周期
局地对负有生命周期回调方法开展了阐释。

创建 Activity


要创制Activity,您必须创设 Activity 的子类(或应用其存世子类)。您须要在子类中落实Activity 在其生命周期的各类状态之间转移时(例如创立 Activity、停止Activity、复苏 Activity 或销毁 Activity 时)系统调用的回调方法。
四个最根本的回调方法是:

onCreate()
您必须落成此措施。系统会在开立您的 Activity
时调用此方法。您应该在贯彻内开始化 Activity 的不可或缺组件。
最关键的是,您必须在此方式内调用setContentView(),以定义 Activity
用户界面的布局。

onPause()
系统将此方法作为用户距离 Activity 的首先个信号(但并不一连意味着
Activity 会被灭绝)举行调用。
您平日应该在此方法内肯定在脚下用户会话为止后仍然有效的别的变动(因为用户可能不会回到)。

你还应接纳三种其余生命周期回调方法,以便提供流畅的 Activity
间用户体验,以及处理导致你的 Activity 甘休甚至被销毁的出人意料中断。
后文的管理 Activity
生命周期
局部对富有生命周期回调方法开展了阐释。

以下演讲均源于Android官网的开销文档

完毕用户界面

Activity 的用户界面是由层级式视图(衍生自 View
类的靶子)提供的。每个视图都控制 Activity
窗口内的特定矩形空间,可对用户交互作出响应。
例如,视图可以是在用户触摸时启动某项操作的按钮。
  您能够运用 Android
提供的众多现成视图设计和团社团您的布局。“小工具”(Widget)是提供按钮、文本字段、复选框或独自是一幅图像等显示器视觉(交互式)元素的视图。
“布局”(Layout)是衍生自 ViewGroup
的视图,为其子视图提供唯一布局模型,例如线性布局(Linear
Layout)、网格布局(Grid Layout)或相对布局(Relative Layout)。您仍是可以为
View
类和
ViewGroup
类创制子类(或应用其现有子类)来机关创立小工具和布局,然后将它们选取于你的
Activity 布局。
  利用视图定义布局的最广泛方法是依靠保存在您的运用资源内的 XML
布局文件。那样一来,您就足以将用户界面的设计与定义 Activity
行为的源代码分开维护。 您可以因而 setContentView()将布局设置为
Activity 的 UI,从而传递布局的资源 ID。不过,您也可以在 Activity
代码中开立异 View,并由此将新 View 插入 ViewGroup
来创设视图层次,然后通过将根 ViewGroup 传递到
setContentView()来利用该布局。
  如需明白有关成立用户界面的信息,请参阅用户界面文档。

兑现用户界面

Activity 的用户界面是由层级式视图 — 衍生自 View 类的对象 —
提供的。每个视图都控制 Activity
窗口内的特定矩形空间,可对用户交互作出响应。
例如,视图可以是在用户触摸时起步某项操作的按钮。

您可以行使 Android
提供的过多现成视图设计和社团您的布局。“小部件”是提供按钮、文本字段、复选框或单独是一幅图像等显示器视觉(交互式)元素的视图。
“布局”是衍生自 ViewGroup 的视图,为其子视图提供唯一布局模型,例如线性布局、网格布局或相对布局。
您还是能为 View 类和 ViewGroup 类创设子类(或应用其现有子类)来机关创制小部件和布局,然后将它们利用于你的
Activity 布局。

运用视图定义布局的最广泛方式是着重保存在您的行使资源内的 XML
布局文件。这样一来,您就足以将用户界面的宏图与定义 Activity
行为的源代码分开维护。 您可以透过 setContentView() 将布局设置为
Activity 的 UI,从而传递布局的资源 ID。可是,您也得以在 Activity
代码中开革新 View,并透过将新 View 插入 ViewGroup 来创设视图层次,然后经过将根 ViewGroup 传递到 setContentView() 来使用该布局。

如需领会有关创设用户界面的新闻,请参阅用户界面文档。

1.简述Activity

Activity
是一个使用组件,用户可与其提供的显示屏进行互动,以履行拨打电话、拍摄照片、发送电子邮件或查看地图等操作。
每个 Activity
都会获取一个用以绘制其用户界面的窗口。窗口经常会充满显示屏,但也可小于屏幕并转移在其余窗口之上。

一个采纳一般由三个相互松散联系的 Activity 组成。 一般会指定应用中的某个
Activity 为“主”Activity,即首次开行应用时表现给用户的非常 Activity。
而且每个 Activity 均可开行另一个 Activity,以便执行不一的操作。 每回新
Activity 启动时,前一 Activity
便会截止,但系统会在仓房(“再次来到栈”)中保存该 Activity。 当新 Activity
启动时,系统会将其推送到再次来到栈上,并取得用户主旨。
再次来到栈遵从基本的“后进先出”堆栈机制,因而,当用户落成近期 Activity
并按“再次来到”按钮时,系统会从仓库上校其弹出(并销毁),然后还原前一
Activity。
义务和再次来到栈文档中对回到栈有更详细的阐发。)

当一个 Activity 因某个新 Activity 启动而告一段落时,系统会通过该 Activity
的生命周期回调方法文告其这一情景变化。Activity 因场合变化—系统是创设Activity、甘休 Activity、復苏 Activity 仍旧销毁 Activity—
而接受的回调方法也许有若干种,每一种回调都会为您提供执行与该情形变化相应的特定操作的机遇。
例如,截至时,您的 Activity 应释放其余大型对象,例如网络或数据库连接。
当 Activity 恢复生机时,您可以重复得到所需资源,并回涨执行中断的操作。
这么些意况转变都是 Activity 生命周期的一局地。

本文的其他部分解说有关怎么样创建和选择 Activity 的基础知识(包涵对
Activity 生命周期工作方法的两全论述),以便你不利管理各样 Activity
状态之间的变迁。

在清单文件中宣称 Activity

总得在清单文件中申明您的 Activity,那样系统才能访问它。 要评释您的
Activity,请打开你的清单文件,并将<activity>要素添加为 <application>
元素的子项。例如:

<manifest ... >
    <application ... >
      <activity android:name=".ExampleActivity" />
      ...  
   </application ... >
    ...
</manifest >

您还足以在此因素中参预多少个其他特色,以定义 Activity 标签、Activity
图标或风格大旨等用于安装 Activity UI 风格的属性。android:name
特性是绝无仅有的画龙点睛特性—它指定 Activity
的类名。应用一旦发表,即不应更改此类名,否则,可能会毁掉诸如应用快速形式等片段功效(请阅读博客文章
Things That Cannot
Change

[不可以改变的内容])。
请参阅 <activity> 元素参考文档,掌握关于在清单文件中宣示 Activity
的详细新闻。

在清单文件中声称 Activity

你必须在清单文件中扬言您的 Activity,那样系统才能访问它。 要声明您的
Activity,请打开你的清单文件,并将 <activity> 元素添加为 <application>要素的子项。例如:

<manifest ... >
  <application ... >
      <activity android:name=".ExampleActivity" />
      ...
  </application ... >
  ...
</manifest >

你还足以在此因素中参加多少个其余特色,以定义 Activity 标签、Activity
图标或风格宗旨等用于安装 Activity UI
风格的习性。 android:name 属性是唯一必需的性质—它指定
Activity
的类名。应用一旦发表,即不应更改此类名,否则,可能会毁掉诸如应用快捷方式等一些职能(请阅读博客作品 Things
That Cannot
Change
 [无法更改的内容])。

请参阅 <activity> 元素参考文档,精晓关于在清单文件中声称
Activity 的详细音讯。

2.创建Activity

要创建 Activity,您必须成立 Activity
的子类(或应用其存世子类)。您必要在子类中落实 Activity
在其生命周期的种种状态之间变化时(例如创设 Activity、甘休 Activity、苏醒Activity 或销毁 Activity 时)系统调用的回调方法。
四个最珍爱的回调方法是:

  • onCreate()
    你必须达成此方法。系统会在开立您的 Activity
    时调用此措施。您应该在落到实处内初步化 Activity 的不可或缺组件。
    最重视的是,您必须在此方法内调用 setContentView(),以定义 Activity
    用户界面的布局。
  • onPause()
    系统将此措施作为用户距离 Activity 的第一个信号(但并不延续意味着
    Activity 会被灭绝)实行调用。
    您常常应该在此措施内肯定在当前用户会话截至后仍然有效的别样改变(因为用户可能不会重返)。

您还应采纳两种其余生命周期回调方法,以便提供流畅的 Activity
间用户体验,以及处理导致你的 Activity 截至甚至被销毁的意料之外中断。
后文的管住 Activity 生命周期有的对具有生命周期回调方法开展了解说。

使用 Intent 过滤器

<activity> 元素还可指定各样 Intent 过滤器——使用
<Intent-filter>要素——以宣称其余应用组件激活它的法子。当您使用 Android
SDK 工具创立新利用时,系统活动为您创立的票根 Activity 包涵一个 Intent
过滤器,其中注脚了该 Activity 响应“主”操作且应放置“launcher”连串内。
Intent 过滤器的始末与以下所示类似:

<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon"> 
      <intent-filter>        
          <action android:name="android.intent.action.MAIN" />   
          <category android:name="android.intent.category.LAUNCHER" />  
      </intent-filter>
</activity>

<action>要素指定那是利用的“主”入口点。<category> 元素指定此 Activity
应列入系统的采纳启动器内(以便用户启动该 Activity)。
  如果你打算让使用成为独立使用,不允许任何应用激活其
Activity,则您不须求其余别的 Intent 过滤器。 正如前例所示,只应有一个
Activity 具有“主”操作和“launcher”序列。 您不想提须求其他使用的 Activity
不应有其余 Intent 过滤器,您可以应用显式 Intent
自行启动它们(下文对此做了阐释)。
  可是,若是你想让 Activity 对衍生自其余应用(以及你的自有利用)的隐式
Intent 作出响应,则必须为 Activity 定义其余 Intent 过滤器。
对于你想要作出响应的每一个 Intent 类型,您都无法不参与相应的
<Intent-filter>,其中包涵一个 <action>要素,还可选取性地概括一个
<category> 元素和/或一个 <data> 元素。这个元素指定您的 Activity
可以响应的 Intent 类型。

如需领会有关您的 Activity 怎样响应 Intent 的详细消息,请参阅Intent 和
Intent
过滤器
文档。

使用 Intent 过滤器

<activity> 元素还可指定各个Intent
过滤器—使用 <intent-filter> 元素—以宣称其余使用组件激活它的不二法门。

当您使用 Android SDK 工具创制新应用时,系统活动为您创制的存折 Activity
包涵一个 Intent 过滤器,其中评释了该 Activity
响应“主”操作且应松开“launcher”体系内。 Intent 过滤器的始末如下所示:

<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<action> 元素指定那是应用的“主”入口点。<category> 元素指定此
Activity 应列入系统的应用启动器内(以便用户启动该 Activity)。

纵然你打算让使用成为独立行使,分歧意任何应用激活其
Activity,则您不须求其余其余 Intent 过滤器。 正如前例所示,只应有一个
Activity 具有“主”操作和“launcher”体系。 您不想提需求别的使用的 Activity
不该其余 Intent 过滤器,您可以采用显式 Intent
自行启动它们(下文对此做了阐释)。

不过,假若你想让 Activity 对衍生自其余应用(以及你的自有使用)的隐式
Intent 作出响应,则必须为 Activity 定义其他 Intent 过滤器。
对于你想要作出响应的每一个 Intent
类型,您都必须到场相应的 <intent-filter>,其中囊括一个 <action> 元素,还可采纳性地概括一个 <category> 元素和/或一个<data> 元素。那一个元素指定您的
Activity 可以响应的 Intent 类型。

如需驾驭有关您的 Activity 如何响应 Intent 的详细新闻,请参阅 Intent 和
Intent
过滤器
文档。

3.落到实处用户界面

Activity 的用户界面是由层级式视图 — 衍生自 View 类的对象 —
提供的。每个视图都决定 Activity
窗口内的一定矩形空间,可对用户交互作出响应。
例如,视图可以是在用户触摸时启动某项操作的按钮。

你能够行使 Android
提供的广大现成视图设计和集体您的布局。“小部件”是提供按钮、文本字段、复选框或仅仅是一幅图像等屏幕视觉(交互式)元素的视图。
“布局”是衍生自 ViewGroup
的视图,为其子视图提供唯一布局模型,例如线性布局、网格布局或相对布局。
您还能为 View 类和 ViewGroup
类创设子类(或应用其存世子类)来机关成立小部件和布局,然后将它们利用于您的
Activity 布局。

应用视图定义布局的最普遍方法是借助保存在您的拔取资源内的 XML
布局文件。那样一来,您就可以将用户界面的设计与概念 Activity
行为的源代码分开维护。 您可以由此 setContentView() 将布局设置为 Activity
的 UI,从而传递布局的资源 ID。可是,您也足以在 Activity 代码中开立异View,并因而将新 View 插入 ViewGroup 来制造视图层次,然后通过将根
ViewGroup 传递到 setContentView() 来使用该布局。

如需询问关于成立用户界面的信息,请参阅用户界面文档。

启动 Activity

你可以透过调用 startActivity(),并将其传递给描述您想启动的 Activity 的
Intent 来启动另一个 Activity。Intent 对象会指定您想启动的现实 Activity
或描述您想进行的操作类型(系统会为你拔取适宜的
Activity,甚至是缘于其余应用的 Activity)。 Intent
对象还可能教导少量供所启动 Activity 使用的数据。
  在你的自有应用内行事时,您日常只须求启动某个已知 Activity。
您可以因此选用类名创设一个显式定义您想启动的 Activity 的 Intent
对象来促成此目标。 例如,可以由此以下代码让一个 Activity
启动另一个名为SignInActivity 的 Activity:

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);

而是,您的应用可能还索要利用你的 Activity
数据进行某项操作,例如发送电子邮件、短信或情状更新。
在那种情景下,您的施用自身或者不持有实践此类操作所需的
Activity,由此你可以改为利用设备上其他使用提供的 Activity
为你执行这个操作。 那便是 Intent 对象的真正价值所在——您可以创立一个
Intent 对象,对你想举办的操作举办描述,系统会从其余应用启动相应的
Activity。 若是有多少个 Activity 可以处理
Intent,则用户可以选取要动用哪一个。
例如,假若您想同意用户发送电子邮件,可以创建以下 Intent 对象:

 Intent intent = new Intent(Intent.ACTION_SEND);
 intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
 startActivity(intent);

添加到 Intent 中的 EXTRA_EMAIL extra
是一个字符串数组,其中包涵应将电子邮件发送到的电子邮件地址。
当电子邮件选拔响应此 Intent 时,它会读取 extra
中提供的字符串数组,并将它们放入电子邮件撰写窗体的“收件人”字段。
在那种景观下,电子邮件选择的 Activity 启动,并且当用户完毕操作时,您的
Activity 会復苏执行。

启动 Activity


你可以通过调用 startActivity(),并将其传递给描述您想启动的 Activity
的 Intent 来启动另一个 Activity。Intent 对象会指定您想启动的现实
Activity 或描述您想举办的操作类型(系统会为你选取合适的
Activity,甚至是出自其余应用的 Activity)。 Intent
对象还可能指引少量供所启动 Activity 使用的数码。

在你的自有应用内行事时,您平日只必要启动某个已知 Activity。
您可以通过运用类名创造一个显式定义您想启动的 Activity 的 Intent
对象来兑现此目标。 例如,可以由此以下代码让一个 Activity
启动另一个名为 SignInActivity 的 Activity:

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);

而是,您的行使可能还需求利用你的 Activity
数据实施某项操作,例如发送电子邮件、短信或景况更新。
在那种情况下,您的利用自身或许不富有实践此类操作所需的
Activity,由此你可以改为利用设备上别样使用提供的 Activity
为你执行那么些操作。 那便是 Intent 对象的真的价值所在 — 您可以创造一个
Intent 对象,对你想举办的操作举办描述,系统会从其余使用启动相应的
Activity。 如若有五个 Activity 可以拍卖
Intent,则用户可以接纳要利用哪一个。
例如,假若你想同意用户发送电子邮件,可以创设以下 Intent:

Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);

添加到 Intent 中的 EXTRA_EMAIL extra
是一个字符串数组,其中带有应将电子邮件发送到的电子邮件地址。
当电子邮件选用响应此 Intent 时,它会读取 extra
中提供的字符串数组,并将它们放入电子邮件撰写窗体的“收件人”字段。
在那种情状下,电子邮件采纳的 Activity 启动,并且当用户完毕操作时,您的
Activity 会恢复生机执行。

4.在清单文件中注解Activity

你必须在清单文件中宣示您的 Activity,那样系统才能访问它。 要评释您的
Activity,请打开你的清单文件,并将 <activity> 元素添加为
<application> 元素的子项。例如:

<manifest ... >
  <application ... >
      <activity android:name=".ExampleActivity" />
      ...
  </application ... >
  ...
</manifest >

你仍是可以在此因素中参加多少个其他特色,以定义 Activity 标签、Activity
图标或风格主题等用于安装 Activity UI 风格的性质。 android:name
属性是唯一必需的习性—它指定 Activity
的类名。应用一旦公布,即不应更改此类名,否则,可能会破坏诸如应用神速格局等部分功效。

请参阅<activity>要素参考文档,了解关于在清单文件中声明Activity 的详细音讯。

起步 Activity 以博取结果

突发性,您或许要求从起步的 Activity 获得结果。在那种景色下,请通过调用
startActivityForResult()(而非startActivity())来启动 Activity。
要想在随之接受后续 Activity 的结果,请完毕
onActivityResult()回调方法。 当后续 Activity 已毕时,它会拔取 Intent
向您的 onActivityResult() 方法重临结果。
  例如,您或许希望用户挑选其中一位联系人,以便你的 Activity
对该联系人中的音讯举办某项操作。 您可以由此以下代码成立此类 Intent
并处理结果:

private void pickContact() {
        // Create an intent to "pick" a contact, as defined by the content provider URI
        Intent intent = new Intent(Intent.ACTION_PICK, Contacts.CONTENT_URI);
        startActivityForResult(intent, PICK_CONTACT_REQUEST);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the request went well (OK) and the request was PICK_CONTACT_REQUEST
    if (resultCode == Activity.RESULT_OK && requestCode == PICK_CONTACT_REQUEST) {
        // Perform a query to the contact's content provider for the contact's name
        Cursor cursor = getContentResolver().query(data.getData(),
        new String[] {Contacts.DISPLAY_NAME}, null, null, null);
        if (cursor.moveToFirst()) { // True if the cursor is not empty
            int columnIndex = cursor.getColumnIndex(Contacts.DISPLAY_NAME);
            String name = cursor.getString(columnIndex);
            // Do something with the selected contact's name...
        }    
    }
}

上例展现的是,您在处理 Activity 结果时应当在 onActivityResult()
方法中动用的中坚逻辑。第三个规格检查请求是不是成功(假如成功,则resultCode
将为RESULT_OK以及此结果响应的伸手是还是不是已知 —
在此情状下,requestCode与随 startActivityForResult()
发送的第一个参数匹配。 代码通过查询 Intent中回到的多少(data
参数)从该处开端拍卖 Activity 结果。
  实际景况是,ContentResolver 对一个情节提供程序执行查询,后者再次回到一个
Cursor,让查询的数据可见被读取。如需通晓详细新闻,请参阅情节提供程序文档。

如需精通有关 Intent 用法的详细信息,请参阅Intent 和 Intent
过滤器
文档。

开端 Activity 以博取结果

偶尔,您或许要求从起步的 Activity
得到结果。在这种景色下,请通过调用 startActivityForResult()(而非 startActivity())来启动
Activity。 要想在随之接受后续 Activity
的结果,请完毕 onActivityResult() 回调方法。 当后续 Activity
落成时,它会动用 Intent 向您的 onActivityResult() 方法重回结果。

诸如,您可能希望用户挑选其中一位联系人,以便你的 Activity
对该联系人中的新闻举行某项操作。 您可以由此以下代码成立此类 Intent
并处理结果:

private void pickContact() {
    // Create an intent to "pick" a contact, as defined by the content provider URI
    Intent intent = new Intent(Intent.ACTION_PICK, Contacts.CONTENT_URI);
    startActivityForResult(intent, PICK_CONTACT_REQUEST);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the request went well (OK) and the request was PICK_CONTACT_REQUEST
    if (resultCode == Activity.RESULT_OK && requestCode == PICK_CONTACT_REQUEST) {
        // Perform a query to the contact's content provider for the contact's name
        Cursor cursor = getContentResolver().query(data.getData(),
        new String[] {Contacts.DISPLAY_NAME}, null, null, null);
        if (cursor.moveToFirst()) { // True if the cursor is not empty
            int columnIndex = cursor.getColumnIndex(Contacts.DISPLAY_NAME);
            String name = cursor.getString(columnIndex);
            // Do something with the selected contact's name...
        }
    }
}

上例彰显的是,您在处理 Activity
结果时应有在 onActivityResult() 方法中动用的骨干逻辑。
首个规格检查请求是不是中标(倘使成功,则resultCode将为 RESULT_OK)以及此结果响应的伸手是还是不是已知

在此情景下,requestCode与随 startActivityForResult() 发送的第一个参数匹配。
代码通过查询Intent 中回到的数目(data 参数)从该处开首拍卖 Activity
结果。

实际上情形是,ContentResolver 对一个内容提供程序执行查询,后者再次回到一个 Cursor,让查询的数额可见被读取。如需询问详细新闻,请参阅情节提供程序文档。

如需通晓有关 Intent 用法的详细音讯,请参阅 Intent 和 Intent
过滤器
文档。

(1)使用 Intent 过滤器

<activity> 元素还可指定各样 Intent 过滤器—使用
<intent-filter> 元素—以宣称其余应用组件激活它的法子。
当您使用 Android SDK 工具创立新应用时,系统活动为您创制的存折 Activity
包涵一个 Intent 过滤器,其中申明了该 Activity
响应“主”操作且应放置“launcher”连串内。 Intent 过滤器的情节如下所示:

<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

<action> 元素指定那是选取的“主”入口点。<category> 元素指定此
Activity 应列入系统的选择启动器内(以便用户启动该 Activity)。

设若您打算让使用成为独立使用,不容许任何应用激活其
Activity,则您不需要任何其余 Intent 过滤器。 正如前例所示,只应有一个
Activity 具有“主”操作和“launcher”连串。 您不想提需求任何使用的 Activity
不应当别的 Intent 过滤器,您可以应用显式 Intent
自行启动它们(下文对此做了阐释)。

不过,即使你想让 Activity 对衍生自其他使用(以及你的自有采纳)的隐式
Intent 作出响应,则必须为 Activity 定义其余 Intent 过滤器。
对于你想要作出响应的每一个 Intent 类型,您都不可能不参预相应的
<intent-filter>,其中包括一个 <action>
元素,还可选用性地包罗一个 <category> 元素和/或一个 <data>
元素。这几个元素指定您的 Activity 可以响应的 Intent 类型。

如需精通有关您的 Activity 如何响应 Intent 的详细音信,请参阅Intent 和
Intent 过滤器
文档。

结束 Activity

你可以通过调用 Activity 的 finish() 方法来终止该
Activity。您还足以由此调用 finishActivity() 截至你事先启动的另一个
Activity。

注:在大部分状态下,您不应使用这一个艺术显式甘休 Activity。
正如下文有关 Activity 生命周期的有的所述,Android 系统会为你管理
Activity 的生命周期,由此你无需成功自己的 Activity。
调用这么些主意或者对预期的用户体验暴发不良影响,因而只应在您确实不想让用户再次来到此
Activity 实例时利用。

结束 Activity


你可以通过调用 Activity 的 finish() 方法来终止该
Activity。您还是可以通过调用 finishActivity() 截至你此前启动的另一个
Activity。

:在多数情况下,您不应使用这个办法显式截至 Activity。
正如下文有关 Activity 生命周期的有的所述,Android 系统会为您管理
Activity 的生命周期,因而你无需终止自己的 Activity。
调用这几个形式或者对预期的用户体验暴发不良影响,因而只应在您确实不想让用户重回此
Activity 实例时选拔。

5.启动Activity

你可以因此调用 startActivity(),并将其传递给描述您想启动的 Activity 的
Intent 来启动另一个 Activity。Intent 对象会指定您想启动的切实 Activity
或描述您想举行的操作类型(系统会为你选拔适当的
Activity,甚至是根源其余使用的 Activity)。 Intent
对象还可能辅导少量供所启动 Activity 使用的多少。

在你的自有利用内工作时,您不时只须要启动某个已知 Activity。
您能够经过应用类名创立一个显式定义您想启动的 Activity 的 Intent
对象来兑现此目标。 例如,可以由此以下代码让一个 Activity 启动另一个名为
SignInActivity 的 Activity:

Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);

可是,您的行使可能还亟需运用你的 Activity
数据实施某项操作,例如发送电子邮件、短信或状态更新。
在那种情状下,您的利用自身或许不享有履行此类操作所需的
Activity,因此你可以改为利用设备上其他使用提供的 Activity
为您执行这一个操作。 那便是 Intent 对象的真正价值所在 — 您可以创制一个
Intent 对象,对你想进行的操作进行描述,系统会从别的使用启动相应的
Activity。 假使有几个 Activity 可以处理
Intent,则用户可以选拔要动用哪一个。
例如,即使您想同意用户发送电子邮件,可以创建以下 Intent:

Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);

添加到 Intent 中的 EXTRA_EMAIL extra
是一个字符串数组,其中蕴涵应将电子邮件发送到的电子邮件地址。
当电子邮件采纳响应此 Intent 时,它会读取 extra
中提供的字符串数组,并将它们放入电子邮件撰写窗体的“收件人”字段。
在那种状态下,电子邮件采用的 Activity 启动,并且当用户完毕操作时,您的
Activity 会复苏执行。

管理 Activity 生命周期

由此完毕回调方法管理 Activity
的生命周期对开发强大而又利落的运用关键。 Activity
的生命周期会直接境遇 Activity 与其余Activity、其职务及再次回到栈的关联性的震慑。

Activity 基本上以二种情况存在:

  • Resumed

此 Activity
位于显示器前台并具有用户主题。(有时也将此情形叫做“运行中”。)

  • Paused

另一个 Activity 位于屏幕前台并保有用户主旨,但此 Activity
仍可知。也就是说,另一个 Activity 突显在此 Activity 上方,并且该
Activity 部分透明或未覆盖全体屏幕。 已暂停的 Activity 处于完全
Activity 状态(Activity
对象保留在内存中,它保留了具备意况和成员新闻,并与窗口管理器保持延续),但在内存出色不足的动静下,可能会被系统终止。

  • Stopped

该 Activity 被另一个 Activity 完全覆盖(该 Activity 方今位居“后台”)。
已偃旗息鼓的 Activity 同样仍居于 Activity 状态(Activity
对象保留在内存中,它保留了颇具情状和分子音信,但未与窗口管理器连接)。
然则,它对用户不再可知,在他处索要内存时可能会被系统终止。

假使 Activity 处于中断或终止状态,系统可经过需求其得了(调用其
finish()
方法)或直接终止其进度,将其从内存中删除。(将其得了或终止后)再度打开
Activity 时,必须重建。

管住 Activity 生命周期


经过落实回调方法管理 Activity
的生命周期对开发强大而又利落的选取关键。 Activity
的生命周期会直接面临 Activity 与任何
Activity、其职责及再次回到栈的关联性的熏陶。

Activity 基本上以二种情景存在:

继续
此 Activity 位于显示屏前台并有着用户宗旨。(有时也将此情况称为“运行中”。)

暂停
另一个 Activity 位于显示器前台并富有用户宗旨,但此 Activity
仍可知。也就是说,另一个 Activity 呈现在此 Activity 上方,并且该
Activity 部分透明或未覆盖全部显示器。 暂停的 Activity
处于完全活动状态(Activity 对象保留在内存中,它保留了所有景况和成员信息,并与窗口管理器保持一连),但在内存优秀不足的景况下,可能会被系统终止。

停止
该 Activity 被另一个 Activity 完全覆盖(该 Activity 近年来身处“后台”)。
已甘休的 Activity
同样仍处在活动状态(Activity 对象保留在内存中,它保留了独具情形和分子信息,但与窗口管理器连接)。
不过,它对用户不再可知,在他处须要内存时可能会被系统终止。

万一 Activity
处于中断或为止状态,系统可因此需求其得了(调用其 finish() 方法)或直接终止其进程,将其从内存中删除。(将其得了或停止后)再一次打开
Activity 时,必须重建。

6.起步 Activity 以博得结果

有时候,您或许须要从启动的 Activity 获得结果。在那种状态下,请通过调用
startActivityForResult()(而非 startActivity())来启动 Activity。
要想在随后接受后续 Activity 的结果,请完毕 onActivityResult() 回调方法。
当后续 Activity 完结时,它会选取 Intent 向你的 onActivityResult()
方法重返结果。

诸如,您或许希望用户挑选其中一位联系人,以便你的 Activity
对该联系人中的音讯进行某项操作。 您可以经过以下代码创设此类 Intent
并处理结果:

private void pickContact() {
    // Create an intent to "pick" a contact, as defined by the content provider URI
    Intent intent = new Intent(Intent.ACTION_PICK, Contacts.CONTENT_URI);
    startActivityForResult(intent, PICK_CONTACT_REQUEST);
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    // If the request went well (OK) and the request was PICK_CONTACT_REQUEST
    if (resultCode == Activity.RESULT_OK && requestCode == PICK_CONTACT_REQUEST) {
        // Perform a query to the contact's content provider for the contact's name
        Cursor cursor = getContentResolver().query(data.getData(),
        new String[] {Contacts.DISPLAY_NAME}, null, null, null);
        if (cursor.moveToFirst()) { // True if the cursor is not empty
            int columnIndex = cursor.getColumnIndex(Contacts.DISPLAY_NAME);
            String name = cursor.getString(columnIndex);
            // Do something with the selected contact's name...
        }
    }
}

上例突显的是,您在处理 Activity 结果时应当在 onActivityResult()
方法中使用的为主逻辑。
第二个原则检查请求是还是不是成功(借使成功,则resultCode 将为
RESULT_OK)以及此结果响应的请求是还是不是已知 — 在此意况下,requestCode与随
startActivityForResult() 发送的第四个参数匹配。 代码通过询问 Intent
中回到的数据(data 参数)从该处起先拍卖 Activity 结果。

其实情形是,ContentResolver 对一个情节提供程序执行查询,后者重临一个
Cursor,让查询的数据可见被读取。如需领悟详细音讯,请参阅内容提供程序文档。

兑现生命周期回调

当一个 Activity
转入和转出上述差距意况时,系统会经过各样回调方法向其爆发通报。
所有回调方法都是维系,您可以在 Activity
状态爆发变化时替代那一个关系来举行相应操作。 以下框架 Activity
包罗每一个骨干生命周期方法:

public class ExampleActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // The activity is being created.
    }    
    @Override
    protected void onStart() {
        super.onStart();
        // The activity is about to become visible.
    }
    @Override
    protected void onResume() {
        super.onResume(); 
       // The activity has become visible (it is now "resumed").
    }
    @Override protected void onPause() {
        super.onPause();
        // Another activity is taking focus (this activity is about to be "paused").
    }    
    @Override protected void onStop() {
        super.onStop(); 
       // The activity is no longer visible (it is now "stopped")
    } 
    @Override protected void onDestroy() {
        super.onDestroy();
        // The activity is about to be destroyed.
    }
}

那些措施共同定义 Activity 的成套生命周期。您能够透过兑现这个格局监控
Activity 生命周期中的五个嵌套循环:

  • Activity 的全部生命周期发生在 onCreate() 调用与 onDestroy()
    调用之间。您的 Activity 应在onCreate()
    中实践“全局”状态设置(例如定义布局),并释放 onDestroy()
    中的所有其余资源。例如,如果您的 Activity
    有一个在后台运行的线程,用于从互连网上下载数据,它可能会在
    onCreate() 中开创该线程,然后在 onDestroy() 中停止该线程。
  • Activity 的可见生命周期发生在 onStart() 调用与 onStop()
    调用之间。在这段时光,用户可以在显示屏上观看 Activity 并与其交互。
    例如,当一个新 Activity 启动,并且此 Activity 不再可见时,系统会调用
    onStop()。您可以在调用那四个艺术之间保留向用户体现 Activity
    所需的资源。 例如,您能够在 onStart() 中注册一个
    BroadcastReceiver 以监察影响 UI
    的更动,并在用户不能再来看您出示的情节时在 onStop()
    元帅其收回注册。在 Activity 的任何生命周期,当 Activity
    在对用户可知和隐身三种状态中交替变化时,系统或者会频仍调用
    onStart()onStop()
  • Activity 的前台生命周期发生在 onResume() 调用与 onPause()
    调用之间。在那段日子,Activity 位于显示屏上的持有其余 Activity
    此前,并富有用户输入焦点。 Activity
    可反复转入和转出前台—例如,当设备转入休眠状态或出现对话框时,系统会调用
    onPause()
    由于此情景恐怕时时爆发变动,由此这多少个主意中应运用适度轻量级的代码,以免止因变更速度慢而让用户等待。

图 1 认证了那几个循环以及 Activity
在情状转变时期可能因而的路径。矩形表示回调方法,当 Activity
在分化情形之间变更时,您可以兑现那几个格局来实施操作。

图片 2

图1. Activity生命周期

表 1
列出了相同的生命周期回调方法,其中对每一种回调方法做了更详细的叙述,并表达了每一种办法在
Activity 整个生命周期内的岗位,包括在回调方法成功后系统是不是终止
Activity。

方法 描述 是否能事后终止 后接
onCreate 首次创建 Activity 时调用。 您应该在此方法中执行所有正常的静态设置— 创建视图、将数据绑定到列表等等。系统向此方法传递一个 Bundle 对象,其中包含 Activity 的上一状态,不过前提是捕获了该状态(请参阅后文的保存 Activity 状态)。始终后接 onStart() onStart()
onRestart 在 Activity 已停止并即将再次启动前调用。始终后接 onStart() onStart()
onStart 在 Activity 即将对用户可见之前调用。如果 Activity 转入前台,则后接 onResume(),如果 Activity 转入隐藏状态,则后接 onStop()。 onResume()onStop()
onResume 在 Activity 即将开始与用户进行交互之前调用。 此时,Activity 处于 Activity 堆栈的顶层,并具有用户输入焦点。始终后接 onPause()。 onPause()
onPause 当系统即将开始继续另一个 Activity 时调用。 此方法通常用于确认对持久性数据的未保存更改、停止动画以及其他可能消耗 CPU 的内容,诸如此类。 它应该非常迅速地执行所需操作,因为它返回后,下一个 Activity 才能继续执行。如果 Activity 返回前台,则后接 onResume(),如果 Activity 转入对用户不可见状态,则后接onStop()。 onResume()onStop()
onStop Activity 对用户不再可见时调用。如果 Activity 被销毁,或另一个 Activity(一个现有 Activity 或新 Activity)继续执行并将其覆盖,就可能发生这种情况。如果 Activity 恢复与用户的交互,则后接onRestart(),如果 Activity 被销毁,则后接onDestroy()。 onRestart()onDestroy()
onDestroy 在 Activity 被销毁前调用。这是 Activity 将收到的最后调用。 当 Activity 结束(有人调用 Activity 上的 finish()),或系统为节省空间而暂时销毁该 Activity 实例时,可能会调用它。 您可以通过 isFinishing() 方法区分这两种情形。

名为“是或不是能事后停下?”的列表示系统是还是不是能在不执行另一行 Activity
代码的动静下,在艺术重回后随时终止承载 Activity 的长河。
有多个法子包蕴“是”标记:(onPause()onStop()onDestroy())。由于
onPause() 是那多少个章程中的第四个,因而 Activity 成立后,onPause()
必定成为最终调用的形式,然后才能终止进度——若是系统在急迫情状下必须恢复生机内存,则可能不会调用
onStop()onDestroy()。因而,您应该接纳 onPause()
向存储设备写入至关紧要的持久性数据(例如用户编辑)。不过,您应该对
onPause()
调用时期必须保留的消息享有取舍,因为该方法中的任何阻碍进度都会妨碍向下一个
Activity 的扭转并拖慢用户体验。
  在是还是不是能在此后甘休?列中标记为“否”的不二法门可从系统调用它们的少时起预防承载
Activity 的经过被终止。 因而,在从 onPause() 再次来到的日子到
onResume()被调用的时光,系统可以告一段落 Activity。在 onPause()
被再一次调用并重回前,将不能再次停下 Activity。

注:按照表 1 中的定义属于技术上无法“终止”的 Activity
仍可能被系统终止——但那种情状只有在无任何其他资源的无比气象下才会暴发。进度和线程处理文档对可能会终止
Activity 的场地做了更详实的阐释。

落成生命周期回调

当一个 Activity
转入和转出上述不同景况时,系统会经过种种回调方法向其发出布告。
所有回调方法都是关系,您可以在 Activity
状态爆发变化时替代这一个关系来实施相应操作。 以下框架 Activity
包涵每一个大旨生命周期方法:

public class ExampleActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // The activity is being created.
    }
    @Override
    protected void onStart() {
        super.onStart();
        // The activity is about to become visible.
    }
    @Override
    protected void onResume() {
        super.onResume();
        // The activity has become visible (it is now "resumed").
    }
    @Override
    protected void onPause() {
        super.onPause();
        // Another activity is taking focus (this activity is about to be "paused").
    }
    @Override
    protected void onStop() {
        super.onStop();
        // The activity is no longer visible (it is now "stopped")
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        // The activity is about to be destroyed.
    }
}

  

:正如以上示例所示,您在促成这么些生命周期方法时必须一向先调用超类达成,然后再履行此外操作。

这个措施共同定义 Activity 的全部生命周期。您可以透过完成这么些情势监控
Activity 生命周期中的七个嵌套循环:

  • Activity
    整个生命周期发生在 onCreate() 调用与 onDestroy() 调用之间。您的
    Activity
    应在 onCreate() 中进行“全局”状态设置(例如定义布局),并释放 onDestroy() 中的所有其他资源。例如,要是你的
    Activity
    有一个在后台运行的线程,用于从网络上下载数据,它可能会在 onCreate() 中创设该线程,然后在 onDestroy() 中停止该线程。
  • Activity
    看得出生命周期发生在 onStart() 调用与 onStop() 调用之间。在那段时日,用户可以在显示屏上收看
    Activity 并与其交互。 例如,当一个新 Activity 启动,并且此 Activity
    不再可知时,系统会调用 onStop()。您可以在调用那七个主意之间保留向用户显示Activity 所需的资源。
    例如,您可以在 onStart() 中注册一个 BroadcastReceiver 以监控影响
    UI
    的变型,并在用户不能再寓目你出示的情节时在 onStop() 元帅其废除注册。在
    Activity 的上上下下生命周期,当 Activity
    在对用户可见和隐藏二种景况中交替变化时,系统可能会反复调用 onStart() 和 onStop()

  • Activity
    前台生命周期发生在 onResume() 调用与 onPause() 调用之间。在那段时光,Activity
    位于显示屏上的享有其余 Activity 从前,并具备用户输入宗旨。 Activity
    可反复转入和转出前台 —
    例如,当设备转入休眠状态或出现对话框时,系统会调用 onPause()
    由于此境况恐怕时时发出变化,因而那七个点子中应利用适度轻量级的代码,以幸免因变更速度慢而让用户等待。

图 1 验证了那些循环以及 Activity
在场所转变时期可能由此的门路。矩形表示回调方法,当 Activity
在分歧情形之间转变时,您可以完结这一个点子来执行操作。

图片 3

图 1. Activity 生命周期。

表 1
列出了扳平的生命周期回调方法,其中对每一种回调方法做了更详实的描述,并证实了每一种方法在
Activity 整个生命周期内的地方,包括在回调方法成功后系统能不能终止
Activity。

表 1. Activity 生命周期回调方法汇总表。

方法

说明

是或不是能事后停下?

后接

onCreate()

首次创立 Activity 时调用。 您应该在此办法中实施所有正规的静态设置 —
成立视图、将数据绑定到列表等等。 系统向此方法传递一个 Bundle
对象,其中涵盖 Activity
的上一状态,可是前提是捕获了该情状(请参阅后文的保存 Activity
状态
)。

一向后接 onStart()

onStart()

    

onRestart()

在 Activity 已停止并即将再次启航前调用。

一向后接 onStart()

onStart()

onStart()

在 Activity 即将对用户可知从前调用。

万一 Activity 转入前台,则后接 onResume(),如若 Activity
转入隐藏状态,则后接 onStop()

onResume() 

onStop()

    

onResume()

在 Activity 即将上马与用户展开交互从前调用。 此时,Activity 处于
Activity 堆栈的顶层,并装有用户输入主题。

一向后接 onPause()

onPause()

onPause()

当系统即将开端一而再另一个 Activity 时调用。
此方法一般用于确认对持久性数据的未保存更改、截止动画以及别的可能损耗 CPU
的始末,诸如此类。 它应有分外便捷地执行所需操作,因为它回到后,下一个
Activity 才能继续执行。

设若 Activity 重回前台,则后接 onResume(),假使 Activity
转入对用户不可知状态,则后接onStop()

onResume() 

onStop()

onStop()

在 Activity 对用户不再可知时调用。要是 Activity 被销毁,或另一个
Activity(一个共处 Activity 或新
Activity)继续执行并将其遮住,就可能爆发那种境况。

若果 Activity 恢复生机与用户的互动,则后接 onRestart(),如果 Activity
被销毁,则后接onDestroy()

onRestart()

onDestroy()

onDestroy()

在 Activity 被销毁前调用。那是 Activity 将接收的末尾调用。 当 Activity
截止(有人对 Activity 调用了 finish()),或系统为节约空间而暂时销毁该
Activity 实例时,可能会调用它。
您可以由此 isFinishing() 方法分别那两种情景。

名为“是还是不是能事后停下?”的列表示系统是不是能在不举办另一行 Activity
代码的景况下,在方法重返后整日终止承载 Activity 的进度。 有多个法子带

有“是”标记:(onPause()onStop() 和 onDestroy())。由于 onPause() 是那三个点子中的第二个,由此Activity 成立后,onPause() 必定成为最终调用的法门,然后才能止住进度 —
假设系统在火急景况下必须復苏内存,则可能不会调用 onStop() 和 onDestroy()。因而,您应该运用 onPause() 向存储设备写入至关首要的持久性数据(例如用户编辑)。可是,您应该对 onPause() 调用期间必须保留的音信享有取舍,因为该方法中的任何阻拦进程都会妨碍向下一个
Activity 的扭转并拖慢用户体验。

是还是不是能在未来终止?列中标记为“否”的章程可从系统调用它们的少时起预防承载
Activity 的历程被截至。
因而,在从 onPause() 再次来到的时间到onResume() 被调用的时日,系统能够告一段落
Activity。在 onPause() 被重新调用并再次回到前,将不可能再一次停下 Activity。

:按照表 1 中的定义属于技术上无法“终止”的 Activity
仍可能被系统终止 —
但那种景色唯有在无其余其他资源的最好气象下才会发出。进程和线程处理文档对可能会告一段落
Activity 的场合做了更详实的论述。

7.结束Activity

您可以因而调用 Activity 的 finish() 方法来终止该
Activity。您还足以透过调用 finishActivity() 停止你事先启动的另一个
Activity。

注:在一大半意况下,您不应使用这几个主意显式为止 Activity。 正如下文有关
Activity 生命周期的一些所述,Android 系统会为您管理 Activity
的生命周期,因而你无需终止自己的 Activity。
调用那一个办法也许对预期的用户体验暴发不良影响,由此只应在你确实不想让用户再次回到此
Activity 实例时采纳。

保存 Activity 状态

管住 Activity 生命周期的引言部分简要提及,当 Activity
暂停或截至时,Activity 的情形会得到保留。 确实如此,因为当 Activity
暂停或为止时,Activity 对象仍保留在内存中 —
有关其成员和近年来场合的有着新闻仍居于 Activity 状态。 因而,用户在
Activity 内所做的任何改动都会取得保留,那样一来,当 Activity
重返前台(当它“继续”)时,这个改变依然存在。
  可是,当系统为了复苏内存而销毁某项 Activity 时,Activity
对象也会被灭绝,由此系统在后续 Activity
时根本不可能让其状态保持全体,而是必须在用户重返Activity时重建 Activity
对象。但用户并不知道系统销毁 Activity
后又对其举办了重建,由此他们很可能觉得 Activity 状态并非变化。
在那种状态下,您可以兑现另一个回调方法对关于 Activity
状态的音信举办封存,以管教有关 Activity
状态的重大音讯获取保留:onSaveInstanceState()
  系统会先调用 onSaveInstanceState(),然后再使 Activity
变得不难销毁。系统会向该措施传递一个 Bundle,您可以在里面使用
putString()putInt() 等方法以 名称-值(key-value)对方式保留有关
Activity 状态的新闻。然后,如若系统终止您的使用进度,并且用户再次来到您的
Activity,则系统会重建该 Activity,并将 Bundle 同时传递给 onCreate()
onRestoreInstanceState()。您可以选用上述任一方法从 Bundle
提取您保存的情事并上涨该 Activity
状态。借使没有动静新闻需求还原,则传递给你的 Bundle
是空值(假若是首次创制该 Activity,就会出现那种景观)。

图片 4

**图 2. **在两种情景下,Activity
重获用户要旨时可涵养状态完好:系统在销毁 Activity 后重建
Activity,Activity 必须恢复生机以前封存的意况;系统为止 Activity 后继续执行
Activity,并且 Activity 状态保持全部。

注:不可以保障系统会在销毁您的 Activity 前调用
onSaveInstanceState(),因为存在不须要保留意况的气象(例如用户采用“重返”
按钮离开你的 Activity 时,因为用户的表现是在显式关闭 Activity)。
假诺系统调用 onSaveInstanceState(),它会在调用 onStop()
在此之前,并且可能会在调用 onPause() 从前开展调用。

只是,固然你何以都不做,也不落到实处 onSaveInstanceState(),Activity 类的
onSaveInstanceState() 默许完毕也会还原部分 Activity
状态。具体地讲,默许完结会为布局中的每个 View 调用相应的
onSaveInstanceState()
方法,让各种视图都能提供关于自己的应保存信息。Android
框架中大致种种Widget都会依照须求贯彻此办法,以便在重建 Activity
时自动保存和回复对 UI 所做的其余可知更改。例如,EditText
Widget保存用户输入的其他文件,CheckBox
Widget保存复选框的当选或未当选状态。您只需为想要保存其情景的种种Widget提供一个唯一的
ID(通过 android:id 属性)。倘若Widget没有 ID,则系统无法保存其场合。

您还足以经过将 android:saveEnabled 属性设置为 “false” 或通过调用
setSaveEnabled()
方法显式阻止布局内的视图保存其情形。您平日不应将该属性禁用,但只要您想以差异方法苏醒Activity UI 的情景,就可能必要这么做。

尽管 onSaveInstanceState() 的默许落成会保留有关您的Activity UI
的有用音信,您可能仍需替代它以保存越来越多音讯。例如,您可能须求保留在
Activity 生命周期内暴发了变化的成员值(它们可能与 UI
中苏醒的值有提到,但默许景况下系统不会死灰复燃储存那个 UI 值的分子)。

由于 onSaveInstanceState() 的默许达成牵动保存 UI 的意况,
因而一旦你为了保存更加多景况新闻而重写该措施,应始终先调用
onSaveInstanceState() 的超类达成,然后再实施此外操作。同样,要是您代表
onRestoreInstanceState()
方法,也应调用它的超类落成,以便默许完毕可以东山再起视图状态。

注:由于不可以有限扶助系统会调用
onSaveInstanceState(),因而你只应选取它来记录 Activity 的须臾态(UI
的状态)—切勿使用它来存储持久性数据,而应拔取 onPause() 在用户距离
Activity 后存储持久性数据(例如应封存到数据库的多寡)。

你只需旋转设备,让屏幕方向爆发变化,就能管用地测试你的运用的处境苏醒能力。
当显示器方向变化时,系统会销毁并重建
Activity,以便利用可供新显示器配置利用的备用资源。 单凭这一理由,您的
Activity
在重建时是或不是完全苏醒其场合就显得煞是紧要,因为用户在行使应用时平日需要旋转屏幕。

保存 Activity 状态

治本 Activity
生命周期
的引言部分简要提及,当
Activity 暂停或终止时,Activity 的气象会取得保留。 确实如此,因为当
Activity 暂停或终止时,Activity 对象仍保留在内存中 —
有关其成员和如今景观的具有信息仍处于活动状态。 由此,用户在 Activity
内所做的此外变更都会获得保留,那样一来,当 Activity
再次回到前台(当它“继续”)时,这几个改动依旧存在。

唯独,当系统为了还原内存而销毁某项 Activity
时,Activity 对象也会被灭绝,由此系统在继承 Activity
时根本不可以让其情形保持完全,而是必须在用户再次来到 Activity
时重建 Activity 对象。但用户并不知道系统销毁 Activity
后又对其开展了重建,由此他们很可能觉得 Activity 状态并非变化。
在那种情景下,您可以兑现另一个回调方法对关于 Activity
状态的音讯举办封存,以管教有关 Activity
状态的最重要音讯得到保留:onSaveInstanceState()

系统会先调用 onSaveInstanceState(),然后再使 Activity
变得简单销毁。系统会向该措施传递一个 Bundle,您可以在里头使用 putString() 和putInt() 等措施以名称-值对方式保留有关
Activity 状态的音信。然后,假若系统终止您的行使进度,并且用户重返您的
Activity,则系统会重建该
Activity,并将 Bundle 同时传递给 onCreate() 和 onRestoreInstanceState()。您可以运用上述任一方法从 Bundle 提取您保存的气象并苏醒该
Activity
状态。要是没有动静音讯需求还原,则传递给您的 Bundle 是空值(即使是第一次创立该
Activity,就会产出这种气象)。

图片 5

图 2. 在二种处境下,Activity
重获用户大旨时可保持状态完好:系统在销毁 Activity 后重建
Activity,Activity 必须復苏此前封存的景色;系统截止 Activity 后继续执行
Activity,并且 Activity 状态保持完全。

:不可能保障系统会在销毁您的 Activity
前调用 onSaveInstanceState(),因为存在不须求保留情形的情景(例如用户选取“再次回到”按钮离开你的
Activity 时,因为用户的作为是在显式关闭
Activity)。 如果系统调用 onSaveInstanceState(),它会在调用 onStop() 以前,并且可能会在调用onPause() 从前进行调用。

而是,即便你怎么都不做,也不落到实处 onSaveInstanceState()Activity 类的 onSaveInstanceState() 默许落成也会复苏部分
Activity
状态。具体地讲,默认达成会为布局中的每个 View 调用相应的 onSaveInstanceState() 方法,让种种视图都能提供有关自己的应保存音信。Android
框架中大致各样小部件都会根据须求贯彻此方式,以便在重建 Activity
时自动保存和还原对 UI
所做的别的可知更改。例如,EditText 小部件保存用户输入的其余文件,CheckBox 小部件保存复选框的入选或未入选状态。您只需为想要保存其场合的每个小部件提供一个唯一的
ID(通过 android:id 属性)。若是小部件没有
ID,则系统不可能保存其状态。

您还足以由此将android:saveEnabled 属性设置为"false" 或通过调用setSaveEnabled() 方法显式阻止布局内的视图保存其情景。您平时不应将该属性停用,但假诺你想以不一样方法恢复生机Activity UI 的场馆,就可能须要如此做。

尽管 onSaveInstanceState() 的默许完成会保留有关您的Activity UI
的有用音讯,您或许仍需替换它以保存越来越多信息。例如,您可能必要保留在
Activity 生命周期内发生了变化的成员值(它们或者与 UI
中回复的值有提到,但默许景况下系统不会卷土重来储存这一个 UI 值的分子)。

由于 onSaveInstanceState() 的默许完成牵动保存 UI
的情况,因而一旦你为了保存越来越多情状音信而替换该方法,应始终先调用 onSaveInstanceState() 的超类完毕,然后再举行其余操作。
同样,如若您替换onRestoreInstanceState() 方法,也应调用它的超类落成,以便默认达成可以还原视图状态。

:由于无法有限支撑系统会调用 onSaveInstanceState(),因而你只应选用它来记录
Activity 的须臾态(UI 的状态)—
切勿使用它来存储持久性数据,而应选用 onPause() 在用户距离 Activity
后存储持久性数据(例如应封存到数据库的多寡)。

你只需旋转设备,让屏幕方向暴发变化,就能使得地测试你的行使的状态上涨能力。
当显示器方向转变时,系统会销毁一碗水端平建
Activity,以便利用可供新屏幕配置使用的备用资源。 单凭这一说辞,您的
Activity
在重建时能不能完全复苏其情形就突显煞是主要,因为用户在动用使用时平时索要旋转屏幕。

8.管理 Activity 生命周期

经过兑现回调方法管理 Activity
的生命周期对开发强大而又利落的采用紧要。 Activity
的生命周期会直接遭逢 Activity 与别的Activity、其职分及重临栈的关联性的震慑。

Activity 基本上以三种处境存在:

  • 继续
    此 Activity
    位于屏幕前台并有所用户宗旨。(有时也将此情状叫做“运行中”。)
  • 暂停
    另一个 Activity 位于显示器前台并富有用户主旨,但此 Activity
    仍可知。也就是说,另一个 Activity 突显在此 Activity 上方,并且该
    Activity 部分透明或未覆盖全体屏幕。 暂停的 Activity
    处于完全活动状态(Activity
    对象保留在内存中,它保留了装有意况和成员新闻,并与窗口管理器保持接二连三),但在内存万分不足的处境下,可能会被系统终止。
  • 停止
    该 Activity 被另一个 Activity 完全覆盖(该 Activity
    近来放在“后台”)。 已偃旗息鼓的 Activity 同样仍居于活动状态(Activity
    对象保留在内存中,它保留了富有景况和成员音讯,但未与窗口管理器连接)。
    可是,它对用户不再可知,在她处索要内存时可能会被系统终止。

一旦 Activity 处于中断或截至状态,系统可经过要求其得了(调用其 finish()
方法)或直接终止其经过,将其从内存中删除。(将其得了或甘休后)再度打开
Activity 时,必须重建。

拍卖配置变更

多少设备配备或者会在运行时爆发变化(例如屏幕方向、键盘可用性及言语)。
发生此类变化时,Android 会重建运行中的 Activity(系统调用
onDestroy(),然后马上调用
onCreate())。此行为目的在于通过使用你提供的备用资源(例如适用于不一致显示器方向和屏幕尺寸的不等布局)自动重新加载您的选取来帮衬它适应新布置。
  若是你对 Activity
进行了合适设计,让它可以按以上所述处理屏幕方向转变带来的重启并復苏Activity 状态,那么在备受 Activity
生命周期中的其余意外事件时,您的运用将兼具更强的适应性。
正如上文所述,处理此类重启的最佳艺术 是利用 onSaveInstanceState()
onRestoreInstanceState()(或onCreate())保存并还原 Activity
的气象。
  如需询问关于运行时发生的安插变更以及应对办法的详细音信,请阅读拍卖运行时变更指南。

拍卖配置变更

稍微设备配备或者会在运作时暴发变化(例如显示屏方向、键盘可用性及语言)。
暴发此类变化时,Android 会重建运行中的
Activity(系统调用onDestroy(),然后随即调用 onCreate())。此行为意在通过运用你提供的备用资源(例如适用于不一致显示器方向和显示器尺寸的不等布局)自动重新加载您的使用来救助它适应新布局。

倘若你对 Activity
举行了恰当设计,让它亦可按上述所述处理屏幕方向变化带来的重启并还原
Activity 状态,那么在蒙受 Activity
生命周期中的其他意外事件时,您的接纳将拥有更强的适应性。

正如上文所述,处理此类重启的特级方法是行使onSaveInstanceState() 和 onRestoreInstanceState()(或 onCreate())保存并回复
Activity 的意况。

如需了解关于运行时发出的安插变更以及应对格局的详细音讯,请阅读拍卖运行时变更指南。

9.落到实处注明周期回调

当一个 Activity
转入和转出上述差距情况时,系统会透过各类回调方法向其发生通报。所有回调方法都是联系,您可以在
Activity 状态暴发变化时替代这几个关系来执行相应操作。以下框架 Activity
包罗每一个主导生命周期方法:

public class ExampleActivity extends Activity {    
        @Override   
        public void onCreate(Bundle savedInstanceState) {        
            super.onCreate(savedInstanceState);        
            // The activity is being created.    
        }    

        @Override    
        protected void onStart(){       
            super.onStart();        
            // The activity is about to become visible.    
        }    
       @Override   
       protected void onResume() {       
           super.onResume();        
          // The activity has become visible (it is now "resumed").    
       }   
       @Override    
       protected void onPause(){        
           super.onPause();        
           // Another activity is taking focus (this activity is about to be "paused").    
       }    
       @Override    
       protected void onStop() {        
           super.onStop();       
          // The activity is no longer visible (it is now "stopped")    
       }    
       @Override    
       protected void onDestroy() {        
           super.onDestroy();        
          // The activity is about to be destroyed.   
       }
    }

:正如以上示例所示,您在已毕那个生命周期方法时务必始终先调用超类已毕,然后再实施别的操作。

那个格局共同定义 Activity 的漫天生命周期。您可以经过达成这个办法监控
Activity 生命周期中的多个嵌套循环:

  • Activity
    整整生命周期暴发在onCreate()调用与onDestroy()调用之间。您的
    Activity
    应在onCreate()中执行“全局”状态设置(例如定义布局),并释放onDestroy()中的所有其余资源。例如,假使你的
    Activity
    有一个在后台运行的线程,用于从互联网上下载数据,它或许会在onCreate()中开创该线程,然后在onDestroy()中截止该线程。
  • Activity
    可知生命周期发出在onStart()调用与onStop()调用之间。在那段时日,用户可以在显示屏上收看
    Activity 并与其交互。例如,当一个新 Activity 启动,并且此 Activity
    不再可知时,系统会调用onStop()。您可以在调用那多个办法之间保留向用户浮现Activity
    所需的资源。例如,您可以在onStart()中注册一个BroadcastReceiver以监控影响
    UI的变动,并在用户不可以再见到您出示的内容时在onStop()中将其取消注册。在Activity
    的凡事生命周期,当 Activity
    在对用户可知和隐藏二种景况中交替变化时,系统或许会一再调用onStart()和onStop()。
  • Activity
    前台生命周期发出在onResume()调用与onPause()调用之间。在那段时日,Activity
    位于屏幕上的具有其余 Activity 此前,并装有用户输入宗旨。Activity
    可反复转入和转出前台 —
    例如,当设备转入休眠状态或出现对话框时,系统会调用onPause()。由于此境况恐怕时时发出转移,由此那七个措施中应使用适度轻量级的代码,以免止因变更速度慢而让用户等待。

图 1 认证了那些循环以及 Activity
在意况转变时期可能通过的不二法门。矩形表示回调方法,当 Activity
在分裂意况之间浮动时,您可以兑现那些形式来施行操作。

图片 6

图 1. Activity 生命周期。

表 1
列出了相同的生命周期回调方法,其中对每一种回调方法做了更详细的讲述,并证实了每一种艺术在
Activity 整个生命周期内的任务,包涵在回调方法成功后系统能否终止
Activity。

表 1. Activity 生命周期回调方法汇总表。

图片 7

名为“是不是能事后甘休?”的列表示系统是还是不是能在不实施另一行 Activity
代码的事态下,在艺术重返后随时终止承载 Activity
的经过。有七个点子包括“是”标记:(onPause()、onStop()和onDestroy())。由于onPause()是那七个措施中的首个,因此Activity 创设后,onPause()必定成为终极调用的不二法门,然后才能止住进程 —
倘诺系统在火急情形下必须苏醒内存,则可能不会调用onStop()和onDestroy()。因此,您应该采用onPause()向存储设备写入至关首要的持久性数据(例如用户编辑)。不过,您应该对onPause()调用时期总得保留的音讯具有接纳,因为该方法中的任何阻碍进度都会妨碍向下一个
Activity 的扭转并拖慢用户体验。

是不是能在随后终止?列中标记为“否”的章程可从系统调用它们的说话起预防承载
Activity
的历程被截至。由此,在从onPause()重回的岁月到onResume()被调用的时辰,系统可以告一段落
Activity。在onPause()被再次调用并再次回到前,将不可能再度停下 Activity。

:按照表1中的定义属于技术上不能够“终止”的 Activity
仍可能被系统终止 —
但那种情景唯有在无任何其余资源的极端气象下才会爆发。进度和线程处理文档对可能会停下
Activity 的图景做了更详实的阐发。

协调 Activity

当一个 Activity 启动另一个 Activity 时,它们都会经历生命周期转变。第三个Activity
暂停并停止(但只要它在后台照旧可知,则不会终止)时,系统会创建另一个
Activity。 要是这一个 Activity
共用保存到磁盘或任啥地点方的多少,必须询问的是,在开创第一个 Activity
前,第二个 Activity 不会全盘终止。更适用地说,启动第一个 Activity
的长河与甘休第三个 Activity 的长河存在重叠。
  生命周期回调的一一经过明确定义,当三个 Activity
位于同一进度,并且由一个 Activity 启动另一个 Activity
时,其定义尤其引人侧目。 以下是当 Activity A 启动 Activity B
时一名目繁多操作的发出顺序:

  1. Activity A 的 onPause() 方法执行。
  2. Activity B 的 onCreate()onStart()onResume()
    方法依次执行。(Activity B 现在享有用户宗旨。)
  3. 接下来,假使 Activity A 在屏幕上不再可知,则其 onStop() 方法执行。

您可以运用那种可预测的生命周期回调顺序管理从一个 Activity 到另一个
Activity 的消息变化。 例如,假设你必须在率先个 Activity
甘休时向数据库写入数据,以便下一个 Activity 可以读取该数量,则应在
onPause() 而不是 onStop() 执行时期向数据库写入数据。

协调 Activity

当一个 Activity 启动另一个 Activity
时,它们都会感受到生命周期转变。首个 Activity
暂停并截止(但如若它在后台仍旧可知,则不会告一段落)时,同时系统会创制另一个
Activity。 即使那几个 Activity
共用保存到磁盘或其余地方的多寡,必须询问的是,在开创第三个 Activity
前,首个 Activity 不会全盘停下。更适于地说,启动首个 Activity
的历程与为止第三个 Activity 的长河存在重叠。

生命周期回调的各种经过明确定义,当七个 Activity 位于同一进度,并且由一个
Activity 启动另一个 Activity 时,其定义越发明显。 以下是当 Activity A
启动 Activity B 时一二种操作的发出顺序:

  1. Activity A 的 onPause() 方法执行。
  2. Activity B
    的 onCreate()onStart() 和 onResume() 方法依次执行。(Activity
    B 现在持有用户主题。)
  3. 接下来,假若 Activity A 在显示屏上不再可知,则其 onStop() 方法执行。

你可以使用那种可预测的生命周期回调顺序管理从一个 Activity 到另一个
Activity 的信息变化。 例如,若是你必须在率先个 Activity
为止时向数据库写入数据,以便下一个 Activity
可以读取该数量,则应在 onPause() 而不是 onStop() 执行时期向数据库写入数据。

 

摘自Android官方文档:https://developer.android.google.cn/guide/components/activities.html

 

Activity连串小说:

Android之Activity连串统计(一)–Activity概览

Android之Activity系列统计(二)–义务和重回栈

Android
旋转屏幕–处理Activity与AsyncTask的超级解决方案
(处理运行时变更)

 Activity之概览显示器(Overview
Screen)

10.保存 Activity 状态

管理 Activity 生命周期的引言部分简要提及,当 Activity
暂停或终止时,Activity 的状态会收获保留。确实如此,因为当 Activity
暂停或终止时,Activity对象仍保存在内存中 —
有关其成员和方今状态的保有音讯仍处在活动状态。由此,用户在 Activity
内所做的别样改动都会博得保留,这样一来,当 Activity
重临前台(当它“继续”)时,这几个改动依旧存在。

不过,当系统为了苏醒内存而销毁某项 Activity
时,Activity对象也会被销毁,因而系统在三番一回 Activity
时根本不可能让其情状保持完全,而是必须在用户重回 Activity
时重建Activity对象。但用户并不知道系统销毁 Activity
后又对其开展了重建,因而他们很可能以为 Activity
状态并非变化。在那种情景下,您可以兑现另一个回调方法对有关 Activity
状态的新闻进行保存,以保证有关 Activity
状态的基本点消息得到保留:onSaveInstanceState()。

系统会先调用onSaveInstanceState(),然后再使 Activity
变得简单销毁。系统会向该方式传递一个Bundle,您可以在其间使用putString()和putInt()等办法以名称-值对形式保留有关
Activity 状态的新闻。然后,借使系统终止您的选择进度,并且用户再次来到您的
Activity,则系统会重建该
Activity,并将Bundle同时传递给onCreate()和onRestoreInstanceState()。您可以利用上述任一方法从Bundle提取您保存的场地并復苏该
Activity
状态。即使没有动静新闻须求还原,则传递给你的Bundle是空(若是是首次创制该
Activity,就会出现那种意况)。

图片 8

图 2. 在两种状态下,Activity 重获用户主旨时可涵养状态完好:系统在销毁
Activity 后重建 Activity,Activity 必须苏醒此前封存的场合;系统甘休Activity 后继续执行 Activity,并且 Activity 状态保持全部。

:不可能有限支持系统会在销毁您的 Activity
前调用onSaveInstanceState(),因为存在不需要保留意况的情事(例如用户接纳“重回”按钮离开你的
Activity 时,因为用户的作为是在显式关闭
Activity)。**一旦系统调用onSaveInstanceState(),它会在调用onStop()以前,并且可能会在调用onPause()以前开展调用。

但是,即便你何以都不做,也不落实onSaveInstanceState(),Activity类的onSaveInstanceState()默许完毕也会回复部分
Activity
状态。具体地讲,默许落成会为布局中的每个View调用相应的onSaveInstanceState()方法,让各样视图都能提供关于自己的应保存新闻。Android框架中大约每个小部件都会基于须要达成此格局,以便在重建
Activity 时自动保存和苏醒对 UI所做的其它可知更改。例如,EditText
小部件保存用户输入的此外文件,CheckBox小部件保存复选框的当选或未当选状态。您只需为想要保存其景况的种种小部件提供一个唯一的
ID(通过 android:id
属性)。如果小部件没有 ID,则系统不能够保存其情景。

你还能透过将android:saveEnabled属性设置为”false”或透过调用setSaveEnabled()方法显式阻止布局内的视图保存其情状。您平时不应将该属性停用,但假设你想以分歧格局复苏Activity UI的意况,就可能需求那样做。

即便onSaveInstanceState()的默许已毕会保留有关您的Activity
UI的有用音讯,您可能仍需替换它以保存更加多音信。例如,您可能要求保留在
Activity 生命周期内发出了变更的成员值(它们或者与UI
中平复的值有关系,但默许景况下系统不会过来储存那些 UI值的积极分子)。
出于onSaveInstanceState()的默认已毕牵动保存 UI
的景况,因而如果你为了保存越来越多处境音信而替换该办法,应始终先调用onSaveInstanceState()的超类完结,然后再实践此外操作。同样,假使你替换onRestoreInstanceState()方法,也应调用它的超类完结,以便默许达成可以还原视图状态。

:由于不可以有限支撑系统会调用onSaveInstanceState()
,因而你只应使用它来记录 Activity 的刹那态(UI的情状)—
切勿使用它来储存持久性数据,而应选择onPause()在用户距离 Activity
后存储持久性数据(例如应封存到数据库的数额)。

您只需旋转设备,让显示屏方向暴发变化,就能有效地测试你的行使的图景上涨能力。当屏幕方向变化时,系统会销毁相提并论建
Activity,以便利用可供新显示屏配置使用的备用资源。单凭这一说辞,您的
Activity
在重建时是还是不是完全復苏其景况就浮现极度紧要,因为用户在行使应用时日常须要旋转屏幕。

11.甩卖配置变更

多少设备配备或者会在运行时暴发变化(例如屏幕方向、键盘可用性及语言)。暴发此类变化时,Android
会重建运行中的
Activity(系统调用onDestroy(),然后随即调用onCreate())。此行为目的在于通过运用你提供的备用资源(例如适用于差距显示器方向和显示屏尺寸的两样布局)自动重新加载您的行使来接济它适应新安插。
比方您对 Activity
举行了适宜设计,让它能够按以上所述处理显示器方向转变带来的重启并回升Activity 状态,那么在遭遇 Activity
生命周期中的其他意外事件时,您的使用将有所更强的适应性。

正如上文所述,处理此类重启的顶尖艺术是选拔onSaveInstanceState()和onRestoreInstanceState()(或onCreate())保存并上升Activity 的气象。

如需询问有关运行时发出的安插变更以及应对方法的详细音讯,请阅读拍卖运行时变更指南

12.协调 Activity

当一个 Activity 启动另一个 Activity
时,它们都会感受到生命周期转变。第四个 Activity
暂停并截至(但要是它在后台依旧可知,则不会为止)时,同时系统会创设另一个
Activity。固然那一个 Activity
共用保存到磁盘或任哪里方的数码,必须询问的是,在成立第四个 Activity
前,第二个 Activity 不会完全停止。更贴切地说,启动第四个 Activity
的进度与甘休首个 Activity 的进度存在重叠。

生命周期回调的相继经过明确定义,当多个 Activity 位于同一进程,并且由一个
Activity 启动另一个 Activity 时,其定义尤其引人侧目。以下是当 Activity A启动
Activity B 时一多重操作的暴发顺序:
(1)Activity A 的onPause()方法执行。
(2)Activity B
的onCreate()、onStart()和onResume()方法依次执行。(Activity B
现在所有用户大旨。)
(3)然后,即使 Activity A 在屏幕上不再可见,则其onStop()方法执行。

您可以选拔那种可预测的生命周期回调顺序管理从一个 Activity 到另一个
Activity 的音讯变更。例如,假诺你必须在第三个 Activity
为止时向数据库写入数据,以便下一个 Activity
可以读取该数量,则应在onPause()而不是onStop()执行时期向数据库写入数据。

参考文档:
Android官方文档–Activity

相关文章