再接下来，就是运行模拟器来运行我们的例子了。关于如何在Android源代码工程中运行模拟器，请参考 在Ubuntu上下载、编译和安装Android最新源代码 一文。
执行以下命令启动模拟器： 
        
                
  1.            USER-NAME@MACHINE-NAME:~/Android$emulator     
    2.
模拟器启动起，就可以App Launcher中找到Task应用程序图标，接着把它启动起来：

点击中间的按钮，就会以"singleTask"的方式来启动SubActivity：

现在，我们如何来确认SubActivity是不是在新的任务中启动并且位于这个新任务的堆栈底部呢？Android源代码工程为我们准备了adb工具，可以查看模拟器上系统运行的状况，执行下面的命令查看;

        
                
  1. USER-NAME@MACHINE-NAME:~/Android$adbshelldumpsysactivity
    2.

这个命令输出的内容比较多，这里我们只关心TaskRecord部分：

        
                
  1. Runningactivities(mostrecentfirst):
    2.             
  2. TaskRecord{4070d8f8#3Ashy.luo.task}
    3.             
  3. Run#2:HistoryRecord{406a13f8shy.luo.task/.SubActivity}
    4.             
  4. Run#1:HistoryRecord{406a0e00shy.luo.task/.MainActivity}
    5.             
  5. TaskRecord{4067a510#2Acom.android.launcher}
    6.             
  6. Run#0:HistoryRecord{40677518com.android.launcher/com.android.launcher2.Launcher}
    7.

果然，SubActivity和MainActivity都是运行在TaskRecord#3中，并且SubActivity在MainActivity的上面。这是怎么回事呢？碰到这种情况，Linus Torvalds告诫我们：Read the fucking source code；去年张麻子又说：枪在手，跟我走；我们没有枪，但是有source code，因此，我要说：跟着代码走。

前面我们在两篇文章Android应用程序启动过程源代码分析和Android应用程序内部启动Activity过程（startActivity）的源代码分析时，分别在Step 9和Step 8中分析了Activity在启动过程中与任务相关的函数ActivityStack.startActivityUncheckedLocked函数中，它定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

        
                
  1. publicclassActivityStack{
    2.             
    3.             
  3. ......
    4.             
    5.             
  5. finalintstartActivityUncheckedLocked(ActivityRecordr,
    6.             
  6. ActivityRecordsourceRecord,Uri[]grantedUriPermissions,
    7.             
  7. intgrantedMode,booleanonlyIfNeeded,booleandoResume){
    8.             
  8. finalIntentintent=r.intent;
    9.             
  9. finalintcallingUid=r.launchedFromUid;
    10.             
    11.             
  11. intlaunchFlags=intent.getFlags();
    12.             
    13.             
  13. ......
    14.             
    15.             
  15. ActivityRecordnotTop=(launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)
    16.             
  16. !=0?r:null;
    17.             
    18.             
  18. ......
    19.             
    20.             
  20. if(sourceRecord==null){
    21.             
  21. ......
    22.             
  22. }elseif(sourceRecord.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){
    23.             
  23. ......
    24.             
  24. }elseif(r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE
    25.             
  25. ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK){
    26.             
  26. //Theactivitybeingstartedisasingleinstance...italways
    27.             
  27. //getslaunchedintoitsowntask.
    28.             
  28. launchFlags|=Intent.FLAG_ACTIVITY_NEW_TASK;
    29.             
  29. }
    30.             
    31.             
  31. ......
    32.             
    33.             
  33. booleanaddingToTask=false;
    34.             
  34. if(((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=0&&
    35.             
  35. (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK)==0)
    36.             
  36. ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK
    37.             
  37. ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){
    38.             
  38. //Ifbringtofrontisrequested,andnoresultisrequested,and
    39.             
  39. //wecanfindataskthatwasstartedwiththissame
    40.             
  40. //component,theninsteadoflaunchingbringthatonetothefront.
    41.             
  41. if(r.resultTo==null){
    42.             
  42. //Seeifthereisatasktobringtothefront.Ifthisis
    43.             
  43. //aSINGLE_INSTANCEactivity,therecanbeoneandonlyone
    44.             
  44. //instanceofitinthehistory,anditisalwaysinitsown
    45.             
  45. //uniquetask,sowedoaspecialsearch.
    46.             
  46. ActivityRecordtaskTop=r.launchMode!=ActivityInfo.LAUNCH_SINGLE_INSTANCE
    47.             
  47. ?findTaskLocked(intent,r.info)
    48.             
  48. :findActivityLocked(intent,r.info);
    49.             
  49. if(taskTop!=null){
    50.             
    51.             
  51. ......
    52.             
    53.             
  53. if((launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP)!=0
    54.             
  54. ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK
    55.             
  55. ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){
    56.             
  56. //Inthissituationwewanttoremoveallactivities
    57.             
  57. //fromthetaskuptotheonebeingstarted.Inmost
    58.             
  58. //casesthismeansweareresettingthetasktoits
    59.             
  59. //initialstate.
    60.             
  60. ActivityRecordtop=performClearTaskLocked(
    61.             
  61. taskTop.task.taskId,r,launchFlags,true);
    62.             
  62. if(top!=null){
    63.             
  63. ......
    64.             
  64. }else{
    65.             
  65. //Aspecialcase:weneedto
    66.             
  66. //starttheactivitybecauseitisnotcurrently
    67.             
  67. //running,andthecallerhasaskedtoclearthe
    68.             
  68. //currenttasktohavethisactivityatthetop.
    69.             
  69. addingToTask=true;
    70.             
  70. //Nowpretendlikethisactivityisbeingstarted
    71.             
  71. //bythetopofitstask,soitisputinthe
    72.             
  72. //rightplace.
    73.             
  73. sourceRecord=taskTop;
    74.             
  74. }
    75.             
  75. }elseif(r.realActivity.equals(taskTop.task.realActivity)){
    76.             
  76. ......
    77.             
  77. }elseif((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)==0){
    78.             
  78. ......
    79.             
  79. }elseif(!taskTop.task.rootWasReset){
    80.             
  80. ......
    81.             
  81. }
    82.             
    83.             
  83. ......
    84.             
  84. }
    85.             
  85. }
    86.             
  86. }
    87.             
    88.             
  88. ......
    89.             
    90.             
  90. if(r.packageName!=null){
    91.             
  91. //Iftheactivitybeinglaunchedisthesameastheonecurrently
    92.             
  92. //atthetop,thenweneedtocheckifitshouldonlybelaunched
    93.             
  93. //once.
    94.             
  94. ActivityRecordtop=topRunningNonDelayedActivityLocked(notTop);
    95.             
  95. if(top!=null&&r.resultTo==null){
    96.             
  96. if(top.realActivity.equals(r.realActivity)){
    97.             
  97. if(top.app!=null&&top.app.thread!=null){
    98.             
  98. ......
    99.             
  99. }
    100.             
  100. }
    101.             
  101. }
    102.             
    103.             
  103. }else{
    104.             
  104. ......
    105.             
  105. }
    106.             
    107.             
  107. booleannewTask=false;
    108.             
    109.             
  109. //Shouldthisbeconsideredanewtask?
    110.             
  110. if(r.resultTo==null&&!addingToTask
    111.             
  111. &&(launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=0){
    112.             
  112. //todo:shoulddobettermanagementofintegers.
    113.             
  113. mService.mCurTask++;
    114.             
  114. if(mService.mCurTask<=0){
    115.             
  115. mService.mCurTask=1;
    116.             
  116. }
    117.             
  117. r.task=newTaskRecord(mService.mCurTask,r.info,intent,
    118.             
  118. (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH)!=0);
    119.             
  119. if(DEBUG_TASKS)Slog.v(TAG,"Startingnewactivity"+r
    120.             
  120. +"innewtask"+r.task);
    121.             
  121. newTask=true;
    122.             
  122. if(mMainStack){
    123.             
  123. mService.addRecentTaskLocked(r.task);
    124.             
  124. }
    125.             
  125. }elseif(sourceRecord!=null){
    126.             
  126. if(!addingToTask&&
    127.             
  127. (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP)!=0){
    128.             
  128. ......
    129.             
  129. }elseif(!addingToTask&&
    130.             
  130. (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT)!=0){
    131.             
  131. ......
    132.             
  132. }
    133.             
  133. //Anexistingactivityisstartingthisnewactivity,sowewant
    134.             
  134. //tokeepthenewoneinthesametaskastheonethatisstarting
    135.             
  135. //it.
    136.             
  136. r.task=sourceRecord.task;
    137.             
    138.             
  138. ......
    139.             
    140.             
  140. }else{
    141.             
  141. ......
    142.             
  142. }
    143.             
    144.             
  144. ......
    145.             
    146.             
  146. startActivityLocked(r,newTask,doResume);
    147.             
  147. returnSTART_SUCCESS;
    148.             
  148. }
    149.             
    150.             
  150. ......
    151.             
    152.             
  152. }
    153.

首先是获得用来启动Activity的Intent的Flags，并且保存在launchFlags变量中，这里，launcFlags的Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP位没有置位，因此，notTop为null。

接下来的这个if语句：

        
                
  1. if(sourceRecord==null){
    2.             
  2. ......
    3.             
  3. }elseif(sourceRecord.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){
    4.             
  4. ......
    5.             
  5. }elseif(r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE
    6.             
  6. ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK){
    7.             
  7. //Theactivitybeingstartedisasingleinstance...italways
    8.             
  8. //getslaunchedintoitsowntask.
    9.             
  9. launchFlags|=Intent.FLAG_ACTIVITY_NEW_TASK;
    10.             
  10. }
    11.

这里变量r的类型为ActivityRecord，它表示即将在启动的Activity，在这个例子中，即为SubActivity，因此，这里的r.launchMode等于ActivityInfo.LAUNCH_SINGLE_TASK，于是，无条件将launchFlags的Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP位置为1，表示这个SubActivity要在新的任务中启动，但是别急，还要看看其它条件是否满足，如果条件都满足，才可以在新的任务中启动这个SubActivity。
接下将addingToTask变量初始化为false，这个变量也将决定是否要将SubActivity在新的任务中启动，从名字我们就可以看出，默认不增加到原有的任务中启动，即要在新的任务中启动。这里的r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK条成立，条件r.resultTo == null也成立，它表这个Activity不需要将结果返回给启动它的Activity。于是会进入接下来的if语句中，执行：

        
                
  1. ActivityRecordtaskTop=r.launchMode!=ActivityInfo.LAUNCH_SINGLE_INSTANCE
    2.             
  2. ?findTaskLocked(intent,r.info)
    3.             
  3. :findActivityLocked(intent,r.info)
    4.

这里的条件r.launchMode !=ActivityInfo.LAUNCH_SINGLE_INSTANCE成立，于是执行findTaskLocked函数，这个函数也是定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

        
                
  1. publicclassActivityStack{
    2.             
    3.             
  3. ......
    4.             
    5.             
  5. /**
    6.             
  6. *Returnsthetopactivityinanyexistingtaskmatchingthegiven
    7.             
  7. *Intent.Returnsnullifnosuchtaskisfound.
    8.             
  8. */
    9.             
  9. privateActivityRecordfindTaskLocked(Intentintent,ActivityInfoinfo){
    10.             
  10. ComponentNamecls=intent.getComponent();
    11.             
  11. if(info.targetActivity!=null){
    12.             
  12. cls=newComponentName(info.packageName,info.targetActivity);
    13.             
  13. }
    14.             
    15.             
  15. TaskRecordcp=null;
    16.             
    17.             
  17. finalintN=mHistory.size();
    18.             
  18. for(inti=(N-1);i>=0;i--){
    19.             
  19. ActivityRecordr=(ActivityRecord)mHistory.get(i);
    20.             
  20. if(!r.finishing&&r.task!=cp
    21.             
  21. &&r.launchMode!=ActivityInfo.LAUNCH_SINGLE_INSTANCE){
    22.             
  22. cp=r.task;
    23.             
  23. //Slog.i(TAG,"Comparingexistingcls="+r.task.intent.getComponent().flattenToShortString()
    24.             
  24. //+"/aff="+r.task.affinity+"tonewcls="
    25.             
  25. //+intent.getComponent().flattenToShortString()+"/aff="+taskAffinity);
    26.             
  26. if(r.task.affinity!=null){
    27.             
  27. if(r.task.affinity.equals(info.taskAffinity)){
    28.             
  28. //Slog.i(TAG,"Foundmatchingaffinity!");
    29.             
  29. returnr;
    30.             
  30. }
    31.             
  31. }elseif(r.task.intent!=null
    32.             
  32. &&r.task.intent.getComponent().equals(cls)){
    33.             
  33. //Slog.i(TAG,"Foundmatchingclass!");
    34.             
  34. //dump();
    35.             
  35. //Slog.i(TAG,"ForIntent"+intent+"bringingtotop:"+r.intent);
    36.             
  36. returnr;
    37.             
  37. }elseif(r.task.affinityIntent!=null
    38.             
  38. &&r.task.affinityIntent.getComponent().equals(cls)){
    39.             
  39. //Slog.i(TAG,"Foundmatchingclass!");
    40.             
  40. //dump();
    41.             
  41. //Slog.i(TAG,"ForIntent"+intent+"bringingtotop:"+r.intent);
    42.             
  42. returnr;
    43.             
  43. }
    44.             
  44. }
    45.             
  45. }
    46.             
    47.             
  47. returnnull;
    48.             
  48. }
    49.             
    50.             
  50. ......
    51.             
    52.             
  52. }
    53.

这个函数无非就是根据即将要启动的SubActivity的taskAffinity属性值在系统中查找这样的一个Task：Task的affinity属性值与即将要启动的Activity的taskAffinity属性值一致。如果存在，就返回这个Task堆栈顶端的Activity回去。在上面的AndroidManifest.xml文件中，没有配置MainActivity和SubActivity的taskAffinity属性，于是它们的taskAffinity属性值就默认为父标签application的taskAffinity属性值，这里，标签application的taskAffinity也没有配置，于是它们就默认为包名，即"shy.luo.task"。由于在启动SubActivity之前，MainActivity已经启动，MainActivity启动的时候，会在一个新的任务里面启动，而这个新的任务的affinity属性就等于它的第一个Activity的taskAffinity属性值。于是，这个函数会动回表示MainActivity的ActivityRecord回去.

回到前面的startActivityUncheckedLocked函数中，这里的taskTop就表示MainActivity，它不为null，于是继续往前执行。由于条件r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK成立，于是执行下面语句：

        
                
  1. ActivityRecordtop=performClearTaskLocked(
    2.             
  2. kTop.task.taskId,r,launchFlags,true);
    3.

函数performClearTaskLocked也是定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中：

        
                
  1. publicclassActivityStack{
    2.             
    3.             
  3. ......
    4.             
    5.             
  5. /**
    6.             
  6. *Performclearoperationasrequestedby
    7.             
  7. *{@linkIntent#FLAG_ACTIVITY_CLEAR_TOP}:searchfromthetopofthe
    8.             
  8. *stacktothegiventask,thenlookfor
    9.             
  9. *aninstanceofthatactivityinthestackand,iffound,finishall
    10.             
  10. *activitiesontopofitandreturntheinstance.
    11.             
  11. *
    12.             
  12. *@paramnewRDescriptionofthenewactivitybeingstarted.
    13.             
  13. *@returnReturnstheoldactivitythatshouldbecontinuetobeused,
    14.             
  14. *ornullifnonewasfound.
    15.             
  15. */
    16.             
  16. privatefinalActivityRecordperformClearTaskLocked(inttaskId,
    17.             
  17. ActivityRecordnewR,intlaunchFlags,booleandoClear){
    18.             
  18. inti=mHistory.size();
    19.             
    20.             
  20. //Firstfindtherequestedtask.
    21.             
  21. while(i>0){
    22.             
  22. i--;
    23.             
  23. ActivityRecordr=(ActivityRecord)mHistory.get(i);
    24.             
  24. if(r.task.taskId==taskId){
    25.             
  25. i++;
    26.             
  26. break;
    27.             
  27. }
    28.             
  28. }
    29.             
    30.             
  30. //Nowclearit.
    31.             
  31. while(i>0){
    32.             
  32. i--;
    33.             
  33. ActivityRecordr=(ActivityRecord)mHistory.get(i);
    34.             
  34. if(r.finishing){
    35.             
  35. continue;
    36.             
  36. }
    37.             
  37. if(r.task.taskId!=taskId){
    38.             
  38. returnnull;
    39.             
  39. }
    40.             
  40. if(r.realActivity.equals(newR.realActivity)){
    41.             
  41. //Hereitis!Nowfinisheverythinginfront...
    42.             
  42. ActivityRecordret=r;
    43.             
  43. if(doClear){
    44.             
  44. while(i<(mHistory.size()-1)){
    45.             
  45. i++;
    46.             
  46. r=(ActivityRecord)mHistory.get(i);
    47.             
  47. if(r.finishing){
    48.             
  48. continue;
    49.             
  49. }
    50.             
  50. if(finishActivityLocked(r,i,Activity.RESULT_CANCELED,
    51.             
  51. null,"clear")){
    52.             
  52. i--;
    53.             
  53. }
    54.             
  54. }
    55.             
  55. }
    56.             
    57.             
  57. //Finally,ifthisisanormallaunchmode(thatis,not
    58.             
  58. //expectingonNewIntent()),thenwewillfinishthecurrent
    59.             
  59. //instanceoftheactivitysoanewfreshonecanbestarted.
    60.             
  60. if(ret.launchMode==ActivityInfo.LAUNCH_MULTIPLE
    61.             
  61. &&(launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP)==0){
    62.             
  62. if(!ret.finishing){
    63.             
  63. intindex=indexOfTokenLocked(ret);
    64.             
  64. if(index>=0){
    65.             
  65. finishActivityLocked(ret,index,Activity.RESULT_CANCELED,
    66.             
  66. null,"clear");
    67.             
  67. }
    68.             
  68. returnnull;
    69.             
  69. }
    70.             
  70. }
    71.             
    72.             
  72. returnret;
    73.             
  73. }
    74.             
  74. }
    75.             
    76.             
  76. returnnull;
    77.             
  77. }
    78.             
    79.             
  79. ......
    80.             
    81.             
  81. }
    82.

这个函数中作用无非就是找到ID等于参数taskId的任务，然后在这个任务中查找是否已经存在即将要启动的Activity的实例，如果存在，就会把这个Actvity实例上面直到任务堆栈顶端的Activity通过调用finishActivityLocked函数将它们结束掉。在这个例子中，就是要在属性值affinity等于"shy.luo.task"的任务中看看是否存在SubActivity类型的实例，如果有，就把它上面的Activity都结束掉。这里，属性值affinity等于"shy.luo.task"的任务只有一个MainActivity，而且它不是SubActivity的实例，所以这个函数就返回null了。

更多相关文章

  1. TextView的XML属性说明全析 ---Android基础篇
  2. Android 利用JNI调用Android Java代码函数
  3. android之TextView属性
  4. Android EditText inputType属性
  5. Android中的singleLine（单行显示）和ellipsize属性
  6. android taskAffinity属性
  7. android xml常规布局属性

随机推荐

  1. 谈中型项目下的编码技巧二
  2. Android(安卓)LinearLayout 点击背景颜色
  3. Android(安卓)使用AES/CBC/PKCS7Padding
  4. android ListView向上滑动隐藏标题，下拉显
  5. Android中使用Geocoding API
  6. Android实现的视频背景
  7. Android(安卓)开发学习笔记（一）—— 四大组
  8. OkHttp得拦截机制
  9. Android(安卓)AMS(一) App启动过程之Task
  10. 多个项目Module全局配置