Comprehensive analysis of Activity startup mode

In Android applications, Activity is the core component. To generate an Activity instance, you can choose different launch modes, namely LaunchMode. The launch modes mainly include: standard, singleTop, singleTask, singleInstance.

The standard mode creates an instance at each startup; the three singleton modes will choose to create or reuse instances according to the situation. In Activity startup, the life cycle of the created instance is: onCreate -> onStart -> onResume; the life cycle of the reused instance is: onNewIntent -> onResume.

In the AndroidManifest Activity, use the launchMode attribute to set the launch mode, which is the standard mode by default; use the taskAffinity attribute and add the package name to set the Activity stack, which is the current package name by default and can only be applied to single mode.

I hope that through this article, you can better understand the launch mode of Activity (LaunchMode).

[[164441]]

Script to observe the Activity stack.

 adb shell dumpsys activity | sed -n -e '/Stack #/p' -e '/Running activities/,/Run #0/p'  

Standard

Standard mode is the default mode for launching an Activity. The launched Activity will run on the stack of the launched Activity. Therefore, you must use the Activity's Context to launch it, and you cannot use Application, otherwise an error will be reported.

For example, MainActivity starts TestAActivity.

 Stack #1:
  Running activities (most recent first ):
    TaskRecord{3caa65e3 #2711 A=me.chunyu.spike.wcl_activity_launchmode_demo U=0 sz=2}
      Run #1: ActivityRecord{36b06e99 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2711}
      Run #0: ActivityRecord{27396226 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2711}
 Stack #0:
  Running activities (most recent first ):
    TaskRecord{27d796c9 #2695 A=com.miui.home U=0 sz=1}
      Run #0: ActivityRecord{2e5712cb u0 com.miui.home/.launcher.Launcher t2695}

From bottom to top in the stack: MainActivity -> TestAActivity.
SingleTop

Top-of-stack reuse mode. When only the Activity is at the top of the stack and is started repeatedly, the default instance, i.e., singleton mode, will be used; if it is inside the stack, an instance will still be created.

MainActivity starts TestA, TestA starts TestB, TestB starts itself, TestB is a singleton. Observe the situation in the stack, TestB has only one instance, and it is created and reused the second time.

 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{12abf566 # 2712 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 3 }
      Run # 2 : ActivityRecord{187d7ff7 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2712}
      Run # 1 : ActivityRecord{a551034 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2712}
      Run # 0 : ActivityRecord{22f9cce4 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2712}

In the stack: MainActivity -> TestAActivity -> TestBActivity

MainActivity starts TestA, TestA starts TestB, TestB starts TestC, TestC starts TestB, and TestB is a singleton. Observe the situation in the stack. Since TestC is at the top of the stack, TestC starts TestB, and TestB is not at the top of the stack, recreate the TestB instance, and retain two copies of TestB.

   
 
 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{1792f5f0 # 2715 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 5 }
      Run # 4 : ActivityRecord{1e70110b u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2715}
      Run # 3 : ActivityRecord{c7f4dce u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestCActivity t2715}
      Run # 2 : ActivityRecord{254536cd u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2715}
      Run # 1 : ActivityRecord{36b2da15 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2715}
      Run # 0 : ActivityRecord{3a1c4a6a u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2715}

In the stack: MainActivity -> TestAActivity -> TestBActivity ->TestCActivity -> TestBActivity
SingleTask

In the stack reuse mode, as long as the Activity exists in a stack, no instance will be created when it is called multiple times, that is, the singleton mode.

The situations include the following:
(1) The task stack does not exist. When the SingleTask instance is started for the first time, the task stack and instance will be created.

MainActivity starts TestA, TestA starts TestB, TestB is a SingleTask, and the task stack is different. It can be observed that the system contains two task stacks, and TestB is in the other task stack.

 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{d5d53d4 # 2727 A=me.chunyu.spike.stack U= 0 sz= 1 }
      Run # 2 : ActivityRecord{1d720e55 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2727}
    TaskRecord{a3f797d # 2726 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 2 }
      Run # 1 : ActivityRecord{ffd689d ​​u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2726}
      Run # 0 : ActivityRecord{192310ac u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2726}

Use the taskAffinity attribute to add a new Activity stack and use it with SingleTask. Standard mode is invalid.

The new task stack is me.chunyu.spike.stack.
(2) The task stack exists. When a SingleTask instance is started for the first time, it will be directly pushed into the stack, the same as the Standard mode.

(3) If the task stack is the same, and the SingleTask instance is started again, the instance will be placed on the top of the stack and the instances above it will be cleared, which has the effect of clearTop.

MainActivity starts TestA, TestA starts TestB, TestB is a SingleTask, TestB starts TestC, TestC restarts TestB, then TestC will pop out of the stack. It can be observed that TestC pops out of the stack and TestB is at the top of the stack.

 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{ 18230815 # 2737 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 3 }
      Run # 4 : ActivityRecord{1126c300 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2737}
      Run # 3 : ActivityRecord{3114fee8 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2737}
      Run # 2 : ActivityRecord{f8e235d u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2737}

TestC starts TestB in SingleTask mode, which causes clearTop and pops TestC out of the stack.
(4) The task stack is different. Starting the SingleTask instance again will cause the task stack to switch, and the background will be placed in the foreground.

This is difficult to understand. MainActivity starts TestA, TestA starts TestB (SingleTask instance, different task stack), TestB starts TestC (similar to B), then MainActivity and TestA have the same stack, TestB and TestC have the same stack, and the top of the stack is TestC. Press the Home button and start the app again, then the default task stack will start, TestA starts, and TestA starts TestC. The current status of the app is as follows.

 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{1d05e6c9 # 2754 A=me.chunyu.spike.stack U= 0 sz= 2 }
      Run # 4 : ActivityRecord{3f77e822 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestCActivity t2754}
    TaskRecord{3fe736d0 # 2753 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 2 }
      Run # 3 : ActivityRecord{15f0470e u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2753}
    TaskRecord{1d05e6c9 # 2754 A=me.chunyu.spike.stack U= 0 sz= 2 }
      Run # 2 : ActivityRecord{181229e6 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2754}
    TaskRecord{3fe736d0 # 2753 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 2 }
      Run # 1 : ActivityRecord{28628d61 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2753}
    TaskRecord{2d646058 # 2719 A=com.android.incallui U= 0 sz= 1 }

TestC is at the top of the stack. Clicking the Back key does not return to TestA (which starts the instance of TestC), but to TestB, which gives priority to returning to the instance in the same stack. Then TestA, then MainActivity, are popped out of the stack in order.
SingleInstance

In single instance mode, when it is started, the system will create a separate task stack for it. Each subsequent use will use this single instance until it is destroyed. This is a true single instance mode.

Example: MainActivity starts TestA, TestA starts TestB (SingleInstance mode),

TestB starts TestC, and TestC starts TestB again, so the last TestB is still started.

TestC is merged into the default stack (MainActivity+TestA).

 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{384e3928 # 2765 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 1 }
      Run # 3 : ActivityRecord{1ffc5b6b u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2765}
    TaskRecord{2ad03544 # 2764 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 3 }
      Run # 2 : ActivityRecord{293d8c37 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestCActivity t2764}
      Run # 1 : ActivityRecord{158bc0f3 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2764}
      Run # 0 : ActivityRecord{77691cf u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2764}

startActivityForResult

startActivityForResult is different from startActivity. When launching Activity using LaunchMode mode, there will be some differences. Data can be passed normally, but it cannot create itself continuously, and multiple instances will be generated.

When TestB (singleTask mode) creates itself using startActivity, it uses the default instance, i.e. the singleton; when it creates itself using startActivityForResult, it generates a new instance.

 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{323200ac # 2786 A=me.chunyu.clwang.stack U= 0 sz= 3 }
      Run # 4 : ActivityRecord{3f9e14f3 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2786}
      Run # 3 : ActivityRecord{30d8f17b u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2786}
      Run # 2 : ActivityRecord{11b95b5c u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestBActivity t2786}
    TaskRecord{c86e175 # 2785 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 2 }
      Run # 1 : ActivityRecord{3558d7c4 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.TestAActivity t2785}
      Run # 0 : ActivityRecord{1b8620c u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2785}

From this we can see that because startActivityForResult needs to return a value, the instance will be retained, overwriting the singleton effect.

Note: In version 4.x, singleTask is started via startActivityForResult, and the return value cannot be obtained normally. For reference,

This issue is fixed in versions 5.x and above. Considering compatibility, it is not recommended to use startActivityForResult and singleTask.
Intent sets flags

Intent can set the startup flag, namely Flag.

 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

AndroidManifest cannot set FLAG_ACTIVITY_CLEAR_TOP, which means clearing other instances on the stack; Intent cannot set singleInstance startup mode. You can choose one of them. If you use both, Intent has a higher priority than AndroidManifest.

Commonly used flags:

FLAG_ACTIVITY_NEW_TASK: Same as singleTask startup mode.

FLAG_ACTIVITY_SINGLE_TOP: Same as singleTop startup mode.

FLAG_ACTIVITY_CLEAR_TOP: Usually appears with singleTask startup mode. If it is singleTask startup mode, other instances on the stack will be cleared, the instance will be reused, and onNewIntent will be called; if it is standard startup mode, that is, the default mode, it will clear itself and other instances, recreate them, and call onCreate.
Shell command to display stack

Shell Commands

 adb shell dumpsys activity | sed -n -e '/Stack #/p' -e '/Running activities/,/Run #0/p'  

Directly getting the Activity information is somewhat redundant, we only need to focus on the stack information.

sed can edit displayed text.

-n , process continuously from the point of interception.

-e , multiple selection parameters.

'/Stack #/p' , output lines containing Stack #.

-e '/Running activities/,/Run #0/p' , output all the lines from Running activities to Run #0.

Output

   
 
 Stack # 1 :
  Running activities (most recent first):
    TaskRecord{299f41ea # 2269 A=me.chunyu.spike.wcl_activity_launchmode_demo U= 0 sz= 6 }
      Run # 5 : ActivityRecord{ 33926043 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2269}
      Run # 4 : ActivityRecord{3f181566 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2269}
      Run # 3 : ActivityRecord{22737e45 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2269}
      Run # 2 : ActivityRecord{ce0a990 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2269}
      Run # 1 : ActivityRecord{3de8e378 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2269}
      Run # 0 : ActivityRecord{1cb28ec4 u0 me.chunyu.spike.wcl_activity_launchmode_demo/.MainActivity t2269}
 Stack # 0 :
  Running activities (most recent first):
    TaskRecord{bfee9cf # 2241 A=com.miui.home U= 0 sz= 1 }
      Run # 0 : ActivityRecord{279bc098 u0 com.miui.home/.launcher.Launcher t2241}

As an important attribute of Activity, the startup mode still needs to be mastered thoroughly.

OK, that's all! Enjoy it!