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. Debug native code using addr2line on Android--再转一个Androi
  2. （android 关机/重启）Android关机/重启流程解析
  3. Android(安卓)Audio 框架简读
  4. Android(安卓)隐藏系统状态栏和标题栏
  5. android源代码下载——android环境配置
  6. Android(安卓)App 隐藏显示标题栏、状态栏、导航栏
  7. Android中Message机制的灵活应用
  8. Android自带Music播放器更新播放时间和进度条的方法
  9. android NDK install and config in ubuntu

随机推荐

  1. android中Activity与service之间相互通信
  2. Android之adb命令
  3. For Best User Experience & UI
  4. Android的AsyncTask异步任务浅析
  5. mqtt向android推送消息（一）——发送端使用.
  6. 演化理解 Android 异步
  7. android 调用系统界面
  8. android常用控件（二）　RadioGroup RadioBut
  9. Android的MVC模式：
  10. Android软键盘遮挡布局问题；