Android應用程式啟動過程原始碼分析

yangxi_001發表於2013-11-21
Android原始碼

前文簡要介紹了Android應用程式的Activity的啟動過程。在Android系統中，應用程式是由Activity組成的，因此，應用程式的啟動過程實際上就是應用程式中的預設Activity的啟動過程，本文將詳細分析應用程式框架層的原始碼，瞭解Android應用程式的啟動過程。

        在上一篇文章Android應用程式的Activity啟動過程簡要介紹和學習計劃中，我們舉例子說明了啟動Android應用程式中的Activity的兩種情景，其中，在手機螢幕中點選應用程式圖示的情景就會引發Android應用程式中的預設Activity的啟動，從而把應用程式啟動起來。這種啟動方式的特點是會啟動一個新的程式來載入相應的Activity。這裡，我們繼續以這個例子為例來說明Android應用程式的啟動過程，即MainActivity的啟動過程。

        MainActivity的啟動過程如下圖所示：


點選檢視大圖

        下面詳細分析每一步是如何實現的。

        Step 1. Launcher.startActivitySafely

        在Android系統中，應用程式是由Launcher啟動起來的，其實，Launcher本身也是一個應用程式，其它的應用程式安裝後，就會Launcher的介面上出現一個相應的圖示，點選這個圖示時，Launcher就會對應的應用程式啟動起來。

        Launcher的原始碼工程在packages/apps/Launcher2目錄下，負責啟動其它應用程式的原始碼實現在src/com/android/launcher2/Launcher.java檔案中：

[java] view plaincopy
  1. /** 
  2. * Default launcher application. 
  3. */  
  4. public final class Launcher extends Activity  
  5.         implements View.OnClickListener, OnLongClickListener, LauncherModel.Callbacks, AllAppsView.Watcher {  
  6.   
  7.     ......  
  8.   
  9.     /** 
  10.     * Launches the intent referred by the clicked shortcut. 
  11.     * 
  12.     * @param v The view representing the clicked shortcut. 
  13.     */  
  14.     public void onClick(View v) {  
  15.         Object tag = v.getTag();  
  16.         if (tag instanceof ShortcutInfo) {  
  17.             // Open shortcut  
  18.             final Intent intent = ((ShortcutInfo) tag).intent;  
  19.             int[] pos = new int[2];  
  20.             v.getLocationOnScreen(pos);  
  21.             intent.setSourceBounds(new Rect(pos[0], pos[1],  
  22.                 pos[0] + v.getWidth(), pos[1] + v.getHeight()));  
  23.             startActivitySafely(intent, tag);  
  24.         } else if (tag instanceof FolderInfo) {  
  25.             ......  
  26.         } else if (v == mHandleView) {  
  27.             ......  
  28.         }  
  29.     }  
  30.   
  31.     void startActivitySafely(Intent intent, Object tag) {  
  32.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
  33.         try {  
  34.             startActivity(intent);  
  35.         } catch (ActivityNotFoundException e) {  
  36.             ......  
  37.         } catch (SecurityException e) {  
  38.             ......  
  39.         }  
  40.     }  
  41.   
  42.     ......  
  43.   
  44. }  
        回憶一下前面一篇文章Android應用程式的Activity啟動過程簡要介紹和學習計劃說到的應用程式Activity，它的預設Activity是MainActivity，這裡是AndroidManifest.xml檔案中配置的：

[html] view plaincopy
  1. <activity android:name=".MainActivity"    
  2.       android:label="@string/app_name">    
  3.        <intent-filter>    
  4.         <action android:name="android.intent.action.MAIN" />    
  5.         <category android:name="android.intent.category.LAUNCHER" />    
  6.     </intent-filter>    
  7. </activity>    
        因此，這裡的intent包含的資訊為：action = "android.intent.action.Main"，category="android.intent.category.LAUNCHER", cmp="shy.luo.activity/.MainActivity"，表示它要啟動的Activity為shy.luo.activity.MainActivity。Intent.FLAG_ACTIVITY_NEW_TASK表示要在一個新的Task中啟動這個Activity，注意，Task是Android系統中的概念，它不同於程式Process的概念。簡單地說，一個Task是一系列Activity的集合，這個集合是以堆疊的形式來組織的，遵循後進先出的原則。事實上，Task是一個非常複雜的概念，有興趣的讀者可以到官網http://developer.android.com/guide/topics/manifest/activity-element.html檢視相關的資料。這裡，我們只要知道，這個MainActivity要在一個新的Task中啟動就可以了。

        Step 2. Activity.startActivity

        在Step 1中，我們看到，Launcher繼承於Activity類，而Activity類實現了startActivity函式，因此，這裡就呼叫了Activity.startActivity函式，它實現在frameworks/base/core/java/android/app/Activity.java檔案中：

[java] view plaincopy
  1. public class Activity extends ContextThemeWrapper  
  2.         implements LayoutInflater.Factory,  
  3.         Window.Callback, KeyEvent.Callback,  
  4.         OnCreateContextMenuListener, ComponentCallbacks {  
  5.   
  6.     ......  
  7.   
  8.     @Override  
  9.     public void startActivity(Intent intent) {  
  10.         startActivityForResult(intent, -1);  
  11.     }  
  12.   
  13.     ......  
  14.   
  15. }  
        這個函式實現很簡單，它呼叫startActivityForResult來進一步處理，第二個引數傳入-1表示不需要這個Actvity結束後的返回結果。

        Step 3. Activity.startActivityForResult

        這個函式也是實現在frameworks/base/core/java/android/app/Activity.java檔案中：

[java] view plaincopy
  1. public class Activity extends ContextThemeWrapper  
  2.         implements LayoutInflater.Factory,  
  3.         Window.Callback, KeyEvent.Callback,  
  4.         OnCreateContextMenuListener, ComponentCallbacks {  
  5.   
  6.     ......  
  7.   
  8.     public void startActivityForResult(Intent intent, int requestCode) {  
  9.         if (mParent == null) {  
  10.             Instrumentation.ActivityResult ar =  
  11.                 mInstrumentation.execStartActivity(  
  12.                 this, mMainThread.getApplicationThread(), mToken, this,  
  13.                 intent, requestCode);  
  14.             ......  
  15.         } else {  
  16.             ......  
  17.         }  
  18.   
  19.   
  20.     ......  
  21.   
  22. }  
         這裡的mInstrumentation是Activity類的成員變數，它的型別是Intrumentation，定義在frameworks/base/core/java/android/app/Instrumentation.java檔案中，它用來監控應用程式和系統的互動。

         這裡的mMainThread也是Activity類的成員變數，它的型別是ActivityThread，它代表的是應用程式的主執行緒，我們在Android系統在新程式中啟動自定義服務過程（startService）的原理分析一文中已經介紹過了。這裡通過mMainThread.getApplicationThread獲得它裡面的ApplicationThread成員變數，它是一個Binder物件，後面我們會看到，ActivityManagerService會使用它來和ActivityThread來進行程式間通訊。這裡我們需注意的是，這裡的mMainThread代表的是Launcher應用程式執行的程式。

         這裡的mToken也是Activity類的成員變數，它是一個Binder物件的遠端介面。

         Step 4. Instrumentation.execStartActivity
         這個函式定義在frameworks/base/core/java/android/app/Instrumentation.java檔案中：

[java] view plaincopy
  1. public class Instrumentation {  
  2.   
  3.     ......  
  4.   
  5.     public ActivityResult execStartActivity(  
  6.     Context who, IBinder contextThread, IBinder token, Activity target,  
  7.     Intent intent, int requestCode) {  
  8.         IApplicationThread whoThread = (IApplicationThread) contextThread;  
  9.         if (mActivityMonitors != null) {  
  10.             ......  
  11.         }  
  12.         try {  
  13.             int result = ActivityManagerNative.getDefault()  
  14.                 .startActivity(whoThread, intent,  
  15.                 intent.resolveTypeIfNeeded(who.getContentResolver()),  
  16.                 null, 0, token, target != null ? target.mEmbeddedID : null,  
  17.                 requestCode, false, false);  
  18.             ......  
  19.         } catch (RemoteException e) {  
  20.         }  
  21.         return null;  
  22.     }  
  23.   
  24.     ......  
  25.   
  26. }  
         這裡的ActivityManagerNative.getDefault返回ActivityManagerService的遠端介面，即ActivityManagerProxy介面，具體可以參考Android系統在新程式中啟動自定義服務過程（startService）的原理分析一文。

         這裡的intent.resolveTypeIfNeeded返回這個intent的MIME型別，在這個例子中，沒有AndroidManifest.xml設定MainActivity的MIME型別，因此，這裡返回null。

         這裡的target不為null，但是target.mEmbddedID為null，我們不用關注。

         Step 5. ActivityManagerProxy.startActivity

         這個函式定義在frameworks/base/core/java/android/app/ActivityManagerNative.java檔案中：

[java] view plaincopy
  1. class ActivityManagerProxy implements IActivityManager  
  2. {  
  3.   
  4.     ......  
  5.   
  6.     public int startActivity(IApplicationThread caller, Intent intent,  
  7.             String resolvedType, Uri[] grantedUriPermissions, int grantedMode,  
  8.             IBinder resultTo, String resultWho,  
  9.             int requestCode, boolean onlyIfNeeded,  
  10.             boolean debug) throws RemoteException {  
  11.         Parcel data = Parcel.obtain();  
  12.         Parcel reply = Parcel.obtain();  
  13.         data.writeInterfaceToken(IActivityManager.descriptor);  
  14.         data.writeStrongBinder(caller != null ? caller.asBinder() : null);  
  15.         intent.writeToParcel(data, 0);  
  16.         data.writeString(resolvedType);  
  17.         data.writeTypedArray(grantedUriPermissions, 0);  
  18.         data.writeInt(grantedMode);  
  19.         data.writeStrongBinder(resultTo);  
  20.         data.writeString(resultWho);  
  21.         data.writeInt(requestCode);  
  22.         data.writeInt(onlyIfNeeded ? 1 : 0);  
  23.         data.writeInt(debug ? 1 : 0);  
  24.         mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);  
  25.         reply.readException();  
  26.         int result = reply.readInt();  
  27.         reply.recycle();  
  28.         data.recycle();  
  29.         return result;  
  30.     }  
  31.   
  32.     ......  
  33.   
  34. }  
        這裡的引數比較多，我們先整理一下。從上面的呼叫可以知道，這裡的引數resolvedType、grantedUriPermissions和resultWho均為null；引數caller為ApplicationThread型別的Binder實體；引數resultTo為一個Binder實體的遠端介面，我們先不關注它；引數grantedMode為0，我們也先不關注它；引數requestCode為-1；引數onlyIfNeeded和debug均空false。

        Step 6. ActivityManagerService.startActivity

        上一步Step 5通過Binder驅動程式就進入到ActivityManagerService的startActivity函式來了，它定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java檔案中：

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     public final int startActivity(IApplicationThread caller,  
  7.             Intent intent, String resolvedType, Uri[] grantedUriPermissions,  
  8.             int grantedMode, IBinder resultTo,  
  9.             String resultWho, int requestCode, boolean onlyIfNeeded,  
  10.             boolean debug) {  
  11.         return mMainStack.startActivityMayWait(caller, intent, resolvedType,  
  12.             grantedUriPermissions, grantedMode, resultTo, resultWho,  
  13.             requestCode, onlyIfNeeded, debug, null, null);  
  14.     }  
  15.   
  16.   
  17.     ......  
  18.   
  19. }  
        這裡只是簡單地將操作轉發給成員變數mMainStack的startActivityMayWait函式，這裡的mMainStack的型別為ActivityStack。

        Step 7. ActivityStack.startActivityMayWait

        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final int startActivityMayWait(IApplicationThread caller,  
  6.             Intent intent, String resolvedType, Uri[] grantedUriPermissions,  
  7.             int grantedMode, IBinder resultTo,  
  8.             String resultWho, int requestCode, boolean onlyIfNeeded,  
  9.             boolean debug, WaitResult outResult, Configuration config) {  
  10.   
  11.         ......  
  12.   
  13.         boolean componentSpecified = intent.getComponent() != null;  
  14.   
  15.         // Don't modify the client's object!  
  16.         intent = new Intent(intent);  
  17.   
  18.         // Collect information about the target of the Intent.  
  19.         ActivityInfo aInfo;  
  20.         try {  
  21.             ResolveInfo rInfo =  
  22.                 AppGlobals.getPackageManager().resolveIntent(  
  23.                 intent, resolvedType,  
  24.                 PackageManager.MATCH_DEFAULT_ONLY  
  25.                 | ActivityManagerService.STOCK_PM_FLAGS);  
  26.             aInfo = rInfo != null ? rInfo.activityInfo : null;  
  27.         } catch (RemoteException e) {  
  28.             ......  
  29.         }  
  30.   
  31.         if (aInfo != null) {  
  32.             // Store the found target back into the intent, because now that  
  33.             // we have it we never want to do this again.  For example, if the  
  34.             // user navigates back to this point in the history, we should  
  35.             // always restart the exact same activity.  
  36.             intent.setComponent(new ComponentName(  
  37.                 aInfo.applicationInfo.packageName, aInfo.name));  
  38.             ......  
  39.         }  
  40.   
  41.         synchronized (mService) {  
  42.             int callingPid;  
  43.             int callingUid;  
  44.             if (caller == null) {  
  45.                 ......  
  46.             } else {  
  47.                 callingPid = callingUid = -1;  
  48.             }  
  49.   
  50.             mConfigWillChange = config != null  
  51.                 && mService.mConfiguration.diff(config) != 0;  
  52.   
  53.             ......  
  54.   
  55.             if (mMainStack && aInfo != null &&  
  56.                 (aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0) {  
  57.                     
  58.                       ......  
  59.   
  60.             }  
  61.   
  62.             int res = startActivityLocked(caller, intent, resolvedType,  
  63.                 grantedUriPermissions, grantedMode, aInfo,  
  64.                 resultTo, resultWho, requestCode, callingPid, callingUid,  
  65.                 onlyIfNeeded, componentSpecified);  
  66.   
  67.             if (mConfigWillChange && mMainStack) {  
  68.                 ......  
  69.             }  
  70.   
  71.             ......  
  72.   
  73.             if (outResult != null) {  
  74.                 ......  
  75.             }  
  76.   
  77.             return res;  
  78.         }  
  79.   
  80.     }  
  81.   
  82.     ......  
  83.   
  84. }  
        注意，從Step 6傳下來的引數outResult和config均為null，此外，表示式(aInfo.applicationInfo.flags&ApplicationInfo.FLAG_CANT_SAVE_STATE) != 0為false，因此，這裡忽略了無關程式碼。

        下面語句對引數intent的內容進行解析，得到MainActivity的相關資訊，儲存在aInfo變數中：

[java] view plaincopy
  1.    ActivityInfo aInfo;  
  2.    try {  
  3. ResolveInfo rInfo =  
  4. AppGlobals.getPackageManager().resolveIntent(  
  5.     intent, resolvedType,  
  6.     PackageManager.MATCH_DEFAULT_ONLY  
  7.     | ActivityManagerService.STOCK_PM_FLAGS);  
  8. aInfo = rInfo != null ? rInfo.activityInfo : null;  
  9.    } catch (RemoteException e) {  
  10.     ......  
  11.    }  
        解析之後，得到的aInfo.applicationInfo.packageName的值為"shy.luo.activity"，aInfo.name的值為"shy.luo.activity.MainActivity"，這是在這個例項的配置檔案AndroidManifest.xml裡面配置的。

        此外，函式開始的地方呼叫intent.getComponent()函式的返回值不為null，因此，這裡的componentSpecified變數為true。

        接下去就呼叫startActivityLocked進一步處理了。

        Step 8. ActivityStack.startActivityLocked

        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final int startActivityLocked(IApplicationThread caller,  
  6.             Intent intent, String resolvedType,  
  7.             Uri[] grantedUriPermissions,  
  8.             int grantedMode, ActivityInfo aInfo, IBinder resultTo,  
  9.                 String resultWho, int requestCode,  
  10.             int callingPid, int callingUid, boolean onlyIfNeeded,  
  11.             boolean componentSpecified) {  
  12.             int err = START_SUCCESS;  
  13.   
  14.         ProcessRecord callerApp = null;  
  15.         if (caller != null) {  
  16.             callerApp = mService.getRecordForAppLocked(caller);  
  17.             if (callerApp != null) {  
  18.                 callingPid = callerApp.pid;  
  19.                 callingUid = callerApp.info.uid;  
  20.             } else {  
  21.                 ......  
  22.             }  
  23.         }  
  24.   
  25.         ......  
  26.   
  27.         ActivityRecord sourceRecord = null;  
  28.         ActivityRecord resultRecord = null;  
  29.         if (resultTo != null) {  
  30.             int index = indexOfTokenLocked(resultTo);  
  31.               
  32.             ......  
  33.                   
  34.             if (index >= 0) {  
  35.                 sourceRecord = (ActivityRecord)mHistory.get(index);  
  36.                 if (requestCode >= 0 && !sourceRecord.finishing) {  
  37.                     ......  
  38.                 }  
  39.             }  
  40.         }  
  41.   
  42.         int launchFlags = intent.getFlags();  
  43.   
  44.         if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0  
  45.             && sourceRecord != null) {  
  46.             ......  
  47.         }  
  48.   
  49.         if (err == START_SUCCESS && intent.getComponent() == null) {  
  50.             ......  
  51.         }  
  52.   
  53.         if (err == START_SUCCESS && aInfo == null) {  
  54.             ......  
  55.         }  
  56.   
  57.         if (err != START_SUCCESS) {  
  58.             ......  
  59.         }  
  60.   
  61.         ......  
  62.   
  63.         ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,  
  64.             intent, resolvedType, aInfo, mService.mConfiguration,  
  65.             resultRecord, resultWho, requestCode, componentSpecified);  
  66.   
  67.         ......  
  68.   
  69.         return startActivityUncheckedLocked(r, sourceRecord,  
  70.             grantedUriPermissions, grantedMode, onlyIfNeeded, true);  
  71.     }  
  72.   
  73.   
  74.     ......  
  75.   
  76. }  
        從傳進來的引數caller得到呼叫者的程式資訊，並儲存在callerApp變數中，這裡就是Launcher應用程式的程式資訊了。

        前面說過，引數resultTo是Launcher這個Activity裡面的一個Binder物件，通過它可以獲得Launcher這個Activity的相關資訊，儲存在sourceRecord變數中。
        再接下來，建立即將要啟動的Activity的相關資訊，並儲存在r變數中：

[java] view plaincopy
  1. ActivityRecord r = new ActivityRecord(mService, this, callerApp, callingUid,  
  2.     intent, resolvedType, aInfo, mService.mConfiguration,  
  3.     resultRecord, resultWho, requestCode, componentSpecified);  
        接著呼叫startActivityUncheckedLocked函式進行下一步操作。

        Step 9. ActivityStack.startActivityUncheckedLocked

        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final int startActivityUncheckedLocked(ActivityRecord r,  
  6.         ActivityRecord sourceRecord, Uri[] grantedUriPermissions,  
  7.         int grantedMode, boolean onlyIfNeeded, boolean doResume) {  
  8.         final Intent intent = r.intent;  
  9.         final int callingUid = r.launchedFromUid;  
  10.   
  11.         int launchFlags = intent.getFlags();  
  12.   
  13.         // We'll invoke onUserLeaving before onPause only if the launching  
  14.         // activity did not explicitly state that this is an automated launch.  
  15.         mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0;  
  16.           
  17.         ......  
  18.   
  19.         ActivityRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP)  
  20.             != 0 ? r : null;  
  21.   
  22.         // If the onlyIfNeeded flag is set, then we can do this if the activity  
  23.         // being launched is the same as the one making the call...  or, as  
  24.         // a special case, if we do not know the caller then we count the  
  25.         // current top activity as the caller.  
  26.         if (onlyIfNeeded) {  
  27.             ......  
  28.         }  
  29.   
  30.         if (sourceRecord == null) {  
  31.             ......  
  32.         } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {  
  33.             ......  
  34.         } else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE  
  35.             || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) {  
  36.             ......  
  37.         }  
  38.   
  39.         if (r.resultTo != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {  
  40.             ......  
  41.         }  
  42.   
  43.         boolean addingToTask = false;  
  44.         if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&  
  45.             (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)  
  46.             || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK  
  47.             || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {  
  48.                 // If bring to front is requested, and no result is requested, and  
  49.                 // we can find a task that was started with this same  
  50.                 // component, then instead of launching bring that one to the front.  
  51.                 if (r.resultTo == null) {  
  52.                     // See if there is a task to bring to the front.  If this is  
  53.                     // a SINGLE_INSTANCE activity, there can be one and only one  
  54.                     // instance of it in the history, and it is always in its own  
  55.                     // unique task, so we do a special search.  
  56.                     ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE  
  57.                         ? findTaskLocked(intent, r.info)  
  58.                         : findActivityLocked(intent, r.info);  
  59.                     if (taskTop != null) {  
  60.                         ......  
  61.                     }  
  62.                 }  
  63.         }  
  64.   
  65.         ......  
  66.   
  67.         if (r.packageName != null) {  
  68.             // If the activity being launched is the same as the one currently  
  69.             // at the top, then we need to check if it should only be launched  
  70.             // once.  
  71.             ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);  
  72.             if (top != null && r.resultTo == null) {  
  73.                 if (top.realActivity.equals(r.realActivity)) {  
  74.                     ......  
  75.                 }  
  76.             }  
  77.   
  78.         } else {  
  79.             ......  
  80.         }  
  81.   
  82.         boolean newTask = false;  
  83.   
  84.         // Should this be considered a new task?  
  85.         if (r.resultTo == null && !addingToTask  
  86.             && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {  
  87.                 // todo: should do better management of integers.  
  88.                 mService.mCurTask++;  
  89.                 if (mService.mCurTask <= 0) {  
  90.                     mService.mCurTask = 1;  
  91.                 }  
  92.                 r.task = new TaskRecord(mService.mCurTask, r.info, intent,  
  93.                     (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);  
  94.                 ......  
  95.                 newTask = true;  
  96.                 if (mMainStack) {  
  97.                     mService.addRecentTaskLocked(r.task);  
  98.                 }  
  99.   
  100.         } else if (sourceRecord != null) {  
  101.             ......  
  102.         } else {  
  103.             ......  
  104.         }  
  105.   
  106.         ......  
  107.   
  108.         startActivityLocked(r, newTask, doResume);  
  109.         return START_SUCCESS;  
  110.     }  
  111.   
  112.     ......  
  113.   
  114. }  
        函式首先獲得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語句會被執行：

[java] view plaincopy
  1.    if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 &&  
  2. (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0)  
  3. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK  
  4. || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) {  
  5.     // If bring to front is requested, and no result is requested, and  
  6.     // we can find a task that was started with this same  
  7.     // component, then instead of launching bring that one to the front.  
  8.     if (r.resultTo == null) {  
  9.         // See if there is a task to bring to the front.  If this is  
  10.         // a SINGLE_INSTANCE activity, there can be one and only one  
  11.         // instance of it in the history, and it is always in its own  
  12.         // unique task, so we do a special search.  
  13.         ActivityRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE  
  14.             ? findTaskLocked(intent, r.info)  
  15.             : findActivityLocked(intent, r.info);  
  16.         if (taskTop != null) {  
  17.             ......  
  18.         }  
  19.     }  
  20.    }  
        這段程式碼的邏輯是檢視一下，當前有沒有Task可以用來執行這個Activity。由於r.launchMode的值不為ActivityInfo.LAUNCH_SINGLE_INSTANCE，因此，它通過findTaskLocked函式來查詢存不存這樣的Task，這裡返回的結果是null，即taskTop為null，因此，需要建立一個新的Task來啟動這個Activity。

        接著往下看：

[java] view plaincopy
  1.    if (r.packageName != null) {  
  2. // If the activity being launched is the same as the one currently  
  3. // at the top, then we need to check if it should only be launched  
  4. // once.  
  5. ActivityRecord top = topRunningNonDelayedActivityLocked(notTop);  
  6. if (top != null && r.resultTo == null) {  
  7.     if (top.realActivity.equals(r.realActivity)) {  
  8.         ......  
  9.     }  
  10. }  
  11.   
  12.    }   
        這段程式碼的邏輯是看一下，當前在堆疊頂端的Activity是否就是即將要啟動的Activity，有些情況下，如果即將要啟動的Activity就在堆疊的頂端，那麼，就不會重新啟動這個Activity的別一個例項了，具體可以參考官方網站http://developer.android.com/reference/android/content/pm/ActivityInfo.html。現在處理堆疊頂端的Activity是Launcher，與我們即將要啟動的MainActivity不是同一個Activity，因此，這裡不用進一步處理上述介紹的情況。

       執行到這裡，我們知道，要在一個新的Task裡面來啟動這個Activity了，於是新建立一個Task：

[java] view plaincopy
  1.   if (r.resultTo == null && !addingToTask  
  2. && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) {  
  3. // todo: should do better management of integers.  
  4. mService.mCurTask++;  
  5. if (mService.mCurTask <= 0) {  
  6.     mService.mCurTask = 1;  
  7. }  
  8. r.task = new TaskRecord(mService.mCurTask, r.info, intent,  
  9.     (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0);  
  10. ......  
  11. newTask = true;  
  12. if (mMainStack) {  
  13.     mService.addRecentTaskLocked(r.task);  
  14. }  
  15.   
  16.    }  
        新建的Task儲存在r.task域中，同時，新增到mService中去，這裡的mService就是ActivityManagerService了。

        最後就進入startActivityLocked(r, newTask, doResume)進一步處理了。這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void startActivityLocked(ActivityRecord r, boolean newTask,  
  6.             boolean doResume) {  
  7.         final int NH = mHistory.size();  
  8.   
  9.         int addPos = -1;  
  10.   
  11.         if (!newTask) {  
  12.             ......  
  13.         }  
  14.   
  15.         // Place a new activity at top of stack, so it is next to interact  
  16.         // with the user.  
  17.         if (addPos < 0) {  
  18.             addPos = NH;  
  19.         }  
  20.   
  21.         // If we are not placing the new activity frontmost, we do not want  
  22.         // to deliver the onUserLeaving callback to the actual frontmost  
  23.         // activity  
  24.         if (addPos < NH) {  
  25.             ......  
  26.         }  
  27.   
  28.         // Slot the activity into the history stack and proceed  
  29.         mHistory.add(addPos, r);  
  30.         r.inHistory = true;  
  31.         r.frontOfTask = newTask;  
  32.         r.task.numActivities++;  
  33.         if (NH > 0) {  
  34.             // We want to show the starting preview window if we are  
  35.             // switching to a new task, or the next activity's process is  
  36.             // not currently running.  
  37.             ......  
  38.         } else {  
  39.             // If this is the first activity, don't do any fancy animations,  
  40.             // because there is nothing for it to animate on top of.  
  41.             ......  
  42.         }  
  43.           
  44.         ......  
  45.   
  46.         if (doResume) {  
  47.             resumeTopActivityLocked(null);  
  48.         }  
  49.     }  
  50.   
  51.     ......  
  52.   
  53. }  
        這裡的NH表示當前系統中歷史任務的個數，這裡肯定是大於0，因為Launcher已經跑起來了。當NH>0時，並且現在要切換新任務時，要做一些任務切的介面操作，這段程式碼我們就不看了，這裡不會影響到下面啟Activity的過程，有興趣的讀取可以自己研究一下。

        這裡傳進來的引數doResume為true，於是呼叫resumeTopActivityLocked進一步操作。

        Step 10. Activity.resumeTopActivityLocked

        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     /** 
  6.     * Ensure that the top activity in the stack is resumed. 
  7.     * 
  8.     * @param prev The previously resumed activity, for when in the process 
  9.     * of pausing; can be null to call from elsewhere. 
  10.     * 
  11.     * @return Returns true if something is being resumed, or false if 
  12.     * nothing happened. 
  13.     */  
  14.     final boolean resumeTopActivityLocked(ActivityRecord prev) {  
  15.         // Find the first activity that is not finishing.  
  16.         ActivityRecord next = topRunningActivityLocked(null);  
  17.   
  18.         // Remember how we'll process this pause/resume situation, and ensure  
  19.         // that the state is reset however we wind up proceeding.  
  20.         final boolean userLeaving = mUserLeaving;  
  21.         mUserLeaving = false;  
  22.   
  23.         if (next == null) {  
  24.             ......  
  25.         }  
  26.   
  27.         next.delayedResume = false;  
  28.   
  29.         // If the top activity is the resumed one, nothing to do.  
  30.         if (mResumedActivity == next && next.state == ActivityState.RESUMED) {  
  31.             ......  
  32.         }  
  33.   
  34.         // If we are sleeping, and there is no resumed activity, and the top  
  35.         // activity is paused, well that is the state we want.  
  36.         if ((mService.mSleeping || mService.mShuttingDown)  
  37.             && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {  
  38.             ......  
  39.         }  
  40.   
  41.         ......  
  42.   
  43.         // If we are currently pausing an activity, then don't do anything  
  44.         // until that is done.  
  45.         if (mPausingActivity != null) {  
  46.             ......  
  47.         }  
  48.   
  49.         ......  
  50.   
  51.         // We need to start pausing the current activity so the top one  
  52.         // can be resumed...  
  53.         if (mResumedActivity != null) {  
  54.             ......  
  55.             startPausingLocked(userLeaving, false);  
  56.             return true;  
  57.         }  
  58.   
  59.         ......  
  60.     }  
  61.   
  62.     ......  
  63.   
  64. }  
        函式先通過呼叫topRunningActivityLocked函式獲得堆疊頂端的Activity，這裡就是MainActivity了，這是在上面的Step 9設定好的，儲存在next變數中。 

       接下來把mUserLeaving的儲存在本地變數userLeaving中，然後重新設定為false，在上面的Step 9中，mUserLeaving的值為true，因此，這裡的userLeaving為true。

       這裡的mResumedActivity為Launcher，因為Launcher是當前正被執行的Activity。

       當我們處理休眠狀態時，mLastPausedActivity儲存堆疊頂端的Activity，因為當前不是休眠狀態，所以mLastPausedActivity為null。

       有了這些資訊之後，下面的語句就容易理解了：

[java] view plaincopy
  1.    // If the top activity is the resumed one, nothing to do.  
  2.    if (mResumedActivity == next && next.state == ActivityState.RESUMED) {  
  3. ......  
  4.    }  
  5.   
  6.    // If we are sleeping, and there is no resumed activity, and the top  
  7.    // activity is paused, well that is the state we want.  
  8.    if ((mService.mSleeping || mService.mShuttingDown)  
  9. && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {  
  10. ......  
  11.    }  
        它首先看要啟動的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檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) {  
  6.         if (mPausingActivity != null) {  
  7.             ......  
  8.         }  
  9.         ActivityRecord prev = mResumedActivity;  
  10.         if (prev == null) {  
  11.             ......  
  12.         }  
  13.         ......  
  14.         mResumedActivity = null;  
  15.         mPausingActivity = prev;  
  16.         mLastPausedActivity = prev;  
  17.         prev.state = ActivityState.PAUSING;  
  18.         ......  
  19.   
  20.         if (prev.app != null && prev.app.thread != null) {  
  21.             ......  
  22.             try {  
  23.                 ......  
  24.                 prev.app.thread.schedulePauseActivity(prev, prev.finishing, userLeaving,  
  25.                     prev.configChangeFlags);  
  26.                 ......  
  27.             } catch (Exception e) {  
  28.                 ......  
  29.             }  
  30.         } else {  
  31.             ......  
  32.         }  
  33.   
  34.         ......  
  35.       
  36.     }  
  37.   
  38.     ......  
  39.   
  40. }  

        函式首先把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檔案中：

[java] view plaincopy
  1. class ApplicationThreadProxy implements IApplicationThread {  
  2.       
  3.     ......  
  4.   
  5.     public final void schedulePauseActivity(IBinder token, boolean finished,  
  6.     boolean userLeaving, int configChanges) throws RemoteException {  
  7.         Parcel data = Parcel.obtain();  
  8.         data.writeInterfaceToken(IApplicationThread.descriptor);  
  9.         data.writeStrongBinder(token);  
  10.         data.writeInt(finished ? 1 : 0);  
  11.         data.writeInt(userLeaving ? 1 :0);  
  12.         data.writeInt(configChanges);  
  13.         mRemote.transact(SCHEDULE_PAUSE_ACTIVITY_TRANSACTION, data, null,  
  14.             IBinder.FLAG_ONEWAY);  
  15.         data.recycle();  
  16.     }  
  17.   
  18.     ......  
  19.   
  20. }  

        這個函式通過Binder程式間通訊機制進入到ApplicationThread.schedulePauseActivity函式中。

        Step 13. ApplicationThread.schedulePauseActivity

        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中，它是ActivityThread的內部類：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final class ApplicationThread extends ApplicationThreadNative {  
  6.           
  7.         ......  
  8.   
  9.         public final void schedulePauseActivity(IBinder token, boolean finished,  
  10.                 boolean userLeaving, int configChanges) {  
  11.             queueOrSendMessage(  
  12.                 finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,  
  13.                 token,  
  14.                 (userLeaving ? 1 : 0),  
  15.                 configChanges);  
  16.         }  
  17.   
  18.         ......  
  19.   
  20.     }  
  21.   
  22.     ......  
  23.   
  24. }  
        這裡呼叫的函式queueOrSendMessage是ActivityThread類的成員函式。

       上面說到，這裡的finished值為false，因此，queueOrSendMessage的第一個引數值為H.PAUSE_ACTIVITY，表示要暫停token所代表的Activity，即Launcher。

       Step 14. ActivityThread.queueOrSendMessage

       這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final void queueOrSendMessage(int what, Object obj, int arg1) {  
  6.         queueOrSendMessage(what, obj, arg1, 0);  
  7.     }  
  8.   
  9.     private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {  
  10.         synchronized (this) {  
  11.             ......  
  12.             Message msg = Message.obtain();  
  13.             msg.what = what;  
  14.             msg.obj = obj;  
  15.             msg.arg1 = arg1;  
  16.             msg.arg2 = arg2;  
  17.             mH.sendMessage(msg);  
  18.         }  
  19.     }  
  20.   
  21.     ......  
  22.   
  23. }  
        這裡首先將相關資訊組裝成一個msg，然後通過mH成員變數傳送出去，mH的型別是H，繼承於Handler類，是ActivityThread的內部類，因此，這個訊息最後由H.handleMessage來處理。

        Step 15. H.handleMessage

        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final class H extends Handler {  
  6.   
  7.         ......  
  8.   
  9.         public void handleMessage(Message msg) {  
  10.             ......  
  11.             switch (msg.what) {  
  12.               
  13.             ......  
  14.               
  15.             case PAUSE_ACTIVITY:  
  16.                 handlePauseActivity((IBinder)msg.obj, false, msg.arg1 != 0, msg.arg2);  
  17.                 maybeSnapshot();  
  18.                 break;  
  19.   
  20.             ......  
  21.   
  22.             }  
  23.         ......  
  24.   
  25.     }  
  26.   
  27.     ......  
  28.   
  29. }  

        這裡呼叫ActivityThread.handlePauseActivity進一步操作，msg.obj是一個ActivityRecord物件的引用，它代表的是Launcher這個Activity。
        Step 16. ActivityThread.handlePauseActivity

        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.       
  3.     ......  
  4.   
  5.     private final void handlePauseActivity(IBinder token, boolean finished,  
  6.             boolean userLeaving, int configChanges) {  
  7.   
  8.         ActivityClientRecord r = mActivities.get(token);  
  9.         if (r != null) {  
  10.             //Slog.v(TAG, "userLeaving=" + userLeaving + " handling pause of " + r);  
  11.             if (userLeaving) {  
  12.                 performUserLeavingActivity(r);  
  13.             }  
  14.   
  15.             r.activity.mConfigChangeFlags |= configChanges;  
  16.             Bundle state = performPauseActivity(token, finished, true);  
  17.   
  18.             // Make sure any pending writes are now committed.  
  19.             QueuedWork.waitToFinish();  
  20.   
  21.             // Tell the activity manager we have paused.  
  22.             try {  
  23.                 ActivityManagerNative.getDefault().activityPaused(token, state);  
  24.             } catch (RemoteException ex) {  
  25.             }  
  26.         }  
  27.     }  
  28.   
  29.     ......  
  30.   
  31. }  
         函式首先將Binder引用token轉換成ActivityRecord的遠端介面ActivityClientRecord，然後做了三個事情：1. 如果userLeaving為true，則通過呼叫performUserLeavingActivity函式來呼叫Activity.onUserLeaveHint通知Activity，使用者要離開它了；2. 呼叫performPauseActivity函式來呼叫Activity.onPause函式，我們知道，在Activity的生命週期中，當它要讓位於其它的Activity時，系統就會呼叫它的onPause函式；3. 它通知ActivityManagerService，這個Activity已經進入Paused狀態了，ActivityManagerService現在可以完成未竟的事情，即啟動MainActivity了。

        Step 17. ActivityManagerProxy.activityPaused

        這個函式定義在frameworks/base/core/java/android/app/ActivityManagerNative.java檔案中：

[java] view plaincopy
  1. class ActivityManagerProxy implements IActivityManager  
  2. {  
  3.     ......  
  4.   
  5.     public void activityPaused(IBinder token, Bundle state) throws RemoteException  
  6.     {  
  7.         Parcel data = Parcel.obtain();  
  8.         Parcel reply = Parcel.obtain();  
  9.         data.writeInterfaceToken(IActivityManager.descriptor);  
  10.         data.writeStrongBinder(token);  
  11.         data.writeBundle(state);  
  12.         mRemote.transact(ACTIVITY_PAUSED_TRANSACTION, data, reply, 0);  
  13.         reply.readException();  
  14.         data.recycle();  
  15.         reply.recycle();  
  16.     }  
  17.   
  18.     ......  
  19.   
  20. }  
        這裡通過Binder程式間通訊機制就進入到ActivityManagerService.activityPaused函式中去了。

        Step 18. ActivityManagerService.activityPaused

        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java檔案中：

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.             implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.     ......  
  4.   
  5.     public final void activityPaused(IBinder token, Bundle icicle) {  
  6.           
  7.         ......  
  8.   
  9.         final long origId = Binder.clearCallingIdentity();  
  10.         mMainStack.activityPaused(token, icicle, false);  
  11.           
  12.         ......  
  13.     }  
  14.   
  15.     ......  
  16.   
  17. }  
       這裡，又再次進入到ActivityStack類中，執行activityPaused函式。

       Step 19. ActivityStack.activityPaused

       這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final void activityPaused(IBinder token, Bundle icicle, boolean timeout) {  
  6.           
  7.         ......  
  8.   
  9.         ActivityRecord r = null;  
  10.   
  11.         synchronized (mService) {  
  12.             int index = indexOfTokenLocked(token);  
  13.             if (index >= 0) {  
  14.                 r = (ActivityRecord)mHistory.get(index);  
  15.                 if (!timeout) {  
  16.                     r.icicle = icicle;  
  17.                     r.haveState = true;  
  18.                 }  
  19.                 mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);  
  20.                 if (mPausingActivity == r) {  
  21.                     r.state = ActivityState.PAUSED;  
  22.                     completePauseLocked();  
  23.                 } else {  
  24.                     ......  
  25.                 }  
  26.             }  
  27.         }  
  28.     }  
  29.   
  30.     ......  
  31.   
  32. }  
       這裡通過引數token在mHistory列表中得到ActivityRecord，從上面我們知道，這個ActivityRecord代表的是Launcher這個Activity，而我們在Step 11中，把Launcher這個Activity的資訊儲存在mPausingActivity中，因此，這裡mPausingActivity等於r，於是，執行completePauseLocked操作。

       Step 20. ActivityStack.completePauseLocked

       這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void completePauseLocked() {  
  6.         ActivityRecord prev = mPausingActivity;  
  7.           
  8.         ......  
  9.   
  10.         if (prev != null) {  
  11.   
  12.             ......  
  13.   
  14.             mPausingActivity = null;  
  15.         }  
  16.   
  17.         if (!mService.mSleeping && !mService.mShuttingDown) {  
  18.             resumeTopActivityLocked(prev);  
  19.         } else {  
  20.             ......  
  21.         }  
  22.   
  23.         ......  
  24.     }  
  25.   
  26.     ......  
  27.   
  28. }  
        函式首先把mPausingActivity變數清空，因為現在不需要它了，然後呼叫resumeTopActivityLokced進一步操作，它傳入的引數即為代表Launcher這個Activity的ActivityRecord。

        Step 21. ActivityStack.resumeTopActivityLokced
        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final boolean resumeTopActivityLocked(ActivityRecord prev) {  
  6.         ......  
  7.   
  8.         // Find the first activity that is not finishing.  
  9.         ActivityRecord next = topRunningActivityLocked(null);  
  10.   
  11.         // Remember how we'll process this pause/resume situation, and ensure  
  12.         // that the state is reset however we wind up proceeding.  
  13.         final boolean userLeaving = mUserLeaving;  
  14.         mUserLeaving = false;  
  15.   
  16.         ......  
  17.   
  18.         next.delayedResume = false;  
  19.   
  20.         // If the top activity is the resumed one, nothing to do.  
  21.         if (mResumedActivity == next && next.state == ActivityState.RESUMED) {  
  22.             ......  
  23.             return false;  
  24.         }  
  25.   
  26.         // If we are sleeping, and there is no resumed activity, and the top  
  27.         // activity is paused, well that is the state we want.  
  28.         if ((mService.mSleeping || mService.mShuttingDown)  
  29.             && mLastPausedActivity == next && next.state == ActivityState.PAUSED) {  
  30.             ......  
  31.             return false;  
  32.         }  
  33.   
  34.         .......  
  35.   
  36.   
  37.         // We need to start pausing the current activity so the top one  
  38.         // can be resumed...  
  39.         if (mResumedActivity != null) {  
  40.             ......  
  41.             return true;  
  42.         }  
  43.   
  44.         ......  
  45.   
  46.   
  47.         if (next.app != null && next.app.thread != null) {  
  48.             ......  
  49.   
  50.         } else {  
  51.             ......  
  52.             startSpecificActivityLocked(next, true, true);  
  53.         }  
  54.   
  55.         return true;  
  56.     }  
  57.   
  58.   
  59.     ......  
  60.   
  61. }  
        通過上面的Step 9，我們知道，當前在堆疊頂端的Activity為我們即將要啟動的MainActivity，這裡通過呼叫topRunningActivityLocked將它取回來，儲存在next變數中。之前最後一個Resumed狀態的Activity，即Launcher，到了這裡已經處於Paused狀態了，因此，mResumedActivity為null。最後一個處於Paused狀態的Activity為Launcher，因此，這裡的mLastPausedActivity就為Launcher。前面我們為MainActivity建立了ActivityRecord後，它的app域一直保持為null。有了這些資訊後，上面這段程式碼就容易理解了，它最終呼叫startSpecificActivityLocked進行下一步操作。

       Step 22. ActivityStack.startSpecificActivityLocked
       這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     private final void startSpecificActivityLocked(ActivityRecord r,  
  6.             boolean andResume, boolean checkConfig) {  
  7.         // Is this activity's application already running?  
  8.         ProcessRecord app = mService.getProcessRecordLocked(r.processName,  
  9.             r.info.applicationInfo.uid);  
  10.   
  11.         ......  
  12.   
  13.         if (app != null && app.thread != null) {  
  14.             try {  
  15.                 realStartActivityLocked(r, app, andResume, checkConfig);  
  16.                 return;  
  17.             } catch (RemoteException e) {  
  18.                 ......  
  19.             }  
  20.         }  
  21.   
  22.         mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,  
  23.             "activity", r.intent.getComponent(), false);  
  24.     }  
  25.   
  26.   
  27.     ......  
  28.   
  29. }  
        注意，這裡由於是第一次啟動應用程式的Activity，所以下面語句：

[java] view plaincopy
  1. ProcessRecord app = mService.getProcessRecordLocked(r.processName,  
  2.     r.info.applicationInfo.uid);  
        取回來的app為null。在Activity應用程式中的AndroidManifest.xml配置檔案中，我們沒有指定Application標籤的process屬性，系統就會預設使用package的名稱，這裡就是"shy.luo.activity"了。每一個應用程式都有自己的uid，因此，這裡uid + process的組合就可以為每一個應用程式建立一個ProcessRecord。當然，我們可以配置兩個應用程式具有相同的uid和package，或者在AndroidManifest.xml配置檔案的application標籤或者activity標籤中顯式指定相同的process屬性值，這樣，不同的應用程式也可以在同一個程式中啟動。

       函式最終執行ActivityManagerService.startProcessLocked函式進行下一步操作。

       Step 23. ActivityManagerService.startProcessLocked

       這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java檔案中：

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     final ProcessRecord startProcessLocked(String processName,  
  7.             ApplicationInfo info, boolean knownToBeDead, int intentFlags,  
  8.             String hostingType, ComponentName hostingName, boolean allowWhileBooting) {  
  9.   
  10.         ProcessRecord app = getProcessRecordLocked(processName, info.uid);  
  11.           
  12.         ......  
  13.   
  14.         String hostingNameStr = hostingName != null  
  15.             ? hostingName.flattenToShortString() : null;  
  16.   
  17.         ......  
  18.   
  19.         if (app == null) {  
  20.             app = new ProcessRecordLocked(null, info, processName);  
  21.             mProcessNames.put(processName, info.uid, app);  
  22.         } else {  
  23.             // If this is a new package in the process, add the package to the list  
  24.             app.addPackage(info.packageName);  
  25.         }  
  26.   
  27.         ......  
  28.   
  29.         startProcessLocked(app, hostingType, hostingNameStr);  
  30.         return (app.pid != 0) ? app : null;  
  31.     }  
  32.   
  33.     ......  
  34.   
  35. }  
        這裡再次檢查是否已經有以process + uid命名的程式存在，在我們這個情景中，返回值app為null，因此，後面會建立一個ProcessRecord，並存儲存在成員變數mProcessNames中，最後，呼叫另一個startProcessLocked函式進一步操作：

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     private final void startProcessLocked(ProcessRecord app,  
  7.                 String hostingType, String hostingNameStr) {  
  8.   
  9.         ......  
  10.   
  11.         try {  
  12.             int uid = app.info.uid;  
  13.             int[] gids = null;  
  14.             try {  
  15.                 gids = mContext.getPackageManager().getPackageGids(  
  16.                     app.info.packageName);  
  17.             } catch (PackageManager.NameNotFoundException e) {  
  18.                 ......  
  19.             }  
  20.               
  21.             ......  
  22.   
  23.             int debugFlags = 0;  
  24.               
  25.             ......  
  26.               
  27.             int pid = Process.start("android.app.ActivityThread",  
  28.                 mSimpleProcessManagement ? app.processName : null, uid, uid,  
  29.                 gids, debugFlags, null);  
  30.               
  31.             ......  
  32.   
  33.         } catch (RuntimeException e) {  
  34.               
  35.             ......  
  36.   
  37.         }  
  38.     }  
  39.   
  40.     ......  
  41.   
  42. }  
        這裡主要是呼叫Process.start介面來建立一個新的程式，新的程式會匯入android.app.ActivityThread類，並且執行它的main函式，這就是為什麼我們前面說每一個應用程式都有一個ActivityThread例項來對應的原因。

        Step 24. ActivityThread.main

        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final void attach(boolean system) {  
  6.         ......  
  7.   
  8.         mSystemThread = system;  
  9.         if (!system) {  
  10.   
  11.             ......  
  12.   
  13.             IActivityManager mgr = ActivityManagerNative.getDefault();  
  14.             try {  
  15.                 mgr.attachApplication(mAppThread);  
  16.             } catch (RemoteException ex) {  
  17.             }  
  18.         } else {  
  19.   
  20.             ......  
  21.   
  22.         }  
  23.     }  
  24.   
  25.     ......  
  26.   
  27.     public static final void main(String[] args) {  
  28.           
  29.         .......  
  30.   
  31.         ActivityThread thread = new ActivityThread();  
  32.         thread.attach(false);  
  33.   
  34.         ......  
  35.   
  36.         Looper.loop();  
  37.   
  38.         .......  
  39.   
  40.         thread.detach();  
  41.           
  42.         ......  
  43.     }  
  44. }  
       這個函式在程式中建立一個ActivityThread例項，然後呼叫它的attach函式，接著就進入訊息迴圈了，直到最後程式退出。

       函式attach最終呼叫了ActivityManagerService的遠端介面ActivityManagerProxy的attachApplication函式，傳入的引數是mAppThread，這是一個ApplicationThread型別的Binder物件，它的作用是用來進行程式間通訊的。

      Step 25. ActivityManagerProxy.attachApplication

      這個函式定義在frameworks/base/core/java/android/app/ActivityManagerNative.java檔案中：

[java] view plaincopy
  1. class ActivityManagerProxy implements IActivityManager  
  2. {  
  3.     ......  
  4.   
  5.     public void attachApplication(IApplicationThread app) throws RemoteException  
  6.     {  
  7.         Parcel data = Parcel.obtain();  
  8.         Parcel reply = Parcel.obtain();  
  9.         data.writeInterfaceToken(IActivityManager.descriptor);  
  10.         data.writeStrongBinder(app.asBinder());  
  11.         mRemote.transact(ATTACH_APPLICATION_TRANSACTION, data, reply, 0);  
  12.         reply.readException();  
  13.         data.recycle();  
  14.         reply.recycle();  
  15.     }  
  16.   
  17.     ......  
  18.   
  19. }  
       這裡通過Binder驅動程式，最後進入ActivityManagerService的attachApplication函式中。

       Step 26. ActivityManagerService.attachApplication

       這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java檔案中：

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     public final void attachApplication(IApplicationThread thread) {  
  7.         synchronized (this) {  
  8.             int callingPid = Binder.getCallingPid();  
  9.             final long origId = Binder.clearCallingIdentity();  
  10.             attachApplicationLocked(thread, callingPid);  
  11.             Binder.restoreCallingIdentity(origId);  
  12.         }  
  13.     }  
  14.   
  15.     ......  
  16.   
  17. }  
        這裡將操作轉發給attachApplicationLocked函式。

        Step 27. ActivityManagerService.attachApplicationLocked

        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityManagerService.java檔案中：

[java] view plaincopy
  1. public final class ActivityManagerService extends ActivityManagerNative  
  2.         implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {  
  3.   
  4.     ......  
  5.   
  6.     private final boolean attachApplicationLocked(IApplicationThread thread,  
  7.             int pid) {  
  8.         // Find the application record that is being attached...  either via  
  9.         // the pid if we are running in multiple processes, or just pull the  
  10.         // next app record if we are emulating process with anonymous threads.  
  11.         ProcessRecord app;  
  12.         if (pid != MY_PID && pid >= 0) {  
  13.             synchronized (mPidsSelfLocked) {  
  14.                 app = mPidsSelfLocked.get(pid);  
  15.             }  
  16.         } else if (mStartingProcesses.size() > 0) {  
  17.             ......  
  18.         } else {  
  19.             ......  
  20.         }  
  21.   
  22.         if (app == null) {  
  23.             ......  
  24.             return false;  
  25.         }  
  26.   
  27.         ......  
  28.   
  29.         String processName = app.processName;  
  30.         try {  
  31.             thread.asBinder().linkToDeath(new AppDeathRecipient(  
  32.                 app, pid, thread), 0);  
  33.         } catch (RemoteException e) {  
  34.             ......  
  35.             return false;  
  36.         }  
  37.   
  38.         ......  
  39.   
  40.         app.thread = thread;  
  41.         app.curAdj = app.setAdj = -100;  
  42.         app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;  
  43.         app.setSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;  
  44.         app.forcingToForeground = null;  
  45.         app.foregroundServices = false;  
  46.         app.debugging = false;  
  47.   
  48.         ......  
  49.   
  50.         boolean normalMode = mProcessesReady || isAllowedWhileBooting(app.info);  
  51.   
  52.         ......  
  53.   
  54.         boolean badApp = false;  
  55.         boolean didSomething = false;  
  56.   
  57.         // See if the top visible activity is waiting to run in this process...  
  58.         ActivityRecord hr = mMainStack.topRunningActivityLocked(null);  
  59.         if (hr != null && normalMode) {  
  60.             if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid  
  61.                 && processName.equals(hr.processName)) {  
  62.                     try {  
  63.                         if (mMainStack.realStartActivityLocked(hr, app, true, true)) {  
  64.                             didSomething = true;  
  65.                         }  
  66.                     } catch (Exception e) {  
  67.                         ......  
  68.                     }  
  69.             } else {  
  70.                 ......  
  71.             }  
  72.         }  
  73.   
  74.         ......  
  75.   
  76.         return true;  
  77.     }  
  78.   
  79.     ......  
  80.   
  81. }  

        在前面的Step 23中，已經建立了一個ProcessRecord，這裡首先通過pid將它取回來，放在app變數中，然後對app的其它成員進行初始化，最後呼叫mMainStack.realStartActivityLocked執行真正的Activity啟動操作。這裡要啟動的Activity通過呼叫mMainStack.topRunningActivityLocked(null)從堆疊頂端取回來，這時候在堆疊頂端的Activity就是MainActivity了。

        Step 28. ActivityStack.realStartActivityLocked

        這個函式定義在frameworks/base/services/java/com/android/server/am/ActivityStack.java檔案中：

[java] view plaincopy
  1. public class ActivityStack {  
  2.   
  3.     ......  
  4.   
  5.     final boolean realStartActivityLocked(ActivityRecord r,  
  6.             ProcessRecord app, boolean andResume, boolean checkConfig)  
  7.             throws RemoteException {  
  8.           
  9.         ......  
  10.   
  11.         r.app = app;  
  12.   
  13.         ......  
  14.   
  15.         int idx = app.activities.indexOf(r);  
  16.         if (idx < 0) {  
  17.             app.activities.add(r);  
  18.         }  
  19.           
  20.         ......  
  21.   
  22.         try {  
  23.             ......  
  24.   
  25.             List<ResultInfo> results = null;  
  26.             List<Intent> newIntents = null;  
  27.             if (andResume) {  
  28.                 results = r.results;  
  29.                 newIntents = r.newIntents;  
  30.             }  
  31.       
  32.             ......  
  33.               
  34.             app.thread.scheduleLaunchActivity(new Intent(r.intent), r,  
  35.                 System.identityHashCode(r),  
  36.                 r.info, r.icicle, results, newIntents, !andResume,  
  37.                 mService.isNextTransitionForward());  
  38.   
  39.             ......  
  40.   
  41.         } catch (RemoteException e) {  
  42.             ......  
  43.         }  
  44.   
  45.         ......  
  46.   
  47.         return true;  
  48.     }  
  49.   
  50.     ......  
  51.   
  52. }  
        這裡最終通過app.thread進入到ApplicationThreadProxy的scheduleLaunchActivity函式中，注意，這裡的第二個引數r，是一個ActivityRecord型別的Binder物件，用來作來這個Activity的token值。

        Step 29. ApplicationThreadProxy.scheduleLaunchActivity
        這個函式定義在frameworks/base/core/java/android/app/ApplicationThreadNative.java檔案中：

[java] view plaincopy
  1. class ApplicationThreadProxy implements IApplicationThread {  
  2.   
  3.     ......  
  4.   
  5.     public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,  
  6.             ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,  
  7.             List<Intent> pendingNewIntents, boolean notResumed, boolean isForward)  
  8.             throws RemoteException {  
  9.         Parcel data = Parcel.obtain();  
  10.         data.writeInterfaceToken(IApplicationThread.descriptor);  
  11.         intent.writeToParcel(data, 0);  
  12.         data.writeStrongBinder(token);  
  13.         data.writeInt(ident);  
  14.         info.writeToParcel(data, 0);  
  15.         data.writeBundle(state);  
  16.         data.writeTypedList(pendingResults);  
  17.         data.writeTypedList(pendingNewIntents);  
  18.         data.writeInt(notResumed ? 1 : 0);  
  19.         data.writeInt(isForward ? 1 : 0);  
  20.         mRemote.transact(SCHEDULE_LAUNCH_ACTIVITY_TRANSACTION, data, null,  
  21.             IBinder.FLAG_ONEWAY);  
  22.         data.recycle();  
  23.     }  
  24.   
  25.     ......  
  26.   
  27. }  
        這個函式最終通過Binder驅動程式進入到ApplicationThread的scheduleLaunchActivity函式中。

        Step 30. ApplicationThread.scheduleLaunchActivity
        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final class ApplicationThread extends ApplicationThreadNative {  
  6.   
  7.         ......  
  8.   
  9.         // we use token to identify this activity without having to send the  
  10.         // activity itself back to the activity manager. (matters more with ipc)  
  11.         public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,  
  12.                 ActivityInfo info, Bundle state, List<ResultInfo> pendingResults,  
  13.                 List<Intent> pendingNewIntents, boolean notResumed, boolean isForward) {  
  14.             ActivityClientRecord r = new ActivityClientRecord();  
  15.   
  16.             r.token = token;  
  17.             r.ident = ident;  
  18.             r.intent = intent;  
  19.             r.activityInfo = info;  
  20.             r.state = state;  
  21.   
  22.             r.pendingResults = pendingResults;  
  23.             r.pendingIntents = pendingNewIntents;  
  24.   
  25.             r.startsNotResumed = notResumed;  
  26.             r.isForward = isForward;  
  27.   
  28.             queueOrSendMessage(H.LAUNCH_ACTIVITY, r);  
  29.         }  
  30.   
  31.         ......  
  32.   
  33.     }  
  34.   
  35.     ......  
  36. }  
         函式首先建立一個ActivityClientRecord例項，並且初始化它的成員變數，然後呼叫ActivityThread類的queueOrSendMessage函式進一步處理。

         Step 31. ActivityThread.queueOrSendMessage
         這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final class ApplicationThread extends ApplicationThreadNative {  
  6.   
  7.         ......  
  8.   
  9.         // if the thread hasn't started yet, we don't have the handler, so just  
  10.         // save the messages until we're ready.  
  11.         private final void queueOrSendMessage(int what, Object obj) {  
  12.             queueOrSendMessage(what, obj, 0, 0);  
  13.         }  
  14.   
  15.         ......  
  16.   
  17.         private final void queueOrSendMessage(int what, Object obj, int arg1, int arg2) {  
  18.             synchronized (this) {  
  19.                 ......  
  20.                 Message msg = Message.obtain();  
  21.                 msg.what = what;  
  22.                 msg.obj = obj;  
  23.                 msg.arg1 = arg1;  
  24.                 msg.arg2 = arg2;  
  25.                 mH.sendMessage(msg);  
  26.             }  
  27.         }  
  28.   
  29.         ......  
  30.   
  31.     }  
  32.   
  33.     ......  
  34. }  
        函式把訊息內容放在msg中，然後通過mH把訊息分發出去，這裡的成員變數mH我們在前面已經見過，訊息分發出去後，最後會呼叫H類的handleMessage函式。

        Step 32. H.handleMessage

        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final class H extends Handler {  
  6.   
  7.         ......  
  8.   
  9.         public void handleMessage(Message msg) {  
  10.             ......  
  11.             switch (msg.what) {  
  12.             case LAUNCH_ACTIVITY: {  
  13.                 ActivityClientRecord r = (ActivityClientRecord)msg.obj;  
  14.   
  15.                 r.packageInfo = getPackageInfoNoCheck(  
  16.                     r.activityInfo.applicationInfo);  
  17.                 handleLaunchActivity(r, null);  
  18.             } break;  
  19.             ......  
  20.             }  
  21.   
  22.         ......  
  23.   
  24.     }  
  25.   
  26.     ......  
  27. }  
        這裡最後呼叫ActivityThread類的handleLaunchActivity函式進一步處理。

        Step 33. ActivityThread.handleLaunchActivity

        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {  
  6.         ......  
  7.   
  8.         Activity a = performLaunchActivity(r, customIntent);  
  9.   
  10.         if (a != null) {  
  11.             r.createdConfig = new Configuration(mConfiguration);  
  12.             Bundle oldState = r.state;  
  13.             handleResumeActivity(r.token, false, r.isForward);  
  14.   
  15.             ......  
  16.         } else {  
  17.             ......  
  18.         }  
  19.     }  
  20.   
  21.     ......  
  22. }  
        這裡首先呼叫performLaunchActivity函式來載入這個Activity類，即shy.luo.activity.MainActivity，然後呼叫它的onCreate函式，最後回到handleLaunchActivity函式時，再呼叫handleResumeActivity函式來使這個Activity進入Resumed狀態，即會呼叫這個Activity的onResume函式，這是遵循Activity的生命週期的。

        Step 34. ActivityThread.performLaunchActivity
        這個函式定義在frameworks/base/core/java/android/app/ActivityThread.java檔案中：

[java] view plaincopy
  1. public final class ActivityThread {  
  2.   
  3.     ......  
  4.   
  5.     private final Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {  
  6.           
  7.         ActivityInfo aInfo = r.activityInfo;  
  8.         if (r.packageInfo == null) {  
  9.             r.packageInfo = getPackageInfo(aInfo.applicationInfo,  
  10.                 Context.CONTEXT_INCLUDE_CODE);  
  11.         }  
  12.   
  13.         ComponentName component = r.intent.getComponent();  
  14.         if (component == null) {  
  15.             component = r.intent.resolveActivity(  
  16.                 mInitialApplication.getPackageManager());  
  17.             r.intent.setComponent(component);  
  18.         }  
  19.   
  20.         if (r.activityInfo.targetActivity != null) {  
  21.             component = new ComponentName(r.activityInfo.packageName,  
  22.                 r.activityInfo.targetActivity);  
  23.         }  
  24.   
  25.         Activity activity = null;  
  26.         try {  
  27.             java.lang.ClassLoader cl = r.packageInfo.getClassLoader();  
  28.             activity = mInstrumentation.newActivity(  
  29.                 cl, component.getClassName(), r.intent);  
  30.             r.intent.setExtrasClassLoader(cl);  
  31.             if (r.state != null) {  
  32.                 r.state.setClassLoader(cl);  
  33.             }  
  34.         } catch (Exception e) {  
  35.             ......  
  36.         }  
  37.   
  38.         try {  
  39.             Application app = r.packageInfo.makeApplication(false, mInstrumentation);  
  40.   
  41.             ......  
  42.   
  43.             if (activity != null) {  
  44.                 ContextImpl appContext = new ContextImpl();  
  45.                 appContext.init(r.packageInfo, r.token, this);  
  46.                 appContext.setOuterContext(activity);  
  47.                 CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());  
  48.                 Configuration config = new Configuration(mConfiguration);  
  49.                 ......  
  50.                 activity.attach(appContext, this, getInstrumentation(), r.token,  
  51.                     r.ident, app, r.intent, r.activityInfo, title, r.parent,  
  52.                     r.embeddedID, r.lastNonConfigurationInstance,  
  53.                     r.lastNonConfigurationChildInstances, config);  
  54.   
  55.                 if (customIntent != null) {  
  56.                     activity.mIntent = customIntent;  
  57.                 }  
  58.                 r.lastNonConfigurationInstance = null;  
  59.                 r.lastNonConfigurationChildInstances = null;  
  60.                 activity.mStartedActivity = false;  
  61.                 int theme = r.activityInfo.getThemeResource();  
  62.                 if (theme != 0) {  
  63.                     activity.setTheme(theme);  
  64.                 }  
  65.   
  66.                 activity.mCalled = false;  
  67.                 mInstrumentation.callActivityOnCreate(activity, r.state);  
  68.                 ......  
  69.                 r.activity = activity;  
  70.                 r.stopped = true;  
  71.                 if (!r.activity.mFinished) {  
  72.                     activity.performStart();  
  73.                     r.stopped = false;  
  74.                 }  
  75.                 if (!r.activity.mFinished) {  
  76.                     if (r.state != null) {  
  77.                         mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);  
  78.                     }  
  79.                 }  
  80.                 if (!r.activity.mFinished) {  
  81.                     activity.mCalled = false;  
  82.                     mInstrumentation.callActivityOnPostCreate(activity, r.state);  
  83.                     if (!activity.mCalled) {  
  84.                         throw new SuperNotCalledException(  
  85.                             "Activity " + r.intent.getComponent().toShortString() +  
  86.                             " did not call through to super.onPostCreate()");  
  87.                     }  
  88.                 }  
  89.             }  
  90.             r.paused = true;  
  91.   
  92.             mActivities.put(r.token, r);  
  93.   
  94.         } catch (SuperNotCalledException e) {  
  95.             ......  
  96.   
  97.         } catch (Exception e) {  
  98.             ......  
  99.         }  
  100.   
  101.         return activity;  
  102.     }  
  103.   
  104.     ......  
  105. }  

       函式前面是收集要啟動的Activity的相關資訊，主要package和component資訊：

[java] view plaincopy
  1. ActivityInfo aInfo = r.activityInfo;  
  2. if (r.packageInfo == null) {  
  3.      r.packageInfo = getPackageInfo(aInfo.applicationInfo,  
  4.              Context.CONTEXT_INCLUDE_CODE);  
  5. }  
  6.   
  7. ComponentName component = r.intent.getComponent();  
  8. if (component == null) {  
  9.     component = r.intent.resolveActivity(  
  10.         mInitialApplication.getPackageManager());  
  11.     r.intent.setComponent(component);  
  12. }  
  13.   
  14. if (r.activityInfo.targetActivity != null) {  
  15.     component = new ComponentName(r.activityInfo.packageName,  
  16.             r.activityInfo.targetActivity);  
  17. }  
       然後通過ClassLoader將shy.luo.activity.MainActivity類載入進來：

[java] view plaincopy
  1.   Activity activity = null;  
  2.   try {  
  3. java.lang.ClassLoader cl = r.packageInfo.getClassLoader();  
  4. activity = mInstrumentation.newActivity(  
  5.     cl, component.getClassName(), r.intent);  
  6. r.intent.setExtrasClassLoader(cl);  
  7. if (r.state != null) {  
  8.     r.state.setClassLoader(cl);  
  9. }  
  10.   } catch (Exception e) {  
  11. ......  
  12.   }  
      接下來是建立Application物件，這是根據AndroidManifest.xml配置檔案中的Application標籤的資訊來建立的：

[java] view plaincopy
  1. Application app = r.packageInfo.makeApplication(false, mInstrumentation);  
      後面的程式碼主要建立Activity的上下文資訊，並通過attach方法將這些上下文資訊設定到MainActivity中去：

[java] view plaincopy
  1.   activity.attach(appContext, this, getInstrumentation(), r.token,  
  2. r.ident, app, r.intent, r.activityInfo, title, r.parent,  
  3. r.embeddedID, r.lastNonConfigurationInstance,  
  4. r.lastNonConfigurationChildInstances, config);  
      最後還要呼叫MainActivity的onCreate函式：

[java] view plaincopy
  1. mInstrumentation.callActivityOnCreate(activity, r.state);  
      這裡不是直接呼叫MainActivity的onCreate函式，而是通過mInstrumentation的callActivityOnCreate函式來間接呼叫，前面我們說過，mInstrumentation在這裡的作用是監控Activity與系統的互動操作，相當於是系統執行日誌。

      Step 35. MainActivity.onCreate

      這個函式定義在packages/experimental/Activity/src/shy/luo/activity/MainActivity.java檔案中，這是我們自定義的app工程檔案：

[java] view plaincopy
  1. public class MainActivity extends Activity  implements OnClickListener {  
  2.       
  3.     ......  
  4.   
  5.     @Override  
  6.     public void onCreate(Bundle savedInstanceState) {  
  7.         ......  
  8.   
  9.         Log.i(LOG_TAG, "Main Activity Created.");  
  10.     }  
  11.   
  12.     ......  
  13.   
  14. }  
       這樣，MainActivity就啟動起來了，整個應用程式也啟動起來了。

       整個應用程式的啟動過程要執行很多步驟，但是整體來看，主要分為以下五個階段：

       一. Step1 - Step 11：Launcher通過Binder程式間通訊機制通知ActivityManagerService，它要啟動一個Activity；

       二. Step 12 - Step 16：ActivityManagerService通過Binder程式間通訊機制通知Launcher進入Paused狀態；

       三. Step 17 - Step 24：Launcher通過Binder程式間通訊機制通知ActivityManagerService，它已經準備就緒進入Paused狀態，於是ActivityManagerService就建立一個新的程式，用來啟動一個ActivityThread例項，即將要啟動的Activity就是在這個ActivityThread例項中執行；

       四. Step 25 - Step 27：ActivityThread通過Binder程式間通訊機制將一個ApplicationThread型別的Binder物件傳遞給ActivityManagerService，以便以後ActivityManagerService能夠通過這個Binder物件和它進行通訊；

       五. Step 28 - Step 35：ActivityManagerService通過Binder程式間通訊機制通知ActivityThread，現在一切準備就緒，它可以真正執行Activity的啟動操作了。

       這裡不少地方涉及到了Binder程式間通訊機制，相關資料請參考Android程式間通訊（IPC）機制Binder簡要介紹和學習計劃一文。

       這樣，應用程式的啟動過程就介紹完了，它實質上是啟動應用程式的預設Activity，在下一篇文章中，我們將介紹在應用程式內部啟動另一個Activity的過程，即新的Activity與啟動它的Activity將會在同一個程式（Process）和任務（Task）執行，敬請關注。

相關文章