Android启动模式之singleTask解析

转自：https://i-blog.csdnimg.cn/blog_migrate/c25a02d8836833e42933d63a60634e17.png

在android应用程序中，最重要的组件之一Activity有4种启动模式，其中singleTask根据官方文档的描述很容易让人迷惑，主要是启动后所处的Task易让人困惑，其实原因在于，activity的启动方式除了受标签android:launchMode的影响之外，还会被启动参数所左右，比如intent的标志位FLAG_ACTIVITY_NEW_TASK，任务标签 android:taskAffinity。本文主要对singleTask和这些影响影响因素进行测试。

        测试代码不用复杂即可说明问题，使用两个app，假定为app A 和 app B，其中app A 有两个activity，MainActivity和SingleTaskActivity， app B只有个一个MainActivity。然后分别通过两个MainActivity来启动SingleTaskActivity进行测试。

Test 1：

        为了进行对比，先将SingleTaskActivity的属性设置为默认模式，并且不设置标签android:taskAffinity：

[html]  view plain copy

1. <activity   
2.             android:name=".SingleTaskActivity">  
3.             <!--android:taskAffinity="com.zj.task">  
4.             android:launchMode="singleTask"-->  
5.             <intent-filter >  
6.                 <action android:name="com.zj.test.launch_singletask"/>    
7.                 <category android:name="android.intent.category.DEFAULT"/>     
8.             </intent-filter>  
9. </activity>  

        在app A和app B 中分别以默认方式和FLAG_ACTIVITY_NEW_TASK的方式启动SingleTaskActivity，MainActivity主要测试代码为（App A中和App B中的一样），使用两个Button以两种方式启动Activity：

[java]  view plain copy

1. findViewById(R.id.button1).setOnClickListener(new OnClickListener() {  
2.       
3.     @Override  
4.     public void onClick(View v) {  
5.         // TODO Auto-generated method stub  
6.         Intent intent = new Intent("com.zj.test.launch_singletask");    
7.         Bundle bundle = new Bundle();  
8.         bundle.putString("mainact", "1_Button1");  
9.         intent.putExtras(bundle);  
10.         startActivity(intent);   
11.     }  
12. });  
13.   
14. findViewById(R.id.button2).setOnClickListener(new OnClickListener() {  
15.       
16.     @Override  
17.     public void onClick(View v) {  
18.         // TODO Auto-generated method stub  
19.         Intent intent = new Intent("com.zj.test.launch_singletask");    
20.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
21.         Bundle bundle = new Bundle();  
22.         bundle.putString("mainact", "1_Button2");  
23.         intent.putExtras(bundle);  
24.         startActivity(intent);  
25.     }  
26. });  

Log输出位置：

App A MainActivity:

[java]  view plain copy

1. @Override  
2. protected void onResume() {  
3.     // TODO Auto-generated method stub  
4.     super.onResume();  
5.     Log.d("SingleTask", "App A's MainActivity " +"所在的任务的id为: " +  getTaskId());  
6. }  

App A SingleTaskActivity:

[java]  view plain copy

1. <strong>  </strong>@Override  
2.     protected void onResume() {  
3.         // TODO Auto-generated method stub  
4.         super.onResume();  
5.         Log.d("SingleTask", "App A's SingleTaskActivity " +"所在的任务的id为: " +  getTaskId());  
6.     }  

App B  MainActivity:

[java]  view plain copy

1. @Override  
2. protected void onResume() {  
3.     // TODO Auto-generated method stub  
4.     super.onResume();  
5.     Log.d("SingleTask", "App B's MainActivity " +"所在的任务的id为: " +  getTaskId());  
6. }  

测试步骤为：

        1.启动App A，点击Button1，然后点击back，点击button2，然后home键，启动app B，点击Button1，然后点击back，点击button2。 

        2.启动App A，点击Button1，然后点击back，点击button2，然后点击back，然后home键，启动app B，点击Button1，然后点击back，点击button2。

测试结果：

        在App A 中两种启动方式中，SingleTaskActivity都和启动它的MainActivity位于同一个Task，也就是说FLAG_ACTIVITY_NEW_TASK根本没有发挥作用，
        在App B 中两种启动方式中，当不设置FLAG_ACTIVITY_NEW_TASK时，SingleTaskActivity和启动它的MainActivity位于同一个Task，设置了以后，复用了已经存在位于App A中的SingleTaskActivity。

        如果在启动App B前，先点击back从SingleTaskActivity返回后再home键的效果也一样(实际上是在目标App A的Task内新建的了一个）。

        如果是先测试App B后测试App A的话，依然是在App A 中FLAG_ACTIVITY_NEW_TASK没有发挥作用(没有新建task)，App B中则发挥了作用（区别在于， 由于App A后启动，所以App B新建SingleTaskActivity的Task时，无法再App A的Task中新建，因为它还不存在）。

Test 2：

下面把SingleTaskActivity标签android:taskAffinity设置上内容 ，launchMode保持不变，如下（注意 app A 和 app B的包名不能和android:taskAffinity一样，否则起不到测试效果）

[html]  view plain copy

1. <activity   
2.     android:name=".SingleTaskActivity"  
3.     android:taskAffinity="com.zj.task">  
4.     <!--android:launchMode="singleTask"-->  
5.     <intent-filter >  
6.         <action android:name="com.zj.test.launch_singletask"/>    
7.         <category android:name="android.intent.category.DEFAULT"/>     
8.     </intent-filter>  
9. </activity>  

        然后再次重复测试步骤：

测试结果：

        先App A，再App B(home之前不回退SingleTaskActivity)：

       在两个app下FLAG_ACTIVITY_NEW_TASK都起作用(对于app B而言，新建的时候发现目标Task的栈顶已经有一个实例，所以没有新建)。

        先App A，再App B(home之前回退SingleTaskActivity)：

       在两个app下FLAG_ACTIVITY_NEW_TASK都起作用，且新建了Task。

        先App B，在App A，结果和上面一样。

 

        好了，有些乱了吧，已经快把自己绕进去了,对于启动模式的前两种standard和singleTop(可以被实例化多次), 结论如下：

        1.如果启动者和被启动者在同一app下(声明在同一个AndroidManif.xml文件里)，必须同时使用FLAG_ACTIVITY_NEW_TASK和标签android:taskAffinity才能在新的Task中启动，缺少其中的一个都会和启动者位于同一个Task。
        2.如果启动者和被启动者不在同一个app下，如果不用FLAG_ACTIVITY_NEW_TASK，则二者位于同一个Task内。如果使用的话，会新建Task，所新建的位置依据标签android:taskAffinity而定(1.如果不指定则在被启动者所在App的Task内新建，当然前提是这个被启动者所在的App的Task已经存在，2.如果目标Task内的栈顶已经有一个实例，这时候实际上不新建的，相当于要新建的内容已经存在了)。

       

        以上是一个对比测试，下面转入本文主题，对singleTask模式的测试，

Test 3:：

首先依然不设置标签android:taskAffinity，启动模式为singleTask：

[html]  view plain copy

1. <activity   
2.     android:name=".SingleTaskActivity"  
3.     android:launchMode="singleTask">  
4.     <!--android:taskAffinity="com.zj.task"> -->  
5.     <intent-filter >  
6.         <action android:name="com.zj.test.launch_singletask"/>    
7.         <category android:name="android.intent.category.DEFAULT"/>     
8.     </intent-filter>  
9. </activity>  

测试结果：

        先App A，再App B (不管是否回退都一样)

        在App A 中两种启动方式，SingleTaskActivity都和启动它的MainActivity位于同一个Task，也就是说FLAG_ACTIVITY_NEW_TASK根本没有发挥作用，而且singleTask也没有启动新Task。
       在App B 中两种启动方式：不管是否设置FLAG_ACTIVITY_NEW_TASK时，SingleTaskActivity和启动它的MainActivity都不位于同一个Task中（如存在，直接调用，如不存在，则在所属app的Task中新建出来）。

        先App B，再App A：

       App B的两种方式都会新建一个Task任务来启动SingleTaskActivity，如不回退，启动App A时则直接进入到App B启动好的SingleTaskActivity

Test 4：

下面把SingleTaskActivity标签android:taskAffinity设置上内容

[html]  view plain copy

1. <activity   
2.     android:name=".SingleTaskActivity"  
3.     android:launchMode="singleTask"   
4.     android:taskAffinity="com.zj.task" >  
5.     <intent-filter >  
6.         <action android:name="com.zj.test.launch_singletask"/>    
7.         <category android:name="android.intent.category.DEFAULT"/>     
8.     </intent-filter>  
9. </activity>  

       先App A，再App B：

        先App B，再App A：

       不管启动者和被启动着是否在同一app下，都会新建一个任务来启动SingleTaskActivity，且如果已经存在一个实例的话，就不会再次新建了。

结论：对于singleTask启动方式而言，

1.如果启动者和被启动者属于不同app的话，则只要系统中不存在这个类的实例，都会为SingleTaskActivity新建Task来启动它，存在的话就直接调用已存在的这个实例。
2.如果启动者和被启动者属于同一个app，需要设置标签android:taskAffinity以后，才会新建Task来启动，否则直接调用者所在Task内启动。

总结一下，singleTask启动方式Activity在系统中只会存在一份实例，启动时是否启动新Task，取决两个因素：启动者和被启动者的位置关系 和 标签android:taskAffinity的值。