Step 8. ActivityStack.startActivityLocked 这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中： 
        
                
  1.            public      classActivityStack{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  final      intstartActivityLocked(IApplicationThreadcaller,     
    6.             
  6.            Intentintent,StringresolvedType,     
    7.             
  7.            Uri[]grantedUriPermissions,     
    8.             
  8.                  intgrantedMode,ActivityInfoaInfo,IBinderresultTo,     
    9.             
  9.            StringresultWho,      intrequestCode,     
    10.             
  10.                  intcallingPid,      intcallingUid,      booleanonlyIfNeeded,     
    11.             
  11.                  booleancomponentSpecified){     
    12.             
  12.                  interr=START_SUCCESS;     
    13.             
  13.                 
    14.             
  14.            ProcessRecordcallerApp=      null;     
    15.             
  15.                  if(caller!=      null){     
    16.             
  16.            callerApp=mService.getRecordForAppLocked(caller);     
    17.             
  17.                  if(callerApp!=      null){     
    18.             
  18.            callingPid=callerApp.pid;     
    19.             
  19.            callingUid=callerApp.info.uid;     
    20.             
  20.            }      else{     
    21.             
  21.            ......     
    22.             
  22.            }     
    23.             
  23.            }     
    24.             
  24.                 
    25.             
  25.            ......     
    26.             
  26.                 
    27.             
  27.            ActivityRecordsourceRecord=      null;     
    28.             
  28.            ActivityRecordresultRecord=      null;     
    29.             
  29.                  if(resultTo!=      null){     
    30.             
  30.                  intindex=indexOfTokenLocked(resultTo);     
    31.             
  31.                 
    32.             
  32.            ......     
    33.             
  33.                 
    34.             
  34.                  if(index>=      0){     
    35.             
  35.            sourceRecord=(ActivityRecord)mHistory.get(index);     
    36.             
  36.                  if(requestCode>=      0&&!sourceRecord.finishing){     
    37.             
  37.            ......     
    38.             
  38.            }     
    39.             
  39.            }     
    40.             
  40.            }     
    41.             
  41.                 
    42.             
  42.                  intlaunchFlags=intent.getFlags();     
    43.             
  43.                 
    44.             
  44.                  if((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT)!=      0     
    45.             
  45.            &&sourceRecord!=      null){     
    46.             
  46.            ......     
    47.             
  47.            }     
    48.             
  48.                 
    49.             
  49.                  if(err==START_SUCCESS&&intent.getComponent()==      null){     
    50.             
  50.            ......     
    51.             
  51.            }     
    52.             
  52.                 
    53.             
  53.                  if(err==START_SUCCESS&&aInfo==      null){     
    54.             
  54.            ......     
    55.             
  55.            }     
    56.             
  56.                 
    57.             
  57.                  if(err!=START_SUCCESS){     
    58.             
  58.            ......     
    59.             
  59.            }     
    60.             
  60.                 
    61.             
  61.            ......     
    62.             
  62.                 
    63.             
  63.            ActivityRecordr=      newActivityRecord(mService,      this,callerApp,callingUid,     
    64.             
  64.            intent,resolvedType,aInfo,mService.mConfiguration,     
    65.             
  65.            resultRecord,resultWho,requestCode,componentSpecified);     
    66.             
  66.                 
    67.             
  67.            ......     
    68.             
  68.                 
    69.             
  69.                  returnstartActivityUncheckedLocked(r,sourceRecord,     
    70.             
  70.            grantedUriPermissions,grantedMode,onlyIfNeeded,      true);     
    71.             
  71.            }     
    72.             
  72.                 
    73.             
  73.                 
    74.             
  74.            ......     
    75.             
  75.                 
    76.             
  76.            }     
    77.
从传进来的参数caller得到调用者的进程信息，并保存在callerApp变量中，这里就是Launcher应用程序的进程信息了。 前面说过，参数resultTo是Launcher这个Activity里面的一个Binder对象，通过它可以获得Launcher这个Activity的相关信息，保存在sourceRecord变量中。
再接下来，创建即将要启动的Activity的相关信息，并保存在r变量中： 
            
                    
  1.              ActivityRecordr=       newActivityRecord(mService,       this,callerApp,callingUid,      
    2.                 
  2.              intent,resolvedType,aInfo,mService.mConfiguration,      
    3.                 
  3.              resultRecord,resultWho,requestCode,componentSpecified);      
    4.
接着调用startActivityUncheckedLocked函数进行下一步操作。 Step 9. ActivityStack.startActivityUncheckedLocked 这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中： 
        
                
  1.            public      classActivityStack{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  final      intstartActivityUncheckedLocked(ActivityRecordr,     
    6.             
  6.            ActivityRecordsourceRecord,Uri[]grantedUriPermissions,     
    7.             
  7.                  intgrantedMode,      booleanonlyIfNeeded,      booleandoResume){     
    8.             
  8.                  finalIntentintent=r.intent;     
    9.             
  9.                  final      intcallingUid=r.launchedFromUid;     
    10.             
  10.                 
    11.             
  11.                  intlaunchFlags=intent.getFlags();     
    12.             
  12.                 
    13.             
  13.                  //We'llinvokeonUserLeavingbeforeonPauseonlyifthelaunching     
    14.             
  14.                  //activitydidnotexplicitlystatethatthisisanautomatedlaunch.     
    15.             
  15.            mUserLeaving=(launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION)==      0;     
    16.             
  16.                 
    17.             
  17.            ......     
    18.             
  18.                 
    19.             
  19.            ActivityRecordnotTop=(launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)     
    20.             
  20.            !=      0?r:      null;     
    21.             
  21.                 
    22.             
  22.                  //IftheonlyIfNeededflagisset,thenwecandothisiftheactivity     
    23.             
  23.                  //beinglaunchedisthesameastheonemakingthecall...or,as     
    24.             
  24.                  //aspecialcase,ifwedonotknowthecallerthenwecountthe     
    25.             
  25.                  //currenttopactivityasthecaller.     
    26.             
  26.                  if(onlyIfNeeded){     
    27.             
  27.            ......     
    28.             
  28.            }     
    29.             
  29.                 
    30.             
  30.                  if(sourceRecord==      null){     
    31.             
  31.            ......     
    32.             
  32.            }      else      if(sourceRecord.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){     
    33.             
  33.            ......     
    34.             
  34.            }      else      if(r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE     
    35.             
  35.            ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK){     
    36.             
  36.            ......     
    37.             
  37.            }     
    38.             
  38.                 
    39.             
  39.                  if(r.resultTo!=      null&&(launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=      0){     
    40.             
  40.            ......     
    41.             
  41.            }     
    42.             
  42.                 
    43.             
  43.                  booleanaddingToTask=      false;     
    44.             
  44.                  if(((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=      0&&     
    45.             
  45.            (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK)==      0)     
    46.             
  46.            ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK     
    47.             
  47.            ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){     
    48.             
  48.                  //Ifbringtofrontisrequested,andnoresultisrequested,and     
    49.             
  49.                  //wecanfindataskthatwasstartedwiththissame     
    50.             
  50.                  //component,theninsteadoflaunchingbringthatonetothefront.     
    51.             
  51.                  if(r.resultTo==      null){     
    52.             
  52.                  //Seeifthereisatasktobringtothefront.Ifthisis     
    53.             
  53.                  //aSINGLE_INSTANCEactivity,therecanbeoneandonlyone     
    54.             
  54.                  //instanceofitinthehistory,anditisalwaysinitsown     
    55.             
  55.                  //uniquetask,sowedoaspecialsearch.     
    56.             
  56.            ActivityRecordtaskTop=r.launchMode!=ActivityInfo.LAUNCH_SINGLE_INSTANCE     
    57.             
  57.            ?findTaskLocked(intent,r.info)     
    58.             
  58.            :findActivityLocked(intent,r.info);     
    59.             
  59.                  if(taskTop!=      null){     
    60.             
  60.            ......     
    61.             
  61.            }     
    62.             
  62.            }     
    63.             
  63.            }     
    64.             
  64.                 
    65.             
  65.            ......     
    66.             
  66.                 
    67.             
  67.                  if(r.packageName!=      null){     
    68.             
  68.                  //Iftheactivitybeinglaunchedisthesameastheonecurrently     
    69.             
  69.                  //atthetop,thenweneedtocheckifitshouldonlybelaunched     
    70.             
  70.                  //once.     
    71.             
  71.            ActivityRecordtop=topRunningNonDelayedActivityLocked(notTop);     
    72.             
  72.                  if(top!=      null&&r.resultTo==      null){     
    73.             
  73.                  if(top.realActivity.equals(r.realActivity)){     
    74.             
  74.            ......     
    75.             
  75.            }     
    76.             
  76.            }     
    77.             
  77.                 
    78.             
  78.            }      else{     
    79.             
  79.            ......     
    80.             
  80.            }     
    81.             
  81.                 
    82.             
  82.                  booleannewTask=      false;     
    83.             
  83.                 
    84.             
  84.                  //Shouldthisbeconsideredanewtask?     
    85.             
  85.                  if(r.resultTo==      null&&!addingToTask     
    86.             
  86.            &&(launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=      0){     
    87.             
  87.                  //todo:shoulddobettermanagementofintegers.     
    88.             
  88.            mService.mCurTask++;     
    89.             
  89.                  if(mService.mCurTask<=      0){     
    90.             
  90.            mService.mCurTask=      1;     
    91.             
  91.            }     
    92.             
  92.            r.task=      newTaskRecord(mService.mCurTask,r.info,intent,     
    93.             
  93.            (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH)!=      0);     
    94.             
  94.            ......     
    95.             
  95.            newTask=      true;     
    96.             
  96.                  if(mMainStack){     
    97.             
  97.            mService.addRecentTaskLocked(r.task);     
    98.             
  98.            }     
    99.             
  99.                 
    100.             
  100.            }      else      if(sourceRecord!=      null){     
    101.             
  101.            ......     
    102.             
  102.            }      else{     
    103.             
  103.            ......     
    104.             
  104.            }     
    105.             
  105.                 
    106.             
  106.            ......     
    107.             
  107.                 
    108.             
  108.            startActivityLocked(r,newTask,doResume);     
    109.             
  109.                  returnSTART_SUCCESS;     
    110.             
  110.            }     
    111.             
  111.                 
    112.             
  112.            ......     
    113.             
  113.                 
    114.             
  114.            }     
    115.
函数首先获得intent的标志值，保存在launchFlags变量中。 这个intent的标志值的位Intent.FLAG_ACTIVITY_NO_USER_ACTION没有置位，因此 ，成员变量mUserLeaving的值为true。 这个intent的标志值的位Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP也没有置位，因此，变量notTop的值为null。 由于在这个例子的AndroidManifest.xml文件中，MainActivity没有配置launchMode属值，因此，这里的r.launchMode为默认值0，表示以标准（Standard，或者称为ActivityInfo.LAUNCH_MULTIPLE）的方式来启动这个Activity。Activity的启动方式有四种，其余三种分别是ActivityInfo.LAUNCH_SINGLE_INSTANCE、ActivityInfo.LAUNCH_SINGLE_TASK和ActivityInfo.LAUNCH_SINGLE_TOP，具体可以参考官方网站 http://developer.android.com/reference/android/content/pm/ActivityInfo.html。 传进来的参数r.resultTo为null，表示Launcher不需要等这个即将要启动的MainActivity的执行结果。 由于这个intent的标志值的位Intent.FLAG_ACTIVITY_NEW_TASK被置位，而且Intent.FLAG_ACTIVITY_MULTIPLE_TASK没有置位，因此，下面的if语句会被执行： 
        
                
  1.                  if(((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=      0&&     
    2.             
  2.            (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK)==      0)     
    3.             
  3.            ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_TASK     
    4.             
  4.            ||r.launchMode==ActivityInfo.LAUNCH_SINGLE_INSTANCE){     
    5.             
  5.                  //Ifbringtofrontisrequested,andnoresultisrequested,and     
    6.             
  6.                  //wecanfindataskthatwasstartedwiththissame     
    7.             
  7.                  //component,theninsteadoflaunchingbringthatonetothefront.     
    8.             
  8.                  if(r.resultTo==      null){     
    9.             
  9.                  //Seeifthereisatasktobringtothefront.Ifthisis     
    10.             
  10.                  //aSINGLE_INSTANCEactivity,therecanbeoneandonlyone     
    11.             
  11.                  //instanceofitinthehistory,anditisalwaysinitsown     
    12.             
  12.                  //uniquetask,sowedoaspecialsearch.     
    13.             
  13.            ActivityRecordtaskTop=r.launchMode!=ActivityInfo.LAUNCH_SINGLE_INSTANCE     
    14.             
  14.            ?findTaskLocked(intent,r.info)     
    15.             
  15.            :findActivityLocked(intent,r.info);     
    16.             
  16.                  if(taskTop!=      null){     
    17.             
  17.            ......     
    18.             
  18.            }     
    19.             
  19.            }     
    20.             
  20.            }     
    21.
这段代码的逻辑是查看一下，当前有没有Task可以用来执行这个Activity。由于r.launchMode的值不为ActivityInfo.LAUNCH_SINGLE_INSTANCE，因此，它通过findTaskLocked函数来查找存不存这样的Task，这里返回的结果是null，即taskTop为null，因此，需要创建一个新的Task来启动这个Activity。 接着往下看： 
        
                
  1.                  if(r.packageName!=      null){     
    2.             
  2.            //Iftheactivitybeinglaunchedisthesameastheonecurrently     
    3.             
  3.            //atthetop,thenweneedtocheckifitshouldonlybelaunched     
    4.             
  4.            //once.     
    5.             
  5.            ActivityRecordtop=topRunningNonDelayedActivityLocked(notTop);     
    6.             
  6.            if(top!=      null&&r.resultTo==      null){     
    7.             
  7.                  if(top.realActivity.equals(r.realActivity)){     
    8.             
  8.            ......     
    9.             
  9.            }     
    10.             
  10.            }     
    11.             
  11.                 
    12.             
  12.            }     
    13.
这段代码的逻辑是看一下，当前在堆栈顶端的Activity是否就是即将要启动的Activity，有些情况下，如果即将要启动的Activity就在堆栈的顶端，那么，就不会重新启动这个Activity的别一个实例了，具体可以参考官方网站 http://developer.android.com/reference/android/content/pm/ActivityInfo.html 。现在处理堆栈顶端的Activity是Launcher，与我们即将要启动的MainActivity不是同一个Activity，因此，这里不用进一步处理上述介绍的情况。 执行到这里，我们知道，要在一个新的Task里面来启动这个Activity了，于是新创建一个Task： 
        
                
  1.                  if(r.resultTo==      null&&!addingToTask     
    2.             
  2.            &&(launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK)!=      0){     
    3.             
  3.            //todo:shoulddobettermanagementofintegers.     
    4.             
  4.            mService.mCurTask++;     
    5.             
  5.            if(mService.mCurTask<=      0){     
    6.             
  6.            mService.mCurTask=      1;     
    7.             
  7.            }     
    8.             
  8.            r.task=      newTaskRecord(mService.mCurTask,r.info,intent,     
    9.             
  9.            (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH)!=      0);     
    10.             
  10.            ......     
    11.             
  11.            newTask=      true;     
    12.             
  12.            if(mMainStack){     
    13.             
  13.            mService.addRecentTaskLocked(r.task);     
    14.             
  14.            }     
    15.             
  15.                 
    16.             
  16.            }     
    17.
新建的Task保存在r.task域中，同时，添加到mService中去，这里的mService就是ActivityManagerService了。 最后就进入startActivityLocked(r, newTask, doResume)进一步处理了。这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中： 
        
                
  1.            public      classActivityStack{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  private      final      voidstartActivityLocked(ActivityRecordr,      booleannewTask,     
    6.             
  6.                  booleandoResume){     
    7.             
  7.                  final      intNH=mHistory.size();     
    8.             
  8.                 
    9.             
  9.                  intaddPos=-      1;     
    10.             
  10.                 
    11.             
  11.                  if(!newTask){     
    12.             
  12.            ......     
    13.             
  13.            }     
    14.             
  14.                 
    15.             
  15.                  //Placeanewactivityattopofstack,soitisnexttointeract     
    16.             
  16.                  //withtheuser.     
    17.             
  17.                  if(addPos<      0){     
    18.             
  18.            addPos=NH;     
    19.             
  19.            }     
    20.             
  20.                 
    21.             
  21.                  //Ifwearenotplacingthenewactivityfrontmost,wedonotwant     
    22.             
  22.                  //todelivertheonUserLeavingcallbacktotheactualfrontmost     
    23.             
  23.                  //activity     
    24.             
  24.                  if(addPos<NH){     
    25.             
  25.            ......     
    26.             
  26.            }     
    27.             
  27.                 
    28.             
  28.                  //Slottheactivityintothehistorystackandproceed     
    29.             
  29.            mHistory.add(addPos,r);     
    30.             
  30.            r.inHistory=      true;     
    31.             
  31.            r.frontOfTask=newTask;     
    32.             
  32.            r.task.numActivities++;     
    33.             
  33.                  if(NH>      0){     
    34.             
  34.                  //Wewanttoshowthestartingpreviewwindowifweare     
    35.             
  35.                  //switchingtoanewtask,orthenextactivity'sprocessis     
    36.             
  36.                  //notcurrentlyrunning.     
    37.             
  37.            ......     
    38.             
  38.            }      else{     
    39.             
  39.                  //Ifthisisthefirstactivity,don'tdoanyfancyanimations,     
    40.             
  40.                  //becausethereisnothingforittoanimateontopof.     
    41.             
  41.            ......     
    42.             
  42.            }     
    43.             
  43.                 
    44.             
  44.            ......     
    45.             
  45.                 
    46.             
  46.                  if(doResume){     
    47.             
  47.            resumeTopActivityLocked(      null);     
    48.             
  48.            }     
    49.             
  49.            }     
    50.             
  50.                 
    51.             
  51.            ......     
    52.             
  52.                 
    53.             
  53.            }     
    54.
这里的NH表示当前系统中历史任务的个数，这里肯定是大于0，因为Launcher已经跑起来了。当NH>0时，并且现在要切换新任务时，要做一些任务切的界面操作，这段代码我们就不看了，这里不会影响到下面启Activity的过程，有兴趣的读取可以自己研究一下。 这里传进来的参数doResume为true，于是调用resumeTopActivityLocked进一步操作。 Step 10. Activity.resumeTopActivityLocked 这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中： 
        
                
  1.            public      classActivityStack{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  /**     
    6.             
  6.            *Ensurethatthetopactivityinthestackisresumed.     
    7.             
  7.            *     
    8.             
  8.            *@paramprevThepreviouslyresumedactivity,forwhenintheprocess     
    9.             
  9.            *ofpausing;canbenulltocallfromelsewhere.     
    10.             
  10.            *     
    11.             
  11.            *@returnReturnstrueifsomethingisbeingresumed,orfalseif     
    12.             
  12.            *nothinghappened.     
    13.             
  13.            */     
    14.             
  14.                  final      booleanresumeTopActivityLocked(ActivityRecordprev){     
    15.             
  15.                  //Findthefirstactivitythatisnotfinishing.     
    16.             
  16.            ActivityRecordnext=topRunningActivityLocked(      null);     
    17.             
  17.                 
    18.             
  18.                  //Rememberhowwe'llprocessthispause/resumesituation,andensure     
    19.             
  19.                  //thatthestateisresethoweverwewindupproceeding.     
    20.             
  20.                  final      booleanuserLeaving=mUserLeaving;     
    21.             
  21.            mUserLeaving=      false;     
    22.             
  22.                 
    23.             
  23.                  if(next==      null){     
    24.             
  24.            ......     
    25.             
  25.            }     
    26.             
  26.                 
    27.             
  27.            next.delayedResume=      false;     
    28.             
  28.                 
    29.             
  29.                  //Ifthetopactivityistheresumedone,nothingtodo.     
    30.             
  30.                  if(mResumedActivity==next&&next.state==ActivityState.RESUMED){     
    31.             
  31.            ......     
    32.             
  32.            }     
    33.             
  33.                 
    34.             
  34.                  //Ifwearesleeping,andthereisnoresumedactivity,andthetop     
    35.             
  35.                  //activityispaused,wellthatisthestatewewant.     
    36.             
  36.                  if((mService.mSleeping||mService.mShuttingDown)     
    37.             
  37.            &&mLastPausedActivity==next&&next.state==ActivityState.PAUSED){     
    38.             
  38.            ......     
    39.             
  39.            }     
    40.             
  40.                 
    41.             
  41.            ......     
    42.             
  42.                 
    43.             
  43.                  //Ifwearecurrentlypausinganactivity,thendon'tdoanything     
    44.             
  44.                  //untilthatisdone.     
    45.             
  45.                  if(mPausingActivity!=      null){     
    46.             
  46.            ......     
    47.             
  47.            }     
    48.             
  48.                 
    49.             
  49.            ......     
    50.             
  50.                 
    51.             
  51.                  //Weneedtostartpausingthecurrentactivitysothetopone     
    52.             
  52.                  //canberesumed...     
    53.             
  53.                  if(mResumedActivity!=      null){     
    54.             
  54.            ......     
    55.             
  55.            startPausingLocked(userLeaving,      false);     
    56.             
  56.                  return      true;     
    57.             
  57.            }     
    58.             
  58.                 
    59.             
  59.            ......     
    60.             
  60.            }     
    61.             
  61.                 
    62.             
  62.            ......     
    63.             
  63.                 
    64.             
  64.            }     
    65.
函数先通过调用topRunningActivityLocked函数获得堆栈顶端的Activity，这里就是MainActivity了，这是在上面的Step 9设置好的，保存在next变量中。 接下来把mUserLeaving的保存在本地变量userLeaving中，然后重新设置为false，在上面的Step 9中，mUserLeaving的值为true，因此，这里的userLeaving为true。 这里的mResumedActivity为Launcher，因为Launcher是当前正被执行的Activity。 当我们处理休眠状态时，mLastPausedActivity保存堆栈顶端的Activity，因为当前不是休眠状态，所以mLastPausedActivity为null。 有了这些信息之后，下面的语句就容易理解了： 
        
                
  1.                  //Ifthetopactivityistheresumedone,nothingtodo.     
    2.             
  2.                  if(mResumedActivity==next&&next.state==ActivityState.RESUMED){     
    3.             
  3.            ......     
    4.             
  4.            }     
    5.             
  5.                 
    6.             
  6.                  //Ifwearesleeping,andthereisnoresumedactivity,andthetop     
    7.             
  7.                  //activityispaused,wellthatisthestatewewant.     
    8.             
  8.                  if((mService.mSleeping||mService.mShuttingDown)     
    9.             
  9.            &&mLastPausedActivity==next&&next.state==ActivityState.PAUSED){     
    10.             
  10.            ......     
    11.             
  11.            }     
    12.
它首先看要启动的Activity是否就是当前处理Resumed状态的Activity，如果是的话，那就什么都不用做，直接返回就可以了；否则再看一下系统当前是否休眠状态，如果是的话，再看看要启动的Activity是否就是当前处于堆栈顶端的Activity，如果是的话，也是什么都不用做。 上面两个条件都不满足，因此，在继续往下执行之前，首先要把当处于Resumed状态的Activity推入Paused状态，然后才可以启动新的Activity。但是在将当前这个Resumed状态的Activity推入Paused状态之前，首先要看一下当前是否有Activity正在进入Pausing状态，如果有的话，当前这个Resumed状态的Activity就要稍后才能进入Paused状态了，这样就保证了所有需要进入Paused状态的Activity串行处理。 这里没有处于Pausing状态的Activity，即mPausingActivity为null，而且mResumedActivity也不为null，于是就调用startPausingLocked函数把Launcher推入Paused状态去了。 Step 11. ActivityStack.startPausingLocked 这个函数定义在frameworks/base/services/java/com/android/server/am/ActivityStack.java文件中： 
        
                
  1.            public      classActivityStack{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  private      final      voidstartPausingLocked(      booleanuserLeaving,      booleanuiSleeping){     
    6.             
  6.                  if(mPausingActivity!=      null){     
    7.             
  7.            ......     
    8.             
  8.            }     
    9.             
  9.            ActivityRecordprev=mResumedActivity;     
    10.             
  10.                  if(prev==      null){     
    11.             
  11.            ......     
    12.             
  12.            }     
    13.             
  13.            ......     
    14.             
  14.            mResumedActivity=      null;     
    15.             
  15.            mPausingActivity=prev;     
    16.             
  16.            mLastPausedActivity=prev;     
    17.             
  17.            prev.state=ActivityState.PAUSING;     
    18.             
  18.            ......     
    19.             
  19.                 
    20.             
  20.                  if(prev.app!=      null&&prev.app.thread!=      null){     
    21.             
  21.            ......     
    22.             
  22.                  try{     
    23.             
  23.            ......     
    24.             
  24.            prev.app.thread.schedulePauseActivity(prev,prev.finishing,userLeaving,     
    25.             
  25.            prev.configChangeFlags);     
    26.             
  26.            ......     
    27.             
  27.            }      catch(Exceptione){     
    28.             
  28.            ......     
    29.             
  29.            }     
    30.             
  30.            }      else{     
    31.             
  31.            ......     
    32.             
  32.            }     
    33.             
  33.                 
    34.             
  34.            ......     
    35.             
  35.                 
    36.             
  36.            }     
    37.             
  37.                 
    38.             
  38.            ......     
    39.             
  39.                 
    40.             
  40.            }     
    41.
函数首先把mResumedActivity保存在本地变量prev中。在上一步Step 10中，说到mResumedActivity就是Launcher，因此，这里把Launcher进程中的ApplicationThread对象取出来，通过它来通知Launcher这个Activity它要进入Paused状态了。当然，这里的prev.app.thread是一个ApplicationThread对象的远程接口，通过调用这个远程接口的schedulePauseActivity来通知Launcher进入Paused状态。 参数prev.finishing表示prev所代表的Activity是否正在等待结束的Activity列表中，由于Laucher这个Activity还没结束，所以这里为false；参数prev.configChangeFlags表示哪些config发生了变化，这里我们不关心它的值。 Step 12.ApplicationThreadProxy.schedulePauseActivity 这个函数定义在frameworks/base/core/java/android/app/ApplicationThreadNative.java文件中： 
        
                
  1.            classApplicationThreadProxy      implementsIApplicationThread{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  public      final      voidschedulePauseActivity(IBindertoken,      booleanfinished,     
    6.             
  6.                  booleanuserLeaving,      intconfigChanges)      throwsRemoteException{     
    7.             
  7.            Parceldata=Parcel.obtain();     
    8.             
  8.            data.writeInterfaceToken(IApplicationThread.descriptor);     
    9.             
  9.            data.writeStrongBinder(token);     
    10.             
  10.            data.writeInt(finished?      1:      0);     
    11.             
  11.            data.writeInt(userLeaving?      1:      0);     
    12.             
  12.            data.writeInt(configChanges);     
    13.             
  13.            mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION,data,      null,     
    14.             
  14.            IBinder.FLAG_ONEWAY);     
    15.             
  15.            data.recycle();     
    16.             
  16.            }     
    17.             
  17.                 
    18.             
  18.            ......     
    19.             
  19.                 
    20.             
  20.            }     
    21.
这个函数通过Binder进程间通信机制进入到ApplicationThread.schedulePauseActivity函数中。 Step 13. ApplicationThread.schedulePauseActivity 这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中，它是ActivityThread的内部类： 
        
                
  1.            public      final      classActivityThread{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  private      final      classApplicationThread      extendsApplicationThreadNative{     
    6.             
  6.                 
    7.             
  7.            ......     
    8.             
  8.                 
    9.             
  9.                  public      final      voidschedulePauseActivity(IBindertoken,      booleanfinished,     
    10.             
  10.                  booleanuserLeaving,      intconfigChanges){     
    11.             
  11.            queueOrSendMessage(     
    12.             
  12.            finished?H.PAUSE_ACTIVITY_FINISHING:H.PAUSE_ACTIVITY,     
    13.             
  13.            token,     
    14.             
  14.            (userLeaving?      1:      0),     
    15.             
  15.            configChanges);     
    16.             
  16.            }     
    17.             
  17.                 
    18.             
  18.            ......     
    19.             
  19.                 
    20.             
  20.            }     
    21.             
  21.                 
    22.             
  22.            ......     
    23.             
  23.                 
    24.             
  24.            }     
    25.
这里调用的函数queueOrSendMessage是ActivityThread类的成员函数。 上面说到，这里的finished值为false，因此，queueOrSendMessage的第一个参数值为H.PAUSE_ACTIVITY，表示要暂停token所代表的Activity，即Launcher。 Step 14. ActivityThread.queueOrSendMessage 这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中： 
        
                
  1.            public      final      classActivityThread{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  private      final      voidqueueOrSendMessage(      intwhat,Objectobj,      intarg1){     
    6.             
  6.            queueOrSendMessage(what,obj,arg1,      0);     
    7.             
  7.            }     
    8.             
  8.                 
    9.             
  9.                  private      final      voidqueueOrSendMessage(      intwhat,Objectobj,      intarg1,      intarg2){     
    10.             
  10.                  synchronized(      this){     
    11.             
  11.            ......     
    12.             
  12.            Messagemsg=Message.obtain();     
    13.             
  13.            msg.what=what;     
    14.             
  14.            msg.obj=obj;     
    15.             
  15.            msg.arg1=arg1;     
    16.             
  16.            msg.arg2=arg2;     
    17.             
  17.            mH.sendMessage(msg);     
    18.             
  18.            }     
    19.             
  19.            }     
    20.             
  20.                 
    21.             
  21.            ......     
    22.             
  22.                 
    23.             
  23.            }     
    24.
这里首先将相关信息组装成一个msg，然后通过mH成员变量发送出去，mH的类型是H，继承于Handler类，是ActivityThread的内部类，因此，这个消息最后由H.handleMessage来处理。 Step 15. H.handleMessage 这个函数定义在frameworks/base/core/java/android/app/ActivityThread.java文件中： 
        
                
  1.            public      final      classActivityThread{     
    2.             
  2.                 
    3.             
  3.            ......     
    4.             
  4.                 
    5.             
  5.                  private      final      classH      extendsHandler{     
    6.             
  6.                 
    7.             
  7.            ......     
    8.             
  8.                 
    9.             
  9.                  public      voidhandleMessage(Messagemsg){     
    10.             
  10.            ......     
    11.             
  11.                  switch(msg.what){     
    12.             
  12.                 
    13.             
  13.            ......     
    14.             
  14.                 
    15.             
  15.                  casePAUSE_ACTIVITY:     
    16.             
  16.            handlePauseActivity((IBinder)msg.obj,      false,msg.arg1!=      0,msg.arg2);     
    17.             
  17.            maybeSnapshot();     
    18.             
  18.                  break;     
    19.             
  19.                 
    20.             
  20.            ......     
    21.             
  21.                 
    22.             
  22.            }     
    23.             
  23.            ......     
    24.             
  24.                 
    25.             
  25.            }     
    26.             
  26.                 
    27.             
  27.            ......     
    28.             
  28.                 
    29.             
  29.            }     
    30.
这里调用ActivityThread.handlePauseActivity进一步操作，msg.obj是一个ActivityRecord对象的引用，它代表的是Launcher这个Activity。

更多相关文章

  1. C语言函数以及函数的使用
  2. Android 隐藏系统状态栏和标题栏
  3. Android App 隐藏显示标题栏、状态栏、导航栏
  4. Android 蓝牙状态机以及蓝牙启动状态机
  5. Android中获取屏幕相关信息（屏幕大小，状态栏、标题栏高度）
  6. 获取Android设备电池电量状态
  7. Android 5.1系统禁止通知状态栏下拉
  8. Android 获取状态栏的高度
  9. Android 沉浸式状态栏实现，以及遇到的问题

随机推荐

  1. Android第三十三期 - Dialog的应用
  2. Android提高第十九篇之"多方向"抽屉
  3. Android中文API（125） ―― VideoView
  4. Android控件-多选按钮、单选按钮
  5. Android中使用jdbc连接Sqllite
  6. android延迟执行任务(刷新按钮旋转)
  7. Android:Eclipse+ADT+Android SDK 搭建安
  8. “刨根问底”之Android(安卓)消息机制
  9. Android ActionBarSherlock的使用
  10. 打开电话Android系统调用