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

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

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

当前回答

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

来源:developer.android.com

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

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

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

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

onPostCreate(Bundle savedInstanceState)

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

onPostResume()

当activity resume完成时调用(在onResume()被调用之后)。

onSaveInstanceState(Bundle outState)

调用该方法在activity被杀死之前从activity中检索每个实例的状态，以便状态可以在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()被调用，即使它没有被引用为生命周期方法。

2017-02-10 15:58:41

其他回答

I like this question and the answers to it, but so far there isn't coverage of less frequently used callbacks like onPostCreate() or onPostResume(). Steve Pomeroy has attempted a diagram including these and how they relate to Android's Fragment life cycle, at https://github.com/xxv/android-lifecycle. I revised Steve's large diagram to include only the Activity portion and formatted it for letter size one-page printout. I've posted it as a text PDF at https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf and below is its image:

2016-06-10 16:29:24

在Activity Lifecycle (Android Developers)中可以看到。

onCreate ():

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

onRestart ():

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

onStart ():

当活动对用户可见时调用。紧随其后的是 onResume()如果活动来到前台。

onResume ():

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

onPause ():

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

原():

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

onDestroy ():

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

当Activity第一次加载事件时，调用如下:

onCreate()
onStart()
onResume()

当你点击电话按钮时，Activity将进入后台，下面的事件将被调用:

onPause()
onStop()

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

onRestart()
onStart()
onResume()

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

onPause()
onStop()
onDestroy()

活动状态

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

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

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

Paused - When the device goes to sleep, or an activity is still visible but partially hidden by a new, non-full-sized or transparent activity, the activity is considered paused. Paused activities are still alive, that is, they maintain all state and member information, and remain attached to the window manager. This is considered to be the second highest priority activity in the Android Activity stack and, as such, will only be killed by the OS if killing this activity will satisfy the resource requirements needed to keep the Active/Running Activity stable and responsive.

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

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

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");
    }
}

2011-12-15 06:37:42

在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需要内存用于其他操作时，暂停的活动将被停止，停止的活动将被销毁。

我希望这足够清楚了。

2011-12-15 06:25:57