Android活动的启动模式

一、前言

在实际项目中我们应该根据特定的需求为每个活动指定恰当的启动模式。

启动模式一共有4种，分别是standard、singleTop. singleTask 和singleInstance ,可以在AndroidManifest.xml中通过给标签指定android: launchMode
属性来选择启动模式。

二、standard

沿用博客“Intent的更多用法”项目ActivityTest，在该项目的基础上进行修改

standard是活动默认的启动模式，在不进行显式指定的情况下，所有活动都会自动使用这种启动模式。

因此,到目前为止写过的所有活动都是使用的standard模式。

你已经知道了Android 是使用返回栈来管理活动的，在standard模式(即默认情况)下，每当启动一个新的活动，它就会在返回栈中入栈，并处于栈顶的位置。

对于使用standard模式的活动,系统不会在乎这个活动是否已经在返回栈中存在，每次启动都会创建该活动的一个新的实例。

修改FirstActivity中的onCreate()方法代码，如下：

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("FirstActivity" , this.toString());
        setContentView(R.layout.first_layout);
        Button button1 = (Button) findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(FirstActivity.this, FirstActivity.class);
                startActivity(intent);
            }
        });
    }

启动程序，在FirstActivity界面上连续点击两次按钮：

从打印信息中就可以看出，每点击一次按钮就会创建出一个新的FirstActivity 实例。此时返回栈中也会存在3个FirstActivity的实例，因此你需要连按3次Back键才能退出程序。

standard模式的原理示意图，如下：

三、singleTop

可能在有些情况下，standard 模式不太合理。

活动明明已经在栈顶了，为什么再次启动的时候还要创建一个新的活 动实例呢?

别着急，这只是系统默认的一种启动模式而已，你完
全可以根据自己的需要进行修改，比如说使用singleTop 模式。

当活动的启动模式指定为singleTop,在启动活动时如果发现返回栈的栈顶已经是该活动，则认为可以直接使用它，不会再
创建新的活动实例。

修改AndroidManifest.xml中FirstActivity的启动模式，如下所示:

        <activity
            android:name=".FirstActivity"
            android:exported="true"
            android:launchMode="singleTop">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

启动程序可以发现，不管点击多少次按钮都不会再有新的打印信息出现，因为目前FirstActivity 已经处于返回栈的栈顶，每当想要再启动一个FirstActivity时都会直接使用栈顶的活动，因此FirstActivity 也只会有一个实例，仅按一次Back键就可以退出程序。

修改FirstActivity中onCreate( )方法的代码，如下所示:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("FirstActivity" , this.toString());
        setContentView(R.layout.first_layout);
        Button button1 = (Button) findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });
    }

这次点击按钮后启动的是SecondActivity。然后修改SecondActivity中onCreate()方法的代码，如下所示:

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("SecondActivity" , this.toString());
        setContentView(R.layout.second_layout);

        Button button2 = (Button) findViewById(R.id.button_2);
        button2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(SecondActivity.this, FirstActivity.class);
                startActivity(intent);
            }
        });
    }

启动程序，在FirstActivity界面点击按钮进入到SecondActivity,然后在SecondActivity界面点击按钮，又会重新进入到FirstActivity。

观察打印信息，发现，系统创建了两个不同的FirstActivity 实例，这是由于在SecondActivity 中再次启动FirstActivity时，栈顶活动已经变成了SecondActivity, 因此会创建一个新的 FirstActivity 实例。

现在按下Back键会返回到SecondActivity， 再次按下Back键又会回到FirstActivity， 再按一次Back键才会退出程序。

SingleTop模式的原理示意图，如下：

四、singleTask

使用singleTop 模式可以很好地解决重复创建栈顶活动的问题。

但如果该活动并没有处于栈顶的位置,还是可能会创建多个活动实例的。

那么有没有什么办法可以让某个活动在整个应用程序的上下文中只存在一个实例呢?

借助singleTask模式。当活动的启动模式指定为singleTask, 每次启动该活动时系统首先会在返回栈中检查是否存在该活动的实例，如果发现已经存在则直接使用该实例,并把在这个活动之上的所有活动统统出栈，如果没有发现就会创建一个新的活动实例。

修改AndroidManifest.xml中FirstActivity 的启动模式，如下：

        <activity
            android:name=".FirstActivity"
            android:exported="true"
            android:launchMode="singleTask">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

然后在FirstActivity中添加onRestart()方法，并打印日志:

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

最后在SecondActivity中添加onDestroy()方法，并打印日志:

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

现在重新运行程序，在FirstActivity 界面点击按钮进人到SecondActivity, 然后在SecondActivity界面点击按钮，又会重新进入到FirstActivity。

从打印信息中可以明显看出了，在SecondActivity中启动FirstActivity 时,会发现返回栈中已经存在一个FirstActivity的实例，并且是在SecondActivity的下面，于是SecondActivity
会从返回栈中出栈，而FirstActivity重新成为了栈顶活动，因此FirstActivity的onRestart()方法和SecondActivity的onDestroy( )方法会得到执行。现在返回栈中应该只剩下一个FirstActivity的实例了，按一下Back键就可以退出程序。

singleTask模式的原理示意图，如下所示：

五、singleInstance

singleInstance模式应该算是4种启动模式中最特殊也最复杂的一个了 。

不同于以上3种启动模式,指定为singleInstance模式的活动会启用一个新的返回栈来管理这个活动(其实如果singleTask模式指定了不同的taskAffinity,也会启动一个新的返回栈)。

那么这样做有什么意义呢?

想象以下场景,假设我们的程序中有一个活动是允许其他程
序调用的，如果我们想实现其他程序和我们的程序可以共享这个活动的实例,应该如何实现呢?

使用前面3种启动模式肯定是做不到的,因为每个应用程序都会有自己的返回栈，同一个活动在不同的返回栈中入栈时必然是创建了新的实例。而使用singleInstance模式就可以解决这个问题，在这种模式下会有一个单独的返回栈来管理这个活动,不管是哪个应用程序来访问这个活动,都共用的同一个返回栈，也就解决了共享活动实例的问题。

修改AndroidManifest.xml 中SecondActivity的启动模式:

<activity
            android:name=".SecondActivity"
            android:exported="true"
            android:launchMode="singleInstance">
            <intent-filter>
                <action android:name="com.example.activitytest.ACTION_START" />

                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="com.example.activitytest.MY_CATEGORY" />
            </intent-filter>
        </activity>

然后修改FirstActivity 中onCreate( )方法的代码:

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("FirstActivity" , "Task id is" + getTaskId());
        setContentView(R.layout.first_layout);
        Button button1 = (Button) findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });
    }

然后修改SecondActivity 中onCreate()方法的代码:

   @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("SecondActivity" , "Task id is" + getTaskId());
        setContentView(R.layout.second_layout);

        Button button2 = (Button) findViewById(R.id.button_2);
        button2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(SecondActivity.this, ThirdActivity.class);
                startActivity(intent);
            }
        });
    }

最后修改ThirdActivity中onCreate()方法的代码:

   @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("ThirdActivity" , "Task id is" + getTaskId());
        setContentView(R.layout.thrid_layout);
    }

重新运行程序，在FirstActivity界面点击按钮进入到SecondActivity,然后在SecondActivity界面点击按钮进入到ThirdActivity，观察打印信息，效果如下：

可以看到，SecondActivity 的Task Id不同于FirstActivity 和ThirdActivity， 这说明SecondActivity确实是存放在一个单独的返回栈里的，而且这个栈中只有SecondActivity 这一个
活动。

然后我们按下Back 键进行返回，会发现ThirdActivity竟然直接返回到了FirstActivity,再按下Back键又会返回到SecondActivity,再按下Back键才会退出程序,这是为什么呢?

其实原理很简单，由于FirstActivity和ThirdActivity是存放在同一个返回栈里的，当在ThirdActivity的界面按下Back 键，ThirdActivity 会从返回栈中出栈，那么FirstActivity 就成为了栈顶活动显示在界面上，因此也就出现了从ThirdActivity 直接返回到FirstActivity 的情况。然后在FirstActivity界面再次按下Back 键,这时当前的返回栈已经空了，于是就显示了另一个返回栈的栈顶活动，即SecondActivity。最后再次按下Back键，这时所有返回栈都已经空了，也就自然退出了程序。

singleInstance模式的原理示意图，如下所示：