Android活动生命周期——这些方法都是干什么用的?

Android活动的生命周期是什么?为什么在初始化过程中调用这么多类似的方法(onCreate()， onStart()， onResume())，而在初始化结束时调用这么多其他方法(onPause()， onStop()， onDestroy()) ?

什么时候调用这些方法，应该如何正确地使用它们?

322353 次浏览
小开

在Android开发者页面，

onPause ():

当系统即将开始恢复前一个活动时调用。 这通常用于将未保存的更改提交到持久数据， 停止动画和其他可能消耗CPU的东西，等等。 这个方法的实现必须非常快，因为接下来 直到此方法返回，活动才会恢复。紧随其后的是 onResume()如果活动返回到前面，或者

. onStop()如果它对用户不可见

原():

当活动对用户不再可见时调用，因为 另一项活动已经恢复，正在处理这一事件。这可能 发生的原因可能是一个新的活动正在启动，也可能是一个现有的活动 被带到这个面前，或者这个被摧毁。 如果此活动返回，则后面跟着onRestart() 与用户交互，或者onDestroy()如果这个活动消失

现在假设有三个活动，你从A到B，然后onPause of A将被调用，现在从B到C，然后onPause of B和onStop of A将被调用。

暂停的活动得到恢复，停止的活动得到重新启动。

当你调用this.finish()时，onPause-onStop-onDestroy将被调用。需要记住的主要事情是:当Android需要内存用于其他操作时，暂停的活动将被停止，停止的活动将被销毁。

我希望这足够清楚了。

小开
最佳答案

在活动生命周期(在Android开发者)中可以看到它。

Enter image description here

onCreate():

当activity第一次创建时调用。这就是你应该做的 所有常规的静态设置:创建视图，绑定数据到列表， 等。该方法还为您提供了一个包含 之前的冻结状态，如果有的话。总是跟着 通过onStart () . < / p >

onRestart():

在你的活动被停止后，在它被启动之前被调用 一次。后面总是跟着onStart()

onStart():

当活动对用户可见时调用。紧随其后的是

. onResume()如果活动来到前台

onResume():

当activity开始与用户交互时调用。在这 指向你的activity是在activity栈的顶部，与user 输入到它。后面总是跟着onPause().

.

.

onPause ():

当活动正在进行时，作为活动生命周期的一部分被调用 进入背景， 但还没有被杀死。对应onResume()。 当活动B在活动A之前启动时，此回调将在活动A上调用。 在A的onPause()返回之前不会创建B，所以请确保不要这样做

onStop():

当你对用户不再可见时调用。下一个是你 接收onRestart()， onDestroy()，或什么都没有，取决于 以后的用户活动。 注意，在内存不足的情况下，这个方法可能永远不会被调用 系统没有足够的内存来保存您的活动 在onPause()方法调用后运行的进程

onDestroy():

在activity被销毁之前你收到的最后一个电话。这 都可能发生，因为活动正在结束(有人呼叫 Finish()处理它，或者因为系统正在暂时销毁它 活动实例以节省空间。你可以用isFinishing()方法来区分这两种情况

当活动首次负载调用事件时，如下所示:

onCreate()
onStart()
onResume()

当你点击电话按钮活动转到后台，下面的事件被调用:

onPause()
onStop()

退出电话拨号器和下面的事件将被调用:

onRestart()
onStart()
onResume()

当你点击后退按钮或尝试完成()活动时，事件被调用如下:

onPause()
onStop()
onDestroy()

活动状态

Android操作系统使用优先级队列来帮助管理设备上运行的活动。基于特定的Android活动所处的状态，它将在操作系统中被分配特定的优先级。这个优先级系统帮助Android识别不再使用的活动，允许操作系统回收内存和资源。下图说明了一个活动在其生命周期内可以经历的状态:

这些状态可以分为以下三大类:

活动或运行中 -如果活动在前台，也称为活动堆栈的顶部，则它们被认为是活动的或正在运行的。这被认为是Android activity堆栈中最高优先级的活动，因此只有在极端情况下才会被OS杀死，比如如果活动试图使用比设备上可用的内存更多的内存，因为这可能会导致UI变得无响应。

停顿了一下 -当设备进入睡眠状态，或者一个活动仍然可见，但部分被一个新的、非全尺寸或透明的活动隐藏，该活动被认为是暂停的。暂停的活动仍然是活动的，也就是说，它们维护所有的状态和成员信息，并且仍然连接到窗口管理器。这被认为是Android activity栈中第二高优先级的活动，因此，只有当杀死这个活动满足了保持活动/运行活动稳定和响应所需的资源需求时，才会被操作系统杀死。

停止 -被另一个活动完全遮蔽的活动被认为是停止的或在后台。已停止的活动仍然试图尽可能长时间地保留其状态和成员信息，但已停止的活动被认为是三个状态中优先级最低的，因此，操作系统将首先终止处于该状态的活动，以满足更高优先级活动的资源需求。

*取样活动以了解生命周期**

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class MainActivity extends Activity {
String tag = "LifeCycleEvents";
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.d(tag, "In the onCreate() event");
}
public void onStart()
{
super.onStart();
Log.d(tag, "In the onStart() event");
}
public void onRestart()
{
super.onRestart();
Log.d(tag, "In the onRestart() event");
}
public void onResume()
{
super.onResume();
Log.d(tag, "In the onResume() event");
}
public void onPause()
{
super.onPause();
Log.d(tag, "In the onPause() event");
}
public void onStop()
{
super.onStop();
Log.d(tag, "In the onStop() event");
}
public void onDestroy()
{
super.onDestroy();
Log.d(tag, "In the onDestroy() event");
}
}
小开

造成整个混乱的原因是谷歌选择了非直观的名称，而不是如下所示:

onCreateAndPrepareToDisplay()   [instead of onCreate() ]
onPrepareToDisplay()            [instead of onRestart() ]
onVisible()                     [instead of onStart() ]
onBeginInteraction()            [instead of onResume() ]
onPauseInteraction()            [instead of onPause() ]
onInvisible()                   [instead of onStop]
onDestroy()                     [no change]

活动图可以解释为:

enter image description here

小开

ANDROID生命周期

有7种方法可以管理Android应用程序的生命周期:

  • < a href = " http://developer.android.com/reference/android/app/Activity.html onCreate % 28 android.os.bundle % 29”> <强> < em > onCreate () < / em > < /强> < / >
  • < a href = " http://developer.android.com/reference/android/app/Activity.html onStart % 28% 29”> <强> < em > onStart () < / em > < /强> < / >
  • < a href = " http://developer.android.com/reference/android/app/Activity.html onResume % 28% 29”> <强> < em > onResume () < / em > < /强> < / >
  • < a href = " http://developer.android.com/reference/android/app/Activity.html onRestart % 28% 29”> <强> < em > onRestart () < / em > < /强> < / >
  • < a href = " http://developer.android.com/reference/android/app/Activity.html onPause % 28% 29”> <强> < em > onPause () < / em > < /强> < / >
  • < a href = " http://developer.android.com/reference/android/app/Activity.html原% 28% 29”> <强> < em >原()< / em > < /强> < / >
  • < a href = " http://developer.android.com/reference/android/app/Activity.html onDestroy % 28% 29”> <强> < em > onDestroy () < / em > < /强> < / >

回答所有这些方法都是为了什么:

让我们以一个简单的场景为例，在这个场景中，了解这些方法的调用顺序将有助于我们清楚地了解为什么要使用它们。

    假设你正在使用一个计算器应用程序。调用了三个方法 连续启动应用程序。

__abc3 __abc4 __abc5 __abc4 __abc7

    当我正在使用计算器应用程序时，突然一个电话来了。 计算器活动转到后台，另一个活动说。 对调用的处理出现在前台，现在有两个方法

__abc2 __abc3 __abc4

    现在假设我完成了电话上的对话，计算器 Activity从后台进入前台，有三种方法

__abc3 __abc4 __abc5 __abc4 __abc7

    最后，假设我已经完成了计算器应用程序中的所有任务，并且我 . . .

__abc2 __abc3 __abc4

一个活动可能存在四种状态:

  • 开始状态
  • 运行状态
  • 暂停状态
  • 停止状态

起始状态包括:

创建一个新的Linux进程，为新的UI对象分配新的内存，并设置整个屏幕。大部分的工作都在这里。

运行状态包括:

它是当前在屏幕上的活动(状态)。这个状态单独处理一些事情，比如在屏幕上输入，触摸&点击按钮。

暂停状态包括:

当一个活动不在前台，而是在后台时，该活动被称为处于暂停状态。

停止状态包括:

一个停止的活动只能通过重新启动才能被买到前台，而且它可以在任何时间点被销毁。

活动管理器以这样一种方式处理所有这些状态，即使在将新活动添加到现有活动的场景中，用户体验和性能也始终处于最佳状态

小开

活动有六个状态

  • 创建
  • 开始
  • 恢复
  • 停顿了一下
  • 停止
  • 摧毁了

活动的生命周期有7个方法

  • onCreate()
  • onStart()
  • onResume()
  • onPause()
  • onStop()
  • onRestart()
  • onDestroy()

活动生命周期

的情况下

  • < p > 当打开应用程序时

    onCreate() --> onStart() -->  onResume()

  • When back button pressed and exit the app

    onPaused() -- > onStop() --> onDestory()

  • When home button pressed 

    onPaused() --> onStop()

  • After pressed home button when again open app from recent task list or clicked on icon

    onRestart() --> onStart() --> onResume()

  • When open app another app from notification bar or open settings

    onPaused() --> onStop()

  • Back button pressed from another app or settings then used can see our app

    onRestart() --> onStart() --> onResume()

  • When any dialog open on screen

    onPause()

  • After dismiss the dialog or back button from dialog 

    onResume()

  • Any phone is ringing and user in the app

    onPause() --> onResume()

  • When user pressed phone's answer button

    onPause()

  • After call end 

    onResume()

  • When phone screen off

    onPaused() --> onStop()

  • When screen is turned back on

    onRestart() --> onStart() --> onResume()
小开

我喜欢这个问题和它的答案，但到目前为止，还没有覆盖不太常用的回调，如< em > onPostCreate () < / em >或< em > onPostResume () < / em >。Steve Pomeroy尝试了一个图表，包括这些，以及它们与Android的片段生命周期的关系，在https://github.com/xxv/android-lifecycle。我修改了Steve的大图表，只包括活动部分，并将其格式化为字母大小的一页打印输出。我已经将它作为文本PDF发布在https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf，下面是它的图像:

Android Activity Lifecycle

小开

在高评分的答案上添加了一些更多的信息(增加了KILLABLE和下一组方法的额外部分，这将在生命周期中被调用):

来源:developer.android.com

enter image description here

注意上表中的“Killable”列——对于那些标记为可杀死的方法，在该方法返回后，承载该活动的进程可能在任何时候被系统杀死，而无需执行它的另一行代码。

因此，您应该使用onPause()方法将任何持久数据(例如用户编辑)写入存储。此外，方法onSaveInstanceState(Bundle)在将活动置于这样的后台状态之前被调用，允许你将活动中的任何动态实例状态保存到给定的Bundle中，以便稍后在onCreate(Bundle)中接收，如果活动需要重新创建。

请注意，将持久数据保存在onPause()而不是onSaveInstanceState(Bundle)中是很重要的，因为后者不是生命周期回调的一部分，因此不会像其文档中描述的那样在每种情况下被调用。

我想再添加几个方法。这些方法没有被列为生命周期方法，但根据某些条件，它们将在生命周期中被调用。根据您的需求，您可能必须在应用程序中实现这些方法以正确处理状态。

onPostCreate(Bundle savedInstanceState)

当活动启动完成时调用(在onStart()和onRestoreInstanceState(Bundle)被调用之后)。

onPostResume()

当活动恢复完成时调用(在onResume()被调用之后)。

onSaveInstanceState(Bundle outState)

调用该方法在活动被杀死之前从活动中检索每个实例的状态，以便状态可以在onCreate(Bundle)或onRestoreInstanceState(Bundle)中恢复(由此方法填充的Bundle将被传递给两者)。

onRestoreInstanceState(Bundle savedInstanceState)

此方法在onStart()之后调用，当活动从先前保存的状态重新初始化时，在这里的savedInstanceState中给出。

我的应用程序代码使用所有这些方法:

public class MainActivity extends AppCompatActivity implements View.OnClickListener{


private EditText txtUserName;
private EditText txtPassword;
Button  loginButton;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d("Ravi","Main OnCreate");
txtUserName=(EditText) findViewById(R.id.username);
txtPassword=(EditText) findViewById(R.id.password);
loginButton =  (Button)  findViewById(R.id.login);
loginButton.setOnClickListener(this);


}


@Override
public void onClick(View view) {
Log.d("Ravi", "Login processing initiated");
Intent intent = new Intent(this,LoginActivity.class);
Bundle bundle = new Bundle();
bundle.putString("userName",txtUserName.getText().toString());
bundle.putString("password",txtPassword.getText().toString());
intent.putExtras(bundle);
startActivityForResult(intent,1);
// IntentFilter
}
public void onActivityResult(int requestCode, int resultCode, Intent resIntent){
Log.d("Ravi back result:", "start");
String result = resIntent.getStringExtra("result");
Log.d("Ravi back result:", result);
TextView txtView = (TextView)findViewById(R.id.txtView);
txtView.setText(result);


Intent sendIntent = new Intent();
//sendIntent.setPackage("com.whatsapp");
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "Message...");
sendIntent.setType("text/plain");
startActivity(sendIntent);
}


@Override
protected void onStart() {
super.onStart();
Log.d("Ravi","Main Start");
}


@Override
protected void onRestart() {
super.onRestart();
Log.d("Ravi","Main ReStart");
}


@Override
protected void onPause() {
super.onPause();
Log.d("Ravi","Main Pause");
}


@Override
protected void onResume() {
super.onResume();
Log.d("Ravi","Main Resume");
}


@Override
protected void onStop() {
super.onStop();
Log.d("Ravi","Main Stop");
}


@Override
protected void onDestroy() {
super.onDestroy();
Log.d("Ravi","Main OnDestroy");
}


@Override
public void onPostCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
super.onPostCreate(savedInstanceState, persistentState);
Log.d("Ravi","Main onPostCreate");
}


@Override
protected void onPostResume() {
super.onPostResume();
Log.d("Ravi","Main PostResume");
}


@Override
public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
super.onSaveInstanceState(outState, outPersistentState);
}


@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
}
}

登录活动:

public class LoginActivity extends AppCompatActivity {


private TextView txtView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_login);
txtView = (TextView) findViewById(R.id.Result);
Log.d("Ravi","Login OnCreate");
Bundle bundle = getIntent().getExtras();
txtView.setText(bundle.getString("userName")+":"+bundle.getString("password"));
//Intent  intent = new Intent(this,MainActivity.class);
Intent  intent = new Intent();
intent.putExtra("result","Success");
setResult(1,intent);
// finish();
}
}

输出:(暂停前)

D/Ravi: Main OnCreate
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

输出:(从暂停恢复后)

D/Ravi: Main ReStart
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

注意，即使onPostResume()没有被引用为生命周期方法，它也会被调用。

小开

Android活动的生命周期是什么?

在android sdk框架中，每个android Activity(窗口)都有生命周期方法。这意味着，当用户进入一个应用程序，他可以看到在onCreate()生命周期方法中创建的活动。只在onCreate()方法中附加在窗口中的布局。

Activity(Window)有以下生命周期状态:

Create - Activity is created.
Start - Current activity gets started.
Resume - Current activity has been in resumed state.
Restart - Current activity has been in restarted.
Pause - Current activity has been in Paused state.
Stop - Current activity has been in stopped state.
destroy - Current activity has been in destroyed state.
为什么有这么多类似的方法(onCreate()， onStart()， onResume())在初始化期间调用，以及许多其他调用 (onPause()， onStop()， onDestroy())在结束时调用?< / p >

First time user enter into an application:

当打开应用程序时，我们可以看到一个窗口(Activity)。onCreate (created) -> onStart(started) -> onResume(resume state)将被调用。

Close the application from background:

当从后台关闭应用程序时，必须销毁活动以释放一些内存。因此，onPause -> onStop -> onDestroy方法将被调用。

什么时候调用这些方法，应该如何正确地使用它们?

启动应用程序:

当用户第一次进入一个活动或应用程序时:

onCreate()


onStart()


onResume()

当你从android studio运行应用程序:

onCreate()


onStart()


onResume()

活动的转变:

当移动从第一活动->第二活动:

first_activity  : onPause()


second_activity : onCreate()


second_activity : onStart()


second_activity : onResume()


first_activity  : onStop()

当移动从第二个活动->第一个活动:

second_activity : onPause()


first_activity  : onRestart()


first_activity  : onStart()


first_activity  : onResume()


second_activity : onStop()


second_activity : onDestroy()

概述按钮:

当用户点击概述按钮(硬件第三个按钮-最近列表):

onPause()


onStop()

当用户关闭概览按钮(或)后，用户从最近的列表中进入其他应用程序，并返回到应用程序:

onRestart()


onStart()


onResume()

主页按钮:

当用户点击Home键时:

onPause()


onStop()

用户搜索主屏幕，点击应用程序图标回到活动:

onRestart()


onStart()


onResume()

用户收到电话:

当用户在一个活动，电话来了:

onPause()


onStop()

如果用户没有参加呼叫，它会自动断开并返回活动(未接呼叫):

onRestart()


onStart()


onResume()

如果用户不参加呼叫:

-不调用任何生命周期。

关机按钮:

当用户关闭按钮时:

onPause()


onStop()

解锁设备时:

onRestart()


onStart()


onResume()

弹出对话框:

当弹出对话框出现-没有生命周期将被调用

重启设备或关闭开关:

用户重启或关闭设备时:

onPause()


onStop()

当用户从主屏幕点击应用程序图标时:

onCreate()


onStart()


onResume()
小开

我按照上面的答案运行一些日志，下面是输出:

开始活动

On Activity Load (First Time)
————————————————————————————————————————————————
D/IndividualChatActivity: onCreate:
D/IndividualChatActivity: onStart:
D/IndividualChatActivity: onResume:
D/IndividualChatActivity: onPostResume:


Reload After BackPressed
————————————————————————————————————————————————
D/IndividualChatActivity: onCreate:
D/IndividualChatActivity: onStart:
D/IndividualChatActivity: onResume:
D/IndividualChatActivity: onPostResume:


OnMaximize(Circle Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onRestart:
D/IndividualChatActivity: onStart:
D/IndividualChatActivity: onResume:
D/IndividualChatActivity: onPostResume:


OnMaximize(Square Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onRestart:
D/IndividualChatActivity: onStart:
D/IndividualChatActivity: onResume:
D/IndividualChatActivity: onPostResume:

停止活动

On BackPressed
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop:
D/IndividualChatActivity: onDestroy:


OnMinimize (Circle Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop:


OnMinimize (Square Button)
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop:


Going To Another Activity
————————————————————————————————————————————————
D/IndividualChatActivity: onPause:
D/IndividualChatActivity: onStop:


Close The App
————————————————————————————————————————————————
D/IndividualChatActivity: onDestroy:

在我个人看来，onStart和onStop只需要两个。

onResume似乎在每一个实例回来，和onPause在每一个实例离开(除了关闭应用程序)。


提交答案