Android Activity Launch Mode

1. standard

standard是默认的启动模式，即如果不指定launchMode属性，则自动就会使用这种启动模式。这种启动模式表示每次启动该Activity时系统都会为创建一个新的实例，并且总会把它放入到当前的任务当中。声明成这种启动模式的Activity可以被实例化多次，一个任务当中也可以包含多个这种Activity的实例。
假如现在的任务栈是 A -> B -> C
C启动C后，就是 A -> B -> C -> C

下面是打开一个页面的Activity

Running activities (most recent first):
      TaskRecord{b2a82e #2865 A=com.xiyue.myapplication U=0 StackId=34 sz=1}
        Run #0: ActivityRecord{124f9c2 u0 com.xiyue.myapplication/.MainActivity t2865}

现在打开多个页面,注意看每个AActivity都不是同一个对象

 Running activities (most recent first):
      TaskRecord{b2a82e #2865 A=com.xiyue.myapplication U=0 StackId=34 sz=4}
        Run #3: ActivityRecord{10f0a09 u0 com.xiyue.myapplication/.AActivity t2865}
        Run #2: ActivityRecord{10f0b44 u0 com.xiyue.myapplication/.AActivity t2865}
        Run #1: ActivityRecord{ea3d44 u0 com.xiyue.myapplication/.AActivity t2865}
        Run #0: ActivityRecord{124f9c2 u0 com.xiyue.myapplication/.MainActivity t2865}

2. singleTop

这种启动模式表示，如果要启动的这个Activity在当前任务中已经存在了，并且还处于栈顶的位置，那么系统就不会再去创建一个该Activity的实例，而是调用栈顶Activity的onNewIntent()方法。声明成这种启动模式的Activity也可以被实例化多次，一个任务当中也可以包含多个这种Activity的实例。
假设C的启动模式是singleTop

假如现在的任务栈是 A -> B
B启动C ，最后的任务栈就是 A -> B -> C

假如现在的任务栈是 A -> B -> C
C启动C ，会调用C的onNewIntent方法，最后的任务栈就是 A -> B -> C

假如现在的任务栈是 A -> B -> C -> D
D启动C ,最后的任务栈就是 A -> B -> C -> D -> C

现在栈里只有Main

 Running activities (most recent first):
      TaskRecord{d78ec2 #2866 A=com.xiyue.myapplication U=0 StackId=35 sz=1}
        Run #0: ActivityRecord{10f0a48 u0 com.xiyue.myapplication/.MainActivity t2866}

多次打开AActivity，但是栈里只有一个AActivity

Running activities (most recent first):
      TaskRecord{d78ec2 #2866 A=com.xiyue.myapplication U=0 StackId=35 sz=2}
        Run #1: ActivityRecord{124f848 u0 com.xiyue.myapplication/.AActivity t2866}
        Run #0: ActivityRecord{10f0a48 u0 com.xiyue.myapplication/.MainActivity t2866}

但是如果AActivity不在栈顶，效果就不一样了
MainActivity -> AActivity -> BActivity -> AActivity

   Running activities (most recent first):
     TaskRecord{a93a9d #2867 A=com.xiyue.myapplication U=0 StackId=36 sz=4}
       Run #3: ActivityRecord{10a3705 u0 com.xiyue.myapplication/.AActivity t2867}
       Run #2: ActivityRecord{10a3648 u0 com.xiyue.myapplication/.BActivity t2867}
       Run #1: ActivityRecord{fcdf05 u0 com.xiyue.myapplication/.AActivity t2867}
       Run #0: ActivityRecord{10b4344 u0 com.xiyue.myapplication/.MainActivity t2867}

3. singleTask

同一个应用打开singleTask的activity行为和singleTop类似，但是栈里面只会有一个singleTask的activity，在上面的activity会被弹出去。不同应用打开会打开一个新的任务栈。

假设B的启动模式是singleTask

同一个应用情况下

情景1：A
现在A启动B，会将A添加到栈里，最后的栈就是A -> B

情景2：A -> B
现在B启动B，会调用B的 onNewIntent 方法，最后的栈就是A -> B

情景3：A -> B -> C
现在C启动B，因为B也在栈里，会把C弹出去，调用B的onNewIntent ，最后的栈就是A -> B

其他应用打开情况下

现在用other应用打开带有singleTask的AActivity,会打开一个新的任务栈

 Running activities (most recent first):
      TaskRecord{a8dc78 #2882 A=com.xiyue.other U=0 StackId=51 sz=1}
        Run #0: ActivityRecord{bb4009 u0 com.xiyue.other/.MainActivity t2882}

 Running activities (most recent first):
      TaskRecord{bcc42e #2883 A=com.xiyue.myapplication U=0 StackId=52 sz=1}
        Run #0: ActivityRecord{124f848 u0 com.xiyue.myapplication/.AActivity t2883}

假如AActivity的启动模式是standard，此时的AActivity在别的应用任务栈里，那么最后的任务栈就是

  Running activities (most recent first):
      TaskRecord{b2a853 #2885 A=com.xiyue.other U=0 StackId=54 sz=2}
        Run #1: ActivityRecord{d0b248 u0 com.xiyue.myapplication/.AActivity t2885}
        Run #0: ActivityRecord{108a848 u0 com.xiyue.other/.MainActivity t2885}

4. singleInstance

这种启动模式和"singleTask"有点相似，只不过系统不会向声明成"singleInstance"的Activity所在的任务当中再添加其它Activity。也就是说，这种Activity所在的任务中始终只会有一个Activity，通过这个Activity再打开的其它Activity也会被放入到别的任务当中。

假设B的启动模式是singleInstance
现在的任务栈是 A
A启动B后的将会有2个任务栈
B
A

现在B启动C，C会被加到A的任务栈中，B的任务栈里只有B，最后的任务栈是

A -> C
B

 Running activities (most recent first):
      TaskRecord{d78e78 #2888 A=com.xiyue.myapplication U=0 StackId=57 sz=1}
        Run #0: ActivityRecord{fcdf05 u0 com.xiyue.myapplication/.AActivity t2888}

 Running activities (most recent first):
      TaskRecord{d78e9d #2887 A=com.xiyue.myapplication U=0 StackId=56 sz=2}
        Run #1: ActivityRecord{10aac48 u0 com.xiyue.myapplication/.BActivity t2887}
        Run #0: ActivityRecord{1110dc2 u0 com.xiyue.myapplication/.MainActivity t2887}

现在C启动B，因为B已经在独立的任务栈里了，会调用B的 onNewIntent方法，就会把B所在的任务栈带到前台来，最后的任务栈
B
A -> C

taskAffinity属性

taskAffinity 属性主要和 singleTask 或者 allowTaskReparenting 属性配对使用
给AActivity的启动属性设置为singleTask，taskAffinity属性设置com.xiyue.app
最后MainActivity启动AActivity后的任务栈

 Running activities (most recent first):
      TaskRecord{bf769d #2894 A=com.xiyue.myapplication U=0 StackId=63 sz=1}
        Run #0: ActivityRecord{fc7905 u0 com.xiyue.myapplication/.MainActivity t2894}

  Running activities (most recent first):
      TaskRecord{a93a9d #2895 A=com.xiyue.app U=0 StackId=64 sz=1}
        Run #0: ActivityRecord{ea3c87 u0 com.xiyue.myapplication/.AActivity t2895}

BActivity没有设置启动模式，现在用AActivity启动BActivity后，

 Running activities (most recent first):
      TaskRecord{a93a9d #2895 A=com.xiyue.app U=0 StackId=64 sz=2}
        Run #1: ActivityRecord{108a9c2 u0 com.xiyue.myapplication/.BActivity t2895}
        Run #0: ActivityRecord{ea3c87 u0 com.xiyue.myapplication/.AActivity t2895}

    Running activities (most recent first):
      TaskRecord{bf769d #2894 A=com.xiyue.myapplication U=0 StackId=63 sz=1}
        Run #0: ActivityRecord{fc7905 u0 com.xiyue.myapplication/.MainActivity t2894}