Android之Activity啓動流程詳解（基於api28）

前言

Activity做爲Android四大組件之一，他的啓動絕對沒有那麼簡單。這裏涉及到了系統服務進程，啓動過程細節不少，這裏我只展現主體流程。activity的啓動流程隨着版本的更替，代碼細節一直在進行更改，每次都會有很大的修改，如android5.0 android8.0。我這裏的版本是基於android api28，也是目前我能夠查獲得的最新源碼了。事實上大題的流程是相同的，掌握了一個版本，其餘的版本經過源碼也能夠很快地掌握。

由於涉及到不一樣的進程之間的通訊：系統服務進程和本地進程，在最新版本的android使用的是AIDL來跨進程通訊。因此須要對AIDL有必定的瞭解，會幫助理解整個啓動流程。

源碼部分的講解涉及到不少的代碼講解，可能會有一點不適，但仍是建議看完源碼。源碼的關鍵代碼處我都會加上註釋，方便理解。

代碼不會過度關注細節，只注重總體流程。想知道具體細節能夠去查看源碼。每份代碼所在的路徑我都會在代碼前面標註出來，各位能夠去查看相對應的源碼。

每部分源碼前我都會放流程圖，必定要配合流程圖食用，否則可能會亂。

總體流程概述

這一部分側重於對整個啓動流程的概述，在心中有大致的概念，這樣能夠幫助對下面具體細節流程的理解。

普通Activity的建立

普通Activity建立也就是日常咱們在代碼中採用startActivity(Intent intent)方法來建立Activity的方式。整體流程以下圖：

啓動過程設計到兩個進程：本地進程和系統服務進程。本地進程也就是咱們的應用所在進程，系統服務進程爲全部應用共用的服務進程。總體思路是：

1. activity向Instrumentation請求建立

2. Instrumentation經過AMS在本地進程的IBinder接口，訪問AMS，這裏採用的跨進程技術是AIDL。

3. 而後AMS進程一系列的工做，如判斷該activity是否存在，啓動模式是什麼，有沒有進行註冊等等。

4. 經過ClientLifeCycleManager，利用本地進程在系統服務進程的IBinder接口直接訪問本地ActivityThread。

   ApplicationThread是ActivityThread的內部類，IApplicationThread是在遠程服務端的Binder接口

5. ApplicationThread接收到服務端的事務後，把事務直接轉交給ActivityThread處理。

6. ActivityThread經過Instrumentation利用類加載器進行建立實例，同時利用Instrumentation回調activity的生命中週期

這裏涉及到了兩個進程，本地進程主要負責建立activity以及回調生命週期，服務進程主要判斷該activity是否合法，是否須要建立activity棧等等。進程之間就涉及到了進程通訊：AIDL。（若是不熟悉能夠先去了解一下，但能夠簡單理解爲接口回調便可）

下面介紹幾個關鍵類：

• Instrumentation是activity與外界聯繫的類（不是activity自己的統稱外界，相對activity而言），activity經過Instrumentation來請求建立，ActivityThread經過Instrumentation來建立activity和調用activity的生命週期。

• ActivityThread，每一個應用程序惟一一個實例，負責對Activity建立的管理，而ApplicationThread只是應用程序和服務端進程通訊的類而已，只負責通訊，把AMS的任務交給ActivityThread。

• AMS，全稱ActivityManagerService，負責統籌服務端對activity建立的流程。

  其餘的類，後面的源碼解析會詳解。

根Activity的建立

根Activity也就是咱們點擊桌面圖標的時候，應用程序第一個activity啓動的流程。這裏我側重講解多個進程之間的關係，下面的源碼也不會講細節，只講解普通activity的建立流程。這裏也至關於一個補充。先看總體流程圖：

主要涉及四個進程：

• Launcher進程，也就是桌面進程
• 系統服務進程，AMS所在進程
• Zygote進程，負責建立進程
• 應用程序進程，也就是即將要啓動的進程

主要流程：

1. Launcher進程請求AMS建立activity
2. AMS請求Zygote建立進程。
3. Zygote經過fork本身來建立進程。並通知AMS建立完成。
4. AMS通知應用進程建立根Activity。

和普通Activity的建立很像，主要多了建立進程這一步。

源碼講解

Activity請求AMS的過程

流程圖

源碼

1. 系統經過調用Launcher的startActivitySafely方法來啓動應用程序。Launcher是一個類，負責啓動根Activity。

   這一步是根Activity啓動纔有的流程，普通啓動是沒有的，放在這裏是做爲一點補充而已

   packages/apps/Launcher3/src/com/android/launcher3/Launcher.java/;
   public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
       	//這裏調用了父類的方法，繼續查看父類的方法實現
           boolean success = super.startActivitySafely(v, intent, item);
           ...
           return success;
       }

   packages/apps/Launcher3/src/com/android/launcher3/BaseDraggingActivity.java/;
   public boolean startActivitySafely(View v, Intent intent, ItemInfo item) {
           ...
           // Prepare intent
           //設置標誌singleTask，意味着在新的棧打開
           intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
           if (v != null) {
               intent.setSourceBounds(getViewBounds(v));
           }
           try {
               boolean isShortcut = Utilities.ATLEAST_MARSHMALLOW
                       && (item instanceof ShortcutInfo)
                       && (item.itemType == Favorites.ITEM_TYPE_SHORTCUT
                       || item.itemType == Favorites.ITEM_TYPE_DEEP_SHORTCUT)
                       && !((ShortcutInfo) item).isPromise();
               //下面註釋1和註釋2都是直接採用startActivity進行啓動。註釋1會作一些設置
               //BaseDraggingActivity是繼承自BaseActivity，而BaseActivity是繼承自Activity
               //因此直接就跳轉到了Activity的startActivity邏輯。
               if (isShortcut) {
                   // Shortcuts need some special checks due to legacy reasons.
                   startShortcutIntentSafely(intent, optsBundle, item);//1
               } else if (user == null || user.equals(Process.myUserHandle())) {
                   // Could be launching some bookkeeping activity
                   startActivity(intent, optsBundle);//2
               } else {
                   LauncherAppsCompat.getInstance(this).startActivityForProfile(
                           intent.getComponent(), user, intent.getSourceBounds(), optsBundle);
               }
               
              ...
           } 
       	...
           return false;
       }

2. Activity經過Instrumentation來啓動Activity

   /frameworks/base/core/java/android/app/Activity.java/;
   public void startActivity(Intent intent, @Nullable Bundle options) {
       	//最終都會跳轉到startActivityForResult這個方法
           if (options != null) {
               startActivityForResult(intent, -1, options);
           } else {
               // Note we want to go through this call for compatibility with
               // applications that may have overridden the method.
               startActivityForResult(intent, -1);
           }
       }
   
   public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
               @Nullable Bundle options) {
       	//mParent是指activityGroup，如今已經採用Fragment代替，這裏會一直是null
       	//下一步會經過mInstrumentation.execStartActivity進行啓動
           if (mParent == null) {
               options = transferSpringboardActivityOptions(options);
               Instrumentation.ActivityResult ar =
                   mInstrumentation.execStartActivity(
                       this, mMainThread.getApplicationThread(), mToken, this,
                       intent, requestCode, options);//1
               if (ar != null) {
                   mMainThread.sendActivityResult(
                       mToken, mEmbeddedID, requestCode, ar.getResultCode(),
                       ar.getResultData());
               }
               ...
           }
       ...
   }

3. Instrumentation請求AMS進行啓動。該類的做用是監控應用程序和系統的交互。到此爲止，任務就交給了AMS了，AMS進行一系列處理後，會經過本地的接口IActivityManager來進行回調啓動activity。

   /frameworks/base/core/java/android/app/Instrumentation.java/;
   public ActivityResult execStartActivity(
               Context who, IBinder contextThread, IBinder token, Activity target,
               Intent intent, int requestCode, Bundle options) {
       ...
       //這個地方比較複雜，先說結論。下面再進行解釋    
       //ActivityManager.getService()獲取到的對象是ActivityManagerService，簡稱AMS
       //經過AMS來啓動activity。AMS是全局惟一的，全部的活動啓動都要通過他的驗證，運行在獨立的進程中
       //因此這裏是採用AIDL的方式進行跨進程通訊，獲取到的對象實際上是一個IBinder接口
           
       //註釋2是進行檢查啓動結果，若是異常則拋出，如沒有註冊。
       try {
               intent.migrateExtraStreamToClipData();
               intent.prepareToLeaveProcess(who);
               int result = ActivityManager.getService()
                   .startActivity(whoThread, who.getBasePackageName(), intent,
                           intent.resolveTypeIfNeeded(who.getContentResolver()),
                           token, target != null ? target.mEmbeddedID : null,
                           requestCode, 0, null, options);//1
               checkStartActivityResult(result, intent);//2
           } catch (RemoteException e) {
               throw new RuntimeException("Failure from system", e);
           }
           return null;
       
   }

   這一步是經過AIDL技術進行跨進行通訊。拿到AMS的代理對象，把啓動任務交給了AMS。

   /frameworks/base/core/java/android/app/ActivityManager.java/;
   //單例類
   public static IActivityManager getService() {
   return IActivityManagerSingleton.get();
   }
   
   private static final Singleton<IActivityManager> IActivityManagerSingleton =
   new Singleton<IActivityManager>() {
   @Override
   protected IActivityManager create() {
   //獲得AMS的IBinder接口
   final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
   //轉化成IActivityManager對象。遠程服務實現了這個接口，因此能夠直接調用這個
   //AMS代理對象的接口方法來請求AMS。這裏採用的技術是AIDL
   final IActivityManager am = IActivityManager.Stub.asInterface(b);
   return am;
   }
   };

AMS處理請求的過程

流程圖

源碼

1. 接下來看AMS的實現邏輯。AMS這部分的源碼是經過ActivityStartController來建立一個ActivityStarter，而後把邏輯都交給ActivityStarter去執行。ActivityStarter是android 7.0加入的類。

   /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java/;
   //跳轉到startActivityAsUser
   //注意最後多了一個參數UserHandle.getCallingUserId()，表示調用者權限
   public final int startActivity(IApplicationThread caller, String callingPackage,
           Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
           int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
       return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
               resultWho, requestCode, startFlags, profilerInfo, bOptions,
               UserHandle.getCallingUserId());
   }
   
   public final int startActivityAsUser(IApplicationThread caller, String callingPackage,
               Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
               int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
               boolean validateIncomingUser) {
           enforceNotIsolatedCaller("startActivity");
   
           userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,
                   Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
   
           // TODO: Switch to user app stacks here.
       	//這裏經過ActivityStartController獲取到ActivityStarter，經過ActivityStarter來
       	//執行啓動任務。這裏就把任務邏輯給到了AcitivityStarter
           return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
                   .setCaller(caller)
                   .setCallingPackage(callingPackage)
                   .setResolvedType(resolvedType)
                   .setResultTo(resultTo)
                   .setResultWho(resultWho)
                   .setRequestCode(requestCode)
                   .setStartFlags(startFlags)
                   .setProfilerInfo(profilerInfo)
                   .setActivityOptions(bOptions)
                   .setMayWait(userId)
                   .execute();
   
       }

   ActivityStartController獲取ActivityStarter

   /frameworks/base/services/core/java/com/android/server/am/ActivityStartController.java/;
   //獲取到ActivityStarter對象。這個對象僅使用一次，當他的execute被執行後，該對象做廢
   ActivityStarter obtainStarter(Intent intent, String reason) {
   return mFactory.obtain().setIntent(intent).setReason(reason);
   }

2. 這部分主要是ActivityStarter的源碼內容，涉及到的源碼很是多。AMS把整個啓動邏輯都丟給ActivityStarter去處理了。這裏主要作啓動前處理，建立進程等等。

   /frameworks/base/services/core/java/com/android/server/am/ActivityStarter.java/;
   //這裏須要作啓動預處理，執行startActivityMayWait方法
   int execute() {
           try {
              	...
               if (mRequest.mayWait) {
                   return startActivityMayWait(mRequest.caller, mRequest.callingUid,
                           mRequest.callingPackage, mRequest.intent, mRequest.resolvedType,
                           mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
                           mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
                           mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
                           mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
                           mRequest.inTask, mRequest.reason,
                           mRequest.allowPendingRemoteAnimationRegistryLookup);
               }
               ...
           } 
       	...
       }
   
   //啓動預處理
   private int startActivityMayWait(IApplicationThread caller, int callingUid,
               String callingPackage, Intent intent, String resolvedType,
               IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
               IBinder resultTo, String resultWho, int requestCode, int startFlags,
               ProfilerInfo profilerInfo, WaitResult outResult,
               Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
               int userId, TaskRecord inTask, String reason,
               boolean allowPendingRemoteAnimationRegistryLookup) {
           ...
   		//跳轉startActivity
            final ActivityRecord[] outRecord = new ActivityRecord[1];
        	int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
                   voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
                   callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
                   ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
                   allowPendingRemoteAnimationRegistryLookup);
   }
   
   //記錄啓動進程和activity的信息
   private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
           String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
           IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
           IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
           String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
           SafeActivityOptions options,
           boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
           TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup) {
       ...
       //獲得Launcher進程    
       ProcessRecord callerApp = null;
       if (caller != null) {
           callerApp = mService.getRecordForAppLocked(caller);
           ...
       }
       ...
       //記錄獲得的activity信息
       ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
               callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
               resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
               mSupervisor, checkedOptions, sourceRecord);
       if (outActivity != null) {
           outActivity[0] = r;
       }
       ...
       mController.doPendingActivityLaunches(false);
   	//繼續跳轉
       return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
               true /* doResume */, checkedOptions, inTask, outActivity);
   }
   
   //跳轉startActivityUnchecked
   private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
               IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
               int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
               ActivityRecord[] outActivity) {
       int result = START_CANCELED;
       try {
           mService.mWindowManager.deferSurfaceLayout();
           //跳轉
           result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
                   startFlags, doResume, options, inTask, outActivity);
       } 
       ...
       return result;
   }
   
   //主要作與棧相關的邏輯處理，並跳轉到ActivityStackSupervisor進行處理
   private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
           IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
           int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
           ActivityRecord[] outActivity) {
       ...
       int result = START_SUCCESS;
       //這裏和咱們最初在Launcher設置的標誌FLAG_ACTIVITY_NEW_TASK相關，會建立一個新棧
       if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
               && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
           newTask = true;
           result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
       }
       ...
       if (mDoResume) {
           final ActivityRecord topTaskActivity =
               mStartActivity.getTask().topRunningActivityLocked();
           if (!mTargetStack.isFocusable()
               || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                   && mStartActivity != topTaskActivity)) {
               ...
           } else {
               if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) {
                   mTargetStack.moveToFront("startActivityUnchecked");
               }
               //跳轉到ActivityStackSupervisor進行處理
               mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                                                               mOptions);
           }
       }
   }

3. ActivityStackSupervisor主要負責作activity棧的相關工做，會結合ActivityStack來進行工做。主要判斷activity的狀態，是否處於棧頂或處於中止狀態等

   /frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java/;
   
   boolean resumeFocusedStackTopActivityLocked(
           ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
   	...
       //判斷要啓動的activity是否是出於中止狀態或者Resume狀態
       final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
       if (r == null || !r.isState(RESUMED)) {
           mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
       } else if (r.isState(RESUMED)) {
           // Kick off any lingering app transitions form the MoveTaskToFront operation.
           mFocusedStack.executeAppTransition(targetOptions);
       }
       return false;
   }

4. ActivityStack主要處理activity在棧中的狀態

   /frameworks/base/services/core/java/com/android/server/am/ActivityStack.java/;
   //跳轉resumeTopActivityInnerLocked
   boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
       if (mStackSupervisor.inResumeTopActivity) {
           // Don't even start recursing.
           return false;
       }
       boolean result = false;
       try {
           // Protect against recursion.
           mStackSupervisor.inResumeTopActivity = true;
           //跳轉resumeTopActivityInnerLocked
           result = resumeTopActivityInnerLocked(prev, options);
   	...
       } finally {
           mStackSupervisor.inResumeTopActivity = false;
       }
       return result;
   }
   
   //跳轉到StackSupervisor.startSpecificActivityLocked，註釋1
   @GuardedBy("mService")
   private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
       ...
       if (next.app != null && next.app.thread != null) {
           ...
       } else {
           ...
           mStackSupervisor.startSpecificActivityLocked(next, true, true);//1
       }     
       if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked();
       return true;
   }

5. 這裏又回到了ActivityStackSupervisor，判斷進程是否已經建立，未建立拋出異常。而後建立事務交回給本地執行。這裏的事務很關鍵，Activity執行的工做就是這個事務，事務的內容是裏面的item，因此要注意下面的兩個item。

   /frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java/;
   
   void startSpecificActivityLocked(ActivityRecord r,
           boolean andResume, boolean checkConfig) {
       //獲得即將啓動的activity所在的進程
       ProcessRecord app = mService.getProcessRecordLocked(r.processName,
               r.info.applicationInfo.uid, true);
       getLaunchTimeTracker().setLaunchTime(r);
   
       //判斷該進程是否已經啓動,跳轉realStartActivityLocked，真正啓動活動
       if (app != null && app.thread != null) {
           try {
               if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
                       || !"android".equals(r.info.packageName)) {
                   app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,
                           mService.mProcessStats);
               }
               realStartActivityLocked(r, app, andResume, checkConfig);//1
               return;
           } 
           ...
       }
       mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
               "activity", r.intent.getComponent(), false, false, true);
   }
   
   
   //主要建立事務交給本地執行
   final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
       boolean andResume, boolean checkConfig) throws RemoteException {
       ...
       //建立啓動activity的事務ClientTransaction對象
       // Create activity launch transaction.
       final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
               r.appToken);
       // 添加LaunchActivityItem，該item的內容是建立activity
       clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
               System.identityHashCode(r), r.info,
               // TODO: Have this take the merged configuration instead of separate global
               // and override configs.
               mergedConfiguration.getGlobalConfiguration(),
               mergedConfiguration.getOverrideConfiguration(), r.compat,
               r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle,
               r.persistentState, results, newIntents, mService.isNextTransitionForward(),
               profilerInfo));
   
       // Set desired final state.
       //添加執行Resume事務ResumeActivityItem,後續會在本地被執行
       final ActivityLifecycleItem lifecycleItem;
       if (andResume) {
           lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
       } else {
           lifecycleItem = PauseActivityItem.obtain();
       }
       clientTransaction.setLifecycleStateRequest(lifecycleItem);
   
       // 經過ClientLifecycleManager來啓動事務
       // 這裏的mService就是AMS
       // 記住上面兩個item：LaunchActivityItem和ResumeActivityItem，這是事務的執行單位
       // Schedule transaction.
       mService.getLifecycleManager().scheduleTransaction(clientTransaction);
   }

   經過AMS獲取ClientLifecycleManager

   /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java/;
   //經過AMS獲取ClientLifecycleManager
   ClientLifecycleManager getLifecycleManager() {
   return mLifecycleManager;
   }

6. ClientLifecycleManager是事務管理類，負責執行事務

   /frameworks/base/services/core/java/com/android/server/am/ClientLifecycleManager.java
   void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
       final IApplicationThread client = transaction.getClient();
       //執行事務
       transaction.schedule();
       if (!(client instanceof Binder)) {
           transaction.recycle();
       }
   }

7. 把事務交給本地ActivityThread執行。這裏經過本地ApplicationThread在服務端的接口IApplicationThread來進行跨進程通訊。後面的邏輯就回到了應用程序進程了。

   /frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java/;
   
   //這裏的IApplicationThread是要啓動進程的IBinder接口
   //ApplicationThread是ActivityThread的內部類，IApplicationThread是IBinder代理接口
   //這裏將邏輯轉到本地來執行
   private IApplicationThread mClient;
   public void schedule() throws RemoteException {
       mClient.scheduleTransaction(this);
   }

ActivityThread建立Activity的過程

流程圖

源碼

1. IApplicationThread接口的本地實現類ActivityThread的內部類ApplicationThread

   /frameworks/base/core/java/android/app/ActivityThread.java/ApplicationThread.class/;
   //跳轉到ActivityThread的方法實現
   public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
       ActivityThread.this.scheduleTransaction(transaction);
   }

2. ActivityThread執行事務。ActivityThread是繼承ClientTransactionHandler，scheduleTransaction的具體實現是在ClientTransactionHandler實現的。這裏的主要內容是把事務發送給ActivityThread的內部類H去執行。H是一個Handle，經過這個Handle來切到主線程執行邏輯。

   /frameworks/base/core/java/android/app/ClientTransactionHandler.java
   void scheduleTransaction(ClientTransaction transaction) {
       //事務預處理
       transaction.preExecute(this);
       //這裏很明顯能夠利用Handle機制切換線程，下面看看這個方法的實現
       //該方法的具體實現是在ActivityThread，是ClientTransactionHandler的抽象方法
       sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
   }
   
   /frameworks/base/core/java/android/app/ActivityThread.java/;
   final H mH = new H();
   private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
       if (DEBUG_MESSAGES) Slog.v(
           TAG, "SCHEDULE " + what + " " + mH.codeToString(what)
           + ": " + arg1 + " / " + obj);
       Message msg = Message.obtain();
       msg.what = what;
       msg.obj = obj;
       msg.arg1 = arg1;
       msg.arg2 = arg2;
       if (async) {
           msg.setAsynchronous(true);
       }
       //利用Handle進行切換。mH是H這個類的實例
       mH.sendMessage(msg);
   }

3. H對事務進行處理。調用事務池來處理事務

   /frameworks/base/core/java/android/app/ActivityThread.java/H.class
   //調用事務池對事務進行處理
   public void handleMessage(Message msg) {
       if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
       switch (msg.what) {
           ...
           case EXECUTE_TRANSACTION:
               final ClientTransaction transaction = (ClientTransaction) msg.obj;
               //調用事務池對事務進行處理
               mTransactionExecutor.execute(transaction);
               if (isSystem()) {
                   transaction.recycle();
               }
               // TODO(lifecycler): Recycle locally scheduled transactions.
               break;
               ...
       }
       ...
   }

4. 事務池對事務進行處理。事務池會把事務中的兩個item拿出來分別執行。這兩個事務就是上面我講的兩個Item。對應不一樣的初始化工做。

   /frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
       
   public void execute(ClientTransaction transaction) {
       final IBinder token = transaction.getActivityToken();
       log("Start resolving transaction for client: " + mTransactionHandler + ", token: " + token);
   
       //執行事務
       //這兩個事務就是當時在ActivityStackSupervisor中添加的兩個事件（第8步）
       //註釋1執行activity的建立，註釋2執行activity的窗口等等並調用onStart和onResume方法
       //後面主要深刻註釋1的流程
       executeCallbacks(transaction);//1
       executeLifecycleState(transaction);//2
       mPendingActions.clear();
       log("End resolving transaction");
   }
   
   public void executeCallbacks(ClientTransaction transaction) {
       ...
           //執行事務
           //這裏的item就是當初添加的Item，還記得是哪一個嗎？
          	// 對了就是LaunchActivityItem
           item.execute(mTransactionHandler, token, mPendingActions);
           item.postExecute(mTransactionHandler, token, mPendingActions);
       ...
   }
   
   private void executeLifecycleState(ClientTransaction transaction) {
       ...
       // 和上面的同樣，執行事務中的item，item類型是ResumeActivityItem
       lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
       lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
   }

5. LaunchActivityItem調用ActivityThread執行建立邏輯。

   /frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java/;
   
   public void execute(ClientTransactionHandler client, IBinder token,
           PendingTransactionActions pendingActions) {
       Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
       ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
               mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
               mPendingResults, mPendingNewIntents, mIsForward,
               mProfilerInfo, client);
       // ClientTransactionHandler是ActivityThread實現的接口，具體邏輯回到ActivityThread
       client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
       Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
   }

6. ActivityThread執行Activity的建立。主要利用Instrumentation來建立activity和回調activity的生命週期，並建立activity的上下文和app上下文（若是還沒建立的話）。

   /frameworks/base/core/java/android/app/ActivityThread.java/;
   
   public Activity handleLaunchActivity(ActivityClientRecord r,
           PendingTransactionActions pendingActions, Intent customIntent) {
       ...
           // 跳轉到performLaunchActivity
           final Activity a = performLaunchActivity(r, customIntent);
       ...
   }
   
   //使用Instrumentation去建立activity回調生命週期
   private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
       	//獲取ActivityInfo，用戶存儲代碼、AndroidManifes信息。
       	ActivityInfo aInfo = r.activityInfo;
           if (r.packageInfo == null) {
               //獲取apk描述類
               r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
                       Context.CONTEXT_INCLUDE_CODE);
           }
       
       	// 獲取activity的包名類型信息
       	ComponentName component = r.intent.getComponent();
           if (component == null) {
               component = r.intent.resolveActivity(
                   mInitialApplication.getPackageManager());
               r.intent.setComponent(component);
           }
       ...
           // 建立context上下文
           ContextImpl appContext = createBaseContextForActivity(r);
      		// 建立activity
           Activity activity = null;
           try {
               java.lang.ClassLoader cl = appContext.getClassLoader();
               // 經過Instrumentation來建立活動
               activity = mInstrumentation.newActivity(
                       cl, component.getClassName(), r.intent);
               StrictMode.incrementExpectedActivityCount(activity.getClass());
               r.intent.setExtrasClassLoader(cl);
               r.intent.prepareToEnterProcess();
               if (r.state != null) {
                   r.state.setClassLoader(cl);
               }
           }
       ...
           try {
               // 根據包名建立Application，若是已經建立則不會重複建立
               Application app = r.packageInfo.makeApplication(false, mInstrumentation);
               ...
               // 爲Activity添加window
               Window window = null;
               if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
                   window = r.mPendingRemoveWindow;
                   r.mPendingRemoveWindow = null;
                   r.mPendingRemoveWindowManager = null;
               }
               appContext.setOuterContext(activity);
               activity.attach(appContext, this, getInstrumentation(), r.token,
                       r.ident, app, r.intent, r.activityInfo, title, r.parent,
                       r.embeddedID, r.lastNonConfigurationInstances, config,
                       r.referrer, r.voiceInteractor, window, r.configCallback);
               }
   	...
           // 經過Instrumentation回調Activity的onCreate方法
           ctivity.mCalled = false;
           if (r.isPersistable()) {
               mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
           } else {
               mInstrumentation.callActivityOnCreate(activity, r.state);
           }
   }

   這裏深刻來看一下onCreate何時被調用

   /frameworks/base/core/java/android/app/Instrumentation.java/;
   public void callActivityOnCreate(Activity activity, Bundle icicle,
     PersistableBundle persistentState) {
   prePerformCreate(activity);
   // 調用了activity的performCreate方法
   activity.performCreate(icicle, persistentState);
   postPerformCreate(activity);
   }
   
   /frameworks/base/core/java/android/app/Activity.java/;
   final void performCreate(Bundle icicle, PersistableBundle persistentState) {
   mCanEnterPictureInPicture = true;
   restoreHasCurrentPermissionRequest(icicle);
   // 這裏就回調了onCreate方法了
   if (persistentState != null) {
     onCreate(icicle, persistentState);
   } else {
     onCreate(icicle);
   }
   ...
   }

7. Instrumentation經過類加載器來建立activity實例

   /frameworks/base/core/java/android/app/Instrumentation.java/;
   
   public Activity newActivity(ClassLoader cl, String className,
           Intent intent)
           throws InstantiationException, IllegalAccessException,
           ClassNotFoundException {
       String pkg = intent != null && intent.getComponent() != null
               ? intent.getComponent().getPackageName() : null;
       // 利用AppComponentFactory進行實例化
       return getFactory(pkg).instantiateActivity(cl, className, intent);
   }

8. 最後一步，經過AppComponentFactory工廠來建立實例。

   /frameworks/support/compat/src/main/java/androidx/core/app/AppComponentFactory.java
   //其實就至關於直接返回instantiateActivityCompat
   public final Activity instantiateActivity(ClassLoader cl, String className, Intent intent)
       throws InstantiationException, IllegalAccessException, ClassNotFoundException {
       return checkCompatWrapper(instantiateActivityCompat(cl, className, intent));
   }
       
   //泛型方法
   static <T> T checkCompatWrapper(T obj) {
           if (obj instanceof CompatWrapped) {
               T wrapper = (T) ((CompatWrapped) obj).getWrapper();
               if (wrapper != null) {
                   return wrapper;
               }
           }
           return obj;
       }  
   //終於到了盡頭了。利用類加載器來進行實例化。到此activity的啓動就告一段落了。
   public @NonNull Activity instantiateActivityCompat(@NonNull ClassLoader cl,
           @NonNull String className, @Nullable Intent intent)
           throws InstantiationException, IllegalAccessException, ClassNotFoundException {
       try {
           return (Activity) cl.loadClass(className).getDeclaredConstructor().newInstance();
       } catch (InvocationTargetException | NoSuchMethodException e) {
           throw new RuntimeException("Couldn't call constructor", e);
       }
   }

小結

上文經過總體流程和代碼詳解解析了一個activity啓動時的總體流程。不知道讀者們會不會有個疑問：瞭解這些有什麼用呢？平常又用不到。當走完這整個流程的時候，你會發現你對於android又深刻了解了不少了，面對開發的時候，心裏也會更加有自信心，出現的一些bug，可能別人要解決很久，而你，很快就能夠解決。另外，這一部份內容在插件化也有很大的使用，也是學習插件化必學的知識。

好了講了這麼多，但願以上對你有幫助。有疑問能夠評論區或者私信交流一下。另外，博主屬於android新手，若有不對之處還望指正。

參考文獻

• 《Android進階解密》
• 《Android開發藝術探索》
• Android進階（四）：Activity啓動過程(最詳細&最簡單)