Android基础总结——Activity生命周期、横竖屏切换和启动模式（任务栈）

最新推荐文章于 2024-05-27 08:44:16 发布

走慢一点点

最新推荐文章于 2024-05-27 08:44:16 发布

阅读量1k

点赞数 2

分类专栏： Android基础文章标签： android activity 生命周期横竖屏任务栈

Android基础专栏收录该内容

34 篇文章 1 订阅

订阅专栏

熟悉javaEE的朋友们都了解servlet技术，我们想要实现一个自己的servlet，需要继承相应的基类，重写它的方法，这些方法会在合适的时间被servlet容器调用。其实android中的Activity运行机制跟servlet有些相似之处，Android系统相当于servlet容器，Activity相当于一个servlet，我们的Activity处在这个容器中，一切创建实例、初始化、销毁实例等过程都是容器来调用的，这也就是所谓的“Don’t call me, I’ll call you.”机制。

生命周期

参考文章：基础总结篇之一：Activity生命周期

我们来看一下经典的生命周期流程图：
图一：
这里写图片描述

图二：
这里写图片描述

下面会介绍上图所示的几个生命状态。然而，其中只有三个状态是静态的，这三个状态下activity可以存在一段比较长的时间。(其它几个状态会很快就切换掉，停留的时间比较短暂)

Resumed：该状态下，activity处在前台，用户可以与它进行交互。(通常也被理解为”running” 状态)
Paused：该状态下，activity的部分被另外一个activity所遮盖：另外的activity来到前台，但是半透明的，不会覆盖整个屏幕。被暂停的activity不再接受用户的输入且不再执行任何代码。
Stopped：该状态下, activity完全被隐藏，对用户不可见。可以认为是在后台。当stopped, activity实例与它的所有状态信息（如成员变量等）都会被保留，但activity不能执行任何代码。
其它状态 (Created与Started)都是短暂的，系统快速的执行那些回调函数并通过执行下一阶段的回调函数移动到下一个状态。也就是说，在系统调用onCreate(), 之后会迅速调用onStart(), 之后再迅速执行onResume()。以上就是基本的activity生命周期。

实例演示

package com.example.test;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class MainActivity extends Activity {

    private static final String TAG = "MainActivity";
    private Context context = this;
    private int param = 1;

    // Activity创建时被调用
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i(TAG, "onCreate called.");
        setContentView(R.layout.activity_main);

        Button btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(context, DialogActivity.class);
                startActivity(intent);
            }
        });
    }

    // Activity创建或者从后台重新回到前台时被调用
    @Override
    protected void onStart() {
        super.onStart();
        Log.i(TAG, "onStart called.");
    }

    // Activity从后台重新回到前台时被调用
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.i(TAG, "onRestart called.");
    }

    // Activity创建或者从被覆盖、后台重新回到前台时被调用
    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "onResume called.");
    }

    // Activity窗口获得或失去焦点时被调用,在onResume之后或onPause(锁屏的情况下是在onStop之后)之后
    /*@Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        Log.i(TAG, "onWindowFocusChanged called.");
    }*/

    // Activity被覆盖到下面或者锁屏时被调用
    @Override
    protected void onPause() {
        super.onPause();
        Log.i(TAG, "onPause called.");
        // 有可能在执行完onPause或onStop后,系统资源紧张将Activity杀死,所以有必要在此保存持久数据
    }

    // 退出当前Activity或者跳转到新Activity时被调用
    @Override
    protected void onStop() {
        super.onStop();
        Log.i(TAG, "onStop called.");
    }

    // 退出当前Activity时被调用,调用之后Activity就结束了
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestory called.");
    }

    /**
     * Activity被系统杀死时被调用. 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死.
     * 另外,当跳转到其他Activity或者按Home键回到主屏时该方法也会被调用,系统是为了保存当前View组件的状态. 在onPause之前被调用.
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        outState.putInt("param", param);
        Log.i(TAG, "onSaveInstanceState called. put param: " + param);
        super.onSaveInstanceState(outState);
    }

    /**
     * Activity被系统杀死后再重建时被调用.
     * 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死,用户又启动该Activity.
     * 这两种情况下onRestoreInstanceState都会被调用,在onStart之后.
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        param = savedInstanceState.getInt("param");
        Log.i(TAG, "onRestoreInstanceState called. get param: " + param);
        super.onRestoreInstanceState(savedInstanceState);
    }
}

这里写图片描述
除了几个常见的方法外，我们还添加了onWindowFocusChanged、onSaveInstanceState、onRestoreInstanceState方法：
1.onWindowFocusChanged方法：在Activity窗口获得或失去焦点时被调用，例如创建时首次呈现在用户面前；当前Activity被其他Activity覆盖；当前Activity转到其他Activity或按Home键回到主屏，自身退居后台；用户退出当前Activity。以上几种情况都会调用onWindowFocusChanged。
(1)并且当Activity被创建时是在onResume之后被调用：
这里写图片描述
(2)当Activity被覆盖或者退居后台或者当前Activity退出时，它是在onPause之后被调用：

(3)当锁屏时，它是在onStop之后调用，如图所示：

这个方法在某种场合下还是很有用的，例如程序启动时想要获取视特定视图组件的尺寸大小，在onCreate中可能无法取到，因为窗口Window对象还没创建完成，这个时候我们就需要在onWindowFocusChanged里获取；如果大家已经看过我写的Android动画之Frame Animation这篇文章就会知道，当时试图在onCreate里加载frame动画失败的原因就是因为窗口Window对象没有初始化完成，所以最后我将加载动画的代码放到了onWindowFocusChanged中，问题迎刃而解。不过大家也许会有疑惑，为什么我在代码里将它注释掉了，因为对当前Activity每一个操作都有它的执行log，我担心这会影响到整个流程的清晰度，所以将它注掉，大家只要了解它应用的场合和执行的顺序就可以了。
2.onSaveInstanceState：在onPause()，onStop()以及onDestroy()中需要保存的是那些需要永久化是数据，而不是保存用于恢复状态的数据，状态数据有专门的方法：onSaveInstanceState()。数据保存在一个Bundle中，Bundle被系统永久化。当再调用activity的onCreate()时，原先保存的bundle就被传入，以恢复上一次临死时的模样，如果上次死时没有保存Bundle，则为null。
(1)在Activity被覆盖或退居后台之后，系统资源不足将其杀死，此方法会被调用；(2)在用户改变屏幕方向时，此方法会被调用；(3)在当前Activity跳转到其他Activity或者按Home键回到主屏，自身退居后台时，此方法会被调用。第一种情况我们无法保证什么时候发生，系统根据资源紧张程度去调度；第二种是屏幕翻转方向时，系统先销毁当前的Activity，然后再重建一个新的，调用此方法时，我们可以保存一些临时数据；第三种情况系统调用此方法是为了保存当前窗口各个View组件的状态。onSaveInstanceState的调用顺序是在onPause之后：
这里写图片描述
3.onRestoreInstanceState：(1)在Activity被覆盖或退居后台之后，系统资源不足将其杀死，然后用户又回到了此Activity，此方法会被调用；(2)在用户改变屏幕方向时，重建的过程中，此方法会被调用。我们可以重写此方法，以便可以恢复一些临时数据。onRestoreInstanceState的调用顺序是在onStart之后，如下横竖屏切换：
这里写图片描述

以上着重介绍了三个相对陌生方法之后，下面我们就来操作一下这个Activity，看看它的生命周期到底是个什么样的过程：
1.启动Activity：
这里写图片描述
在系统调用了onCreate和onStart之后，调用了onResume，自此，Activity进入了运行状态。

2.跳转到其他Activity，或按下Home键回到主屏：
这里写图片描述
我们看到，此时onSaveInstanceState方法在onPause之后被调用了，并且注意，退居后台时，onStop被调用。
注意：低版本的sdk可能是先调用onSaveInstanceState方法再调用onPause方法。

3.从后台回到前台：
这里写图片描述
当从后台会到前台时，系统先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，Activity又进入了运行状态。

4.修改DialogActivity在AndroidManifest.xml中的配置，将android:theme属性设置为@android:style/Theme.Dialog，然后再点击MainActivity中的按钮，跳转行为就变为了DialogActivity覆盖到MainActivity之上了，此时调用的方法为：
这里写图片描述

此时MainActivity的OnPause方法被调用，并没有调用onStop方法，因为此时的MainActivity没有退居后台，只是被覆盖或被锁屏；onSaveInstanceState会在onPause之后被调用。

5.按回退键使MainActivity从被覆盖回到前面：
这里写图片描述
此时只有onResume方法被调用，直接再次进入运行状态。

6.按下锁屏键。
这里写图片描述
执行的效果和上面的 4 有差别，会调用onStop方法。

7.退出：
这里写图片描述
最后onDestory方法被调用，标志着MainActivity的终结。

大家似乎注意到，在所有的过程中，并没有onRestoreInstanceState的出现，这个并不奇怪，因为之前我们就说过，onRestoreInstanceState只有在杀死不在前台的Activity之后用户回到此Activity，或者用户改变屏幕方向的这两个重建过程中被调用。我们要演示第一种情况比较困难，我们可以结合第二种情况演示一下具体过程。顺便也向大家讲解一下屏幕方向改变的应对策略。

横竖屏切换

指定横竖屏

我们可以为一个Activity指定一个特定的方向，指定之后即使转动屏幕方向，显示方向也不会跟着改变：
1.指定为竖屏：
在AndroidManifest.xml中对指定的Activity设置android:screenOrientation=”portrait”，或者在onCreate方法中指定：

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);  //竖屏

2.指定为横屏：
在AndroidManifest.xml中对指定的Activity设置android:screenOrientation=”landscape”，或者在onCreate方法中指定：

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); //横屏

为应用中的Activity设置特定的方向是经常用到的办法，可以为我们省去不少不必要的麻烦。

onConfigurationChanged

下面我们就结合实例讲解一下屏幕转换的生命周期，在MainActivity的最后加上一个onConfigurationChanged方法，如下：

package com.example.test;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.res.Configuration;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

public class MainActivity extends Activity {

    private static final String TAG = "MainActivity";
    private Context context = this;
    private int param = 1;

    // Activity创建时被调用
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i(TAG, "onCreate called.");
        setContentView(R.layout.activity_main);

        Button btn = (Button) findViewById(R.id.btn);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent(context, DialogActivity.class);
                startActivity(intent);
            }
        });
    }

    // Activity创建或者从后台重新回到前台时被调用
    @Override
    protected void onStart() {
        super.onStart();
        Log.i(TAG, "onStart called.");
    }

    // Activity从后台重新回到前台时被调用
    @Override
    protected void onRestart() {
        super.onRestart();
        Log.i(TAG, "onRestart called.");
    }

    // Activity创建或者从被覆盖、后台重新回到前台时被调用
    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "onResume called.");
    }

    // Activity窗口获得或失去焦点时被调用,在onResume之后或onPause(锁屏的情况下是在onStop之后)之后
    /*
     * @Override public void onWindowFocusChanged(boolean hasFocus) {
     * super.onWindowFocusChanged(hasFocus); Log.i(TAG,
     * "onWindowFocusChanged called."); }
     */

    // Activity被覆盖到下面或者锁屏时被调用
    @Override
    protected void onPause() {
        super.onPause();
        Log.i(TAG, "onPause called.");
        // 有可能在执行完onPause或onStop后,系统资源紧张将Activity杀死,所以有必要在此保存持久数据
    }

    // 退出当前Activity或者跳转到新Activity时被调用
    @Override
    protected void onStop() {
        super.onStop();
        Log.i(TAG, "onStop called.");
    }

    // 退出当前Activity时被调用,调用之后Activity就结束了
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestory called.");
    }

    /**
     * Activity被系统杀死时被调用. 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死.
     * 另外,当跳转到其他Activity或者按Home键回到主屏时该方法也会被调用,系统是为了保存当前View组件的状态. 在onPause之前被调用.
     */
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        outState.putInt("param", param);
        Log.i(TAG, "onSaveInstanceState called. put param: " + param);
        super.onSaveInstanceState(outState);
    }

    /**
     * Activity被系统杀死后再重建时被调用.
     * 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死,用户又启动该Activity.
     * 这两种情况下onRestoreInstanceState都会被调用,在onStart之后.
     */
    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        param = savedInstanceState.getInt("param");
        Log.i(TAG, "onRestoreInstanceState called. get param: " + param);
        super.onRestoreInstanceState(savedInstanceState);
    }

    /**
     * 当指定了android:configChanges="orientation|keyboardHidden|screenSize"后,
     * 方向改变时onConfigurationChanged被调用
     */
    @Override
    public void onConfigurationChanged(Configuration newConfig) {
        super.onConfigurationChanged(newConfig);
        Log.i(TAG, "onConfigurationChanged called.");
    }
}

如果不在AndroidMainfest.xml做相应配置，当我们旋转屏幕时，我们发现系统会先将当前Activity销毁，然后重建一个新的：
这里写图片描述
系统先是调用onSaveInstanceState方法，我们保存了一个临时参数到Bundle对象里面，然后当Activity重建之后我们又成功的取出了这个参数。

为了避免这样销毁重建的过程，我们需要在AndroidMainfest.xml中对MainActivity对应的配置:

    /**
     * 当指定了android:configChanges="orientation|keyboardHidden|screenSize"后,
     * 方向改变时onConfigurationChanged被调用
     * 自从Android 3.2（API 13），在设置Activity的android:configChanges="orientation|keyboardHidden"后，
     * 还是一样 会重新调用各个生命周期的。因为screen size也开始跟着设备的横竖切换而改变。
     * 所以，在AndroidManifest.xml里设置的MiniSdkVersion和 TargetSdkVersion属性大于等于13的情况下，
     * 如果你想阻止程序在运行时重新加载Activity，除了设置"orientation"， 你还必须设置"ScreenSize"。
     */
      android:configChanges="orientation|keyboardHidden|screenSize"

然后我们再测试一下，我试着做了四次的旋转，打印如下：
这里写图片描述
可以看到，每次旋转方向时，只有onConfigurationChanged方法被调用，没有了销毁重建的过程。

需要注意的是：
1.如果配置了android:screenOrientation属性，则会使android:configChanges=”orientation|keyboardHidden|screenSize”失效。

Activity启动模式（任务栈）

Android中Activity的启动模式分为四种：

1.standard
默认启动模式，每次激活Activity时都会创建Activity，并放入任务栈中

2.singleTop
如果在任务的栈顶正好存在该Activity的实例，就重用该实例，否者就会创建新的实例并放入栈顶(即使栈中已经存在该Activity实例，只要不在栈顶，都会创建实例)。

3.singleTask
如果在栈中已经有该Activity的实例，就重用该实例(会调用实例的onNewIntent())。重用时，会让该实例回到栈顶，因此在它上面的实例将会被移除栈。如果栈中不存在该实例，将会创建新的实例放入栈中。

4.singleInstance
在一个新栈中创建该Activity实例，并让多个应用共享改栈中的该Activity实例。一旦该模式的Activity的实例存在于某个栈中，任何应用再激活改Activity时都会重用该栈中的实例，其效果相当于多个应用程序共享一个应用，不管谁激活该Activity都会进入同一个应用中。

开发中，如果某个Activity供多种方式调用启动，多个调用希望只有一个Activity的实例存在，我们需要配置activity的启动模式为：lanuchMode=“singleTask”，并实现Activity的onNewIntent(Intent intent)生命周期方法。

Activity第一启动的时候执行：
onCreate()—->onStart()—->onResume() —-> ·····，也就时说第一次启动Activity并不会执行到onNewIntent().

第二次、第n次启动的时候执行：
onNewIntent()—->onResart()——>onStart()—–>onResume().

系统可能会随时杀掉后台运行的Activity，如果这一切发生，那么系统就会调用onCreate方法，而不调用onNewIntent方法：
onCreate()—->onStart()—->onResume() —-> ·····。

实际使用的过程中，需要注意onCreate()和onNewIntent()这两个方法的执行时机，一个好的解决方法就是在这两个方法中调用同一个处理数据的方法，并且需要在onNewIntent() 中使用setIntent(intent)赋值给Activity的Intent。否则，后续的getIntent()都是得到老的Intent。示例代码如下：


...

public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);
  processExtraData();
}

protected void onNewIntent(Intent intent) {
  super.onNewIntent(intent);
   setIntent(intent);// must store the new intent unless getIntent() will return the old one
  processExtraData()
}

private void processExtraData(){
  Intent intent = getIntent();// use the data received here
}

...

走慢一点点

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Android基础总结——Activity生命周期、横竖屏切换和启动模式（任务栈）

熟悉javaEE的朋友们都了解servlet技术，我们想要实现一个自己的servlet，需要继承相应的基类，重写它的方法，这些方法会在合适的时间被servlet容器调用。其实android中的Activity运行机制跟servlet有些相似之处，Android系统相当于servlet容器，Activity相当于一个servlet，我们的Activity处在这个容器中，一切创建实例、初始化、销毁实例等
复制链接

扫一扫