再接下来，就是运行模拟器来运行我们的例子了。关于如何在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. 箭头函数的基础使用
  2. Python技巧匿名函数、回调函数和高阶函数
  3. android 视频通话 项目 源码
  4. findViewById()使用常见错误
  5. Android(安卓)- ListActivity 单击事件的响应
  6. Android应用程序启动过程源代码分析
  7. Android驱动（一）硬件访问服务学习之（一）Android通过JNI访问硬件
  8. android WebView总结
  9. Android(安卓)利用JNI调用Android(安卓)Java代码函数

随机推荐

  1. Android复习(八)
  2. Android上的log，日志相关
  3. android 软键盘隐藏 activity初始化时edi
  4. Android(安卓)远程链接 daemon not runni
  5. android中的内存泄露
  6. android studio升级时提示 Connection fa
  7. webrtc 针对 android 平台的编译和运行
  8. android开发BUG集
  9. [置顶] 自定义的解压进度条 关于Progress
  10. Android自定义Toast，并解决toast不重复显