Activity的啟動(dòng)主要包括以下幾個(gè)步驟:

1. 應(yīng)用通過(guò)startActivity或是startActivityForResult方法向ActivityManagerService發(fā)出啟動(dòng)請(qǐng)求浸卦。
2. ActivityManagerService接收到啟動(dòng)請(qǐng)求后，解析啟動(dòng)的Activity信息以及啟動(dòng)模式，為正式啟動(dòng)做準(zhǔn)備工作。
3. ActivityManagerService做完準(zhǔn)備工作之后彭雾，判斷棧頂是否為空，如果不為空竹伸，即當(dāng)前有Activity顯示在前臺(tái)辫樱，則先會(huì)請(qǐng)求對(duì)棧頂 Activity進(jìn)行onPause操作。
4. 棧頂Activity執(zhí)行onPause操作匹摇。
5. 棧頂Activity執(zhí)行onPause操作結(jié)束咬扇，通知ActivityManagerService onPause完成。
6. 為啟動(dòng)Activity創(chuàng)建新進(jìn)程廊勃。
7. Activity所在應(yīng)用進(jìn)程和主線(xiàn)程初始化完成之后創(chuàng)建Application懈贺。
8. 繼續(xù)啟動(dòng)Activity。

時(shí)序圖

用戶(hù)調(diào)用startActivity或startActivityForResult

//frameworks/base/core/java/android/app/Activity.java
5533    @Override
5534    public void startActivity(Intent intent, @Nullable Bundle options) {
5535        if (options != null) {
5536            startActivityForResult(intent, -1, options);
5537        } else {
5538            // Note we want to go through this call for compatibility with
5539            // applications that may have overridden the method.
5540            startActivityForResult(intent, -1);
5541        }
5542    }

//frameworks/base/core/java/android/app/Activity.java
5901    @Override
5902    @UnsupportedAppUsage
5903    public void startActivityForResult(
5904            String who, Intent intent, int requestCode, @Nullable Bundle options) {
5905        Uri referrer = onProvideReferrer();
5906        if (referrer != null) {
5907            intent.putExtra(Intent.EXTRA_REFERRER, referrer);
5908        }
5909        options = transferSpringboardActivityOptions(options);
5910        Instrumentation.ActivityResult ar =
5911            mInstrumentation.execStartActivity(
5912                this, mMainThread.getApplicationThread(), mToken, who,
5913                intent, requestCode, options);
5914        if (ar != null) {
5915            mMainThread.sendActivityResult(
5916                mToken, who, requestCode,
5917                ar.getResultCode(), ar.getResultData());
5918        }
5919        cancelInputsAndStartExitTransition(options);
5920    }

execStartActivity里面我們需要注意兩個(gè)參數(shù)坡垫。mMainThread.getApplicationThread()會(huì)返回一個(gè)ApplicationThread類(lèi)型的變量梭灿。這個(gè)變量我們?cè)谏弦徽乱呀?jīng)介紹過(guò)了，這里ApplicationThread代表的是發(fā)起請(qǐng)求的APP1冰悠，后面AMS和APP1就通過(guò)它來(lái)進(jìn)行跨進(jìn)程通信堡妒，步驟2 AMS中止APP1，AMS就是根據(jù)這個(gè)參數(shù)找到APP1的溉卓。mToken我們?cè)谏弦徽轮幸步榻B過(guò)了皮迟，它是連接ActivityRecord，ActivityClientRecord桑寨，activity的橋梁伏尼，AMS通過(guò)它就可以獲取APP1的詳細(xì)信息了。

//frameworks/base/core/java/android/app/Instrumentation.java
1677    @UnsupportedAppUsage
1678    public ActivityResult execStartActivity(
1679            Context who, IBinder contextThread, IBinder token, Activity target,
1680            Intent intent, int requestCode, Bundle options) {
        ........
1711            int result = ActivityTaskManager.getService()
1712                .startActivity(whoThread, who.getBasePackageName(), intent,
1713                        intent.resolveTypeIfNeeded(who.getContentResolver()),
1714                        token, target != null ? target.mEmbeddedID : null,
1715                        requestCode, 0, null, options);
        ........

startActivity會(huì)進(jìn)行一次binder調(diào)用尉尾，ActivityTaskManagerService之前講過(guò)是用來(lái)分擔(dān)ActivityManagerService的一些功能的爆阶。這個(gè)地方開(kāi)始就從當(dāng)前應(yīng)用APP1跳轉(zhuǎn)到了AMS，通知AMS要啟動(dòng)APP2沙咏。

//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
1008    @Override
1009    public final int startActivity(IApplicationThread caller, String callingPackage,
1010            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
1011            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) {
1012        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
1013                resultWho, requestCode, startFlags, profilerInfo, bOptions,
1014                UserHandle.getCallingUserId());
1015    }

APP1要求啟動(dòng)APP2辨图，我們需要記錄幾個(gè)關(guān)鍵的參數(shù)，
caller:誰(shuí)發(fā)起了這次啟動(dòng)請(qǐng)求芭碍，
intent:被啟動(dòng)activity APP2的信息徒役，
resultTo:發(fā)起啟動(dòng)要求的APP1的信息孽尽。
這樣誰(shuí)要求啟動(dòng)誰(shuí)這個(gè)請(qǐng)求就很清晰的傳遞給了AMS窖壕。

//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
1031    @Override
1032    public int startActivityAsUser(IApplicationThread caller, String callingPackage,
1033            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
1034            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
1035        return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
1036                resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
1037                true /*validateIncomingUser*/);
1038    }
1039
1040    int startActivityAsUser(IApplicationThread caller, String callingPackage,
1041            Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
1042            int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId,
1043            boolean validateIncomingUser) {
1044        enforceNotIsolatedCaller("startActivityAsUser");
1045
1046        userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
1047                Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
1048
1049        // TODO: Switch to user app stacks here.
1050        return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
1051                .setCaller(caller)
1052                .setCallingPackage(callingPackage)
1053                .setResolvedType(resolvedType)
1054                .setResultTo(resultTo)
1055                .setResultWho(resultWho)
1056                .setRequestCode(requestCode)
1057                .setStartFlags(startFlags)
1058                .setProfilerInfo(profilerInfo)
1059                .setActivityOptions(bOptions)
1060                .setMayWait(userId)
1061                .execute();
1062
1063    }

首先獲取并初始化ActivityStater對(duì)象，然后調(diào)用它的execute方法。

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
511    int execute() {
512        try {
513            // TODO(b/64750076): Look into passing request directly to these methods to allow
514            // for transactional diffs and preprocessing.
515            if (mRequest.mayWait) {
516                return startActivityMayWait(mRequest.caller, mRequest.callingUid,
517                        mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid,
518                        mRequest.intent, mRequest.resolvedType,
519                        mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
520                        mRequest.resultWho, mRequest.requestCode, mRequest.startFlags,
521                        mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig,
522                        mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId,
523                        mRequest.inTask, mRequest.reason,
524                        mRequest.allowPendingRemoteAnimationRegistryLookup,
525                        mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
526            } else {
527                return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent,
528                        mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo,
529                        mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo,
530                        mRequest.resultWho, mRequest.requestCode, mRequest.callingPid,
531                        mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid,
532                        mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions,
533                        mRequest.ignoreTargetSecurity, mRequest.componentSpecified,
534                        mRequest.outActivity, mRequest.inTask, mRequest.reason,
535                        mRequest.allowPendingRemoteAnimationRegistryLookup,
536                        mRequest.originatingPendingIntent, mRequest.allowBackgroundActivityStart);
537            }
538        } finally {
539            onExecutionComplete();
540        }
541    }

接著調(diào)用startActivityMayWait瞻讽。

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
1144    private int startActivityMayWait(IApplicationThread caller, int callingUid,
1145            String callingPackage, int requestRealCallingPid, int requestRealCallingUid,
1146            Intent intent, String resolvedType, IVoiceInteractionSession voiceSession,
1147            IVoiceInteractor voiceInteractor, IBinder resultTo, String resultWho, int requestCode,
1148            int startFlags, ProfilerInfo profilerInfo, WaitResult outResult,
1149            Configuration globalConfig, SafeActivityOptions options, boolean ignoreTargetSecurity,
1150            int userId, TaskRecord inTask, String reason,
1151            boolean allowPendingRemoteAnimationRegistryLookup,
1152            PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
        ........  
            //PakageManagerService解析intent(APP2的intent)鸳吸，獲取Activity更多的信息
1194        ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId,
1195                0 /* matchFlags */,
1196                        computeResolveFilterUid(
1197                                callingUid, realCallingUid, mRequest.filterCallingUid));
        ........
1297            final ActivityRecord[] outRecord = new ActivityRecord[1];
1298            int res = startActivity(caller, intent, ephemeralIntent, resolvedType, aInfo, rInfo,
1299                    voiceSession, voiceInteractor, resultTo, resultWho, requestCode, callingPid,
1300                    callingUid, callingPackage, realCallingPid, realCallingUid, startFlags, options,
1301                    ignoreTargetSecurity, componentSpecified, outRecord, inTask, reason,
1302                    allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
        ........

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
568    private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
569            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
570            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
571            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
572            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
573            SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified,
574            ActivityRecord[] outActivity, TaskRecord inTask, String reason,
575            boolean allowPendingRemoteAnimationRegistryLookup,
576            PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
        ........
585        mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
586                aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
587                callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
588                options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
589                inTask, allowPendingRemoteAnimationRegistryLookup, originatingPendingIntent,
590                allowBackgroundActivityStart);
591
592        if (outActivity != null) {
593            // mLastStartActivityRecord[0] is set in the call to startActivity above.
594            outActivity[0] = mLastStartActivityRecord[0];
595        }
596
597        return getExternalResult(mLastStartActivityResult);
598    }

/frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
613    private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,
614            String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo,
615            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
616            IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid,
617            String callingPackage, int realCallingPid, int realCallingUid, int startFlags,
618            SafeActivityOptions options,
619            boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity,
620            TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup,
621            PendingIntentRecord originatingPendingIntent, boolean allowBackgroundActivityStart) {
        ........
629        if (caller != null) {
630            callerApp = mService.getProcessController(caller);
631            if (callerApp != null) {
                   //獲取調(diào)用者的pid和uid
632                callingPid = callerApp.getPid();
633                callingUid = callerApp.mInfo.uid;
        ........
           //sourceRecord表示發(fā)起本次請(qǐng)求的Activity,即父Activity對(duì)應(yīng)的信息
           //resultRecord表示接收處理結(jié)果的Activity。一般情況下二者相等
650        ActivityRecord sourceRecord = null;
651        ActivityRecord resultRecord = null;
652        if (resultTo != null) {
653            sourceRecord = mRootActivityContainer.isInAnyStack(resultTo);
654            if (DEBUG_RESULTS) Slog.v(TAG_RESULTS,
655                    "Will send result to " + resultTo + " " + sourceRecord);
656            if (sourceRecord != null) {
657                if (requestCode >= 0 && !sourceRecord.finishing) {
658                    resultRecord = sourceRecord;
659                }
660            }
661        }
        ........
           //創(chuàng)建ActivityRecord速勇，ActivityRecord用于保存Activity的信息晌砾，現(xiàn)在AMS已經(jīng)擁有了該Activity的實(shí)例，但他還沒(méi)有和TaskRecord關(guān)聯(lián)起來(lái)
901        ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid,
902                callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(),
903                resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null,
904                mSupervisor, checkedOptions, sourceRecord);
905        if (outActivity != null) {
906            outActivity[0] = r;
907        }
        .......
935        final int res = startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
936                true /* doResume */, checkedOptions, inTask, outActivity, restrictedBgActivity);
937        mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outActivity[0]);
938        return res;
939    }

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
1396    private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
1397                IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
1398                int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
1399                ActivityRecord[] outActivity, boolean restrictedBgActivity) {
1400        int result = START_CANCELED;
1401        final ActivityStack startedActivityStack;
1402        try {
1403            mService.mWindowManager.deferSurfaceLayout();
1404            result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
1405                    startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
        ........

startActivityUnchecked這個(gè)函數(shù)最重要的工作就是為我們剛剛創(chuàng)建好的ActivityRecord找到它對(duì)用的TaskRecord和ActivityStack烦磁。

//frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
1474    private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
1475            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
1476            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
1477            ActivityRecord[] outActivity, boolean restrictedBgActivity) {
        ........
1665        // Should this be considered a new task?
1666        int result = START_SUCCESS;
1667        if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
1668                && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
1669            newTask = true;
                //ActivityRecord和TaskRecord养匈，ActivityStack就是在這個(gè)函數(shù)建立聯(lián)系的，詳細(xì)過(guò)程可以參考上一篇博客
1670            result = setTaskFromReuseOrCreateNewTask(taskToAffiliate);
        ........
1728                mRootActivityContainer.resumeFocusedStacksTopActivities(
1729                        mTargetStack, mStartActivity, mOptions);
1730            }
1731        } else if (mStartActivity != null) {
1732            mSupervisor.mRecentTasks.add(mStartActivity.getTaskRecord());
1733        }
1734        mRootActivityContainer.updateUserStack(mStartActivity.mUserId, mTargetStack);
1735
1736        mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTaskRecord(),
1737                preferredWindowingMode, mPreferredDisplayId, mTargetStack);
1738
1739        return START_SUCCESS;
1740    }

//frameworks/base/services/core/java/com/android/server/wm/RootActivityContainer.java
1149    boolean resumeFocusedStacksTopActivities(
1150            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
1151
1152        if (!mStackSupervisor.readyToResume()) {
1153            return false;
1154        }
1155
1156        boolean result = false;
1157        if (targetStack != null && (targetStack.isTopStackOnDisplay()
1158                || getTopDisplayFocusedStack() == targetStack)) {
1159            result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
1160        }
        ........

//frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
2567    boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
2568        if (mInResumeTopActivity) {
2569            // Don't even start recursing.
2570            return false;
2571        }
2572
2573        boolean result = false;
2574        try {
2575            // Protect against recursion.
2576            mInResumeTopActivity = true;
2577            result = resumeTopActivityInnerLocked(prev, options);
2578
2579            // When resuming the top activity, it may be necessary to pause the top activity (for
2580            // example, returning to the lock screen. We suppress the normal pause logic in
2581            // {@link #resumeTopActivityUncheckedLocked}, since the top activity is resumed at the
2582            // end. We call the {@link ActivityStackSupervisor#checkReadyForSleepLocked} again here
2583            // to ensure any necessary pause logic occurs. In the case where the Activity will be
2584            // shown regardless of the lock screen, the call to
2585            // {@link ActivityStackSupervisor#checkReadyForSleepLocked} is skipped.
2586            final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
2587            if (next == null || !next.canTurnScreenOn()) {
2588                checkReadyForSleep();
2589            }
2590        } finally {
2591            mInResumeTopActivity = false;
2592        }
2593
2594        return result;
2595    }

//frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
2616    private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
2617        if (!mService.isBooting() && !mService.isBooted()) {
2618            // Not ready yet!
2619            return false;
2620        }
        ........
2747        if (mResumedActivity != null) {
2748            if (DEBUG_STATES) Slog.d(TAG_STATES,
2749                    "resumeTopActivityLocked: Pausing " + mResumedActivity);
                //中止當(dāng)前activity
2750            pausing |= startPausingLocked(userLeaving, false, next, false);
2751        }
        ........
                //繼續(xù)activity的啟動(dòng)
3039            mStackSupervisor.startSpecificActivityLocked(next, true, true);
3040        }
3041
3042        return true;
3043    }

如果當(dāng)前界面正在顯示一個(gè)Activity都伪，那么在啟動(dòng)新的Activity之前必須中斷當(dāng)前的Activity呕乎，中斷完成之后繼續(xù)調(diào)用startSpectificActivityLocked函數(shù)繼續(xù)啟動(dòng)activity。步驟1,2主要做的就是根據(jù)APP1啟動(dòng)APP2的請(qǐng)求陨晶，為APP1創(chuàng)建ActivityRecord猬仁，并為這個(gè)ActivityRecord找到找到它所屬的TaskRecord，ActivityStack,ActivityDisplay先誉。

接下來(lái)我們看下步驟3,4湿刽，`onPause`當(dāng)前Activity，我們還是先看下這一步驟的時(shí)序圖:

//frameworks/base/services/core/java/com/android/server/wm/ActivityStack.java
1653      final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
1654              ActivityRecord resuming, boolean pauseImmediately) {
          ........
//Android 9.0之后引入了ClientLifecycleManager和ClientTransactionHandler來(lái)輔助管理Activity的
//生命周期褐耳，它會(huì)發(fā)送EXECUTE_TRANSACTION消息到ActivityThread.H里面繼續(xù)執(zhí)行诈闺。這邊我們要注意傳入了
//一個(gè)參數(shù)PauseActivityItem
1698                  mService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
1699                          prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving,
1700                                  prev.configChangeFlags, pauseImmediately));
          ........

//frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
65      void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
66              @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
67          final ClientTransaction clientTransaction = transactionWithState(client, activityToken,
68                  stateRequest);
69          scheduleTransaction(clientTransaction);
70      }
 
 
45      void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
46          final IApplicationThread client = transaction.getClient();
47          transaction.schedule();
48          if (!(client instanceof Binder)) {
49              // If client is not an instance of Binder - it's a remote call and at this point it is
50              // safe to recycle the object. All objects used for local calls will be recycled after
51              // the transaction is executed on client in ActivityThread.
52              transaction.recycle();
53          }
54      }
 
//frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
134      public void schedule() throws RemoteException {
135          mClient.scheduleTransaction(this);
136      }
137

Client是一個(gè)IApplicationThread類(lèi)型。ActivityThread的內(nèi)部類(lèi)ApplicationThread派生這個(gè)接口類(lèi)并實(shí)現(xiàn)對(duì)應(yīng)的方法漱病。所以直接跳轉(zhuǎn)到ApplicationThread中的scheduleTransaction方法买雾。

//frameworks/base/core/java/android/app/ActivityThread.java
1665          public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
1666              ActivityThread.this.scheduleTransaction(transaction);
1667          }
1668  

接著調(diào)用它父類(lèi)ClientTransactionHandler的scheduleTransaction方法

//frameworks/base/core/java/android/app/ClientTransactionHandler.java
45      void scheduleTransaction(ClientTransaction transaction) {
46          transaction.preExecute(this);
47          sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
48      }
49 

在ClientTransactionHandler.scheduleTransaction方法中調(diào)用了sendMessage方法，這個(gè)方法是一個(gè)抽象方法杨帽，其實(shí)現(xiàn)在ClientTransactionHandler派生類(lèi)ActivityThread中漓穿。ActivityThread.sendMessage方法會(huì)把消息發(fā)送給內(nèi)部名字叫H的Handler。

//frameworks/base/core/java/android/app/ActivityThread.java
3106      void sendMessage(int what, Object obj) {
3107          sendMessage(what, obj, 0, 0, false);
3108      }
3109  
3110      private void sendMessage(int what, Object obj, int arg1) {
3111          sendMessage(what, obj, arg1, 0, false);
3112      }
3113  
3114      private void sendMessage(int what, Object obj, int arg1, int arg2) {
3115          sendMessage(what, obj, arg1, arg2, false);
3116      }
3117  
3118      private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
3119          if (DEBUG_MESSAGES) {
3120              Slog.v(TAG,
3121                      "SCHEDULE " + what + " " + mH.codeToString(what) + ": " + arg1 + " / " + obj);
3122          }
3123          Message msg = Message.obtain();
3124          msg.what = what;
3125          msg.obj = obj;
3126          msg.arg1 = arg1;
3127          msg.arg2 = arg2;
3128          if (async) {
3129              msg.setAsynchronous(true);
3130          }
3131          mH.sendMessage(msg);
3132      }
 
1853          public void handleMessage(Message msg) {
1854              if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
1855              switch (msg.what) {
          ........
2014                  case EXECUTE_TRANSACTION:
2015                      final ClientTransaction transaction = (ClientTransaction) msg.obj;
2016                      mTransactionExecutor.execute(transaction);
2017                      if (isSystem()) {
2018                          // Client transactions inside system process are recycled on the client side
2019                          // instead of ClientLifecycleManager to avoid being cleared before this
2020                          // message is handled.
2021                          transaction.recycle();
2022                      }
2023                      // TODO(lifecycler): Recycle locally scheduled transactions.
2024                      break;
          ........

Handler H的實(shí)例接收到EXECUTE_TRANSACTION消息后調(diào)用TransactionExecutor.execute切換Activity的狀態(tài)注盈。

//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
69      public void execute(ClientTransaction transaction) {
70          if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");
71  
72          final IBinder token = transaction.getActivityToken();
73          if (token != null) {
74              final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =
75                      mTransactionHandler.getActivitiesToBeDestroyed();
76              final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);
77              if (destroyItem != null) {
78                  if (transaction.getLifecycleStateRequest() == destroyItem) {
79                      // It is going to execute the transaction that will destroy activity with the
80                      // token, so the corresponding to-be-destroyed record can be removed.
81                      activitiesToBeDestroyed.remove(token);
82                  }
83                  if (mTransactionHandler.getActivityClient(token) == null) {
84                      // The activity has not been created but has been requested to destroy, so all
85                      // transactions for the token are just like being cancelled.
86                      Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
87                              + transactionToString(transaction, mTransactionHandler));
88                      return;
89                  }
90              }
91          }
92  
93          if (DEBUG_RESOLVER) Slog.d(TAG, transactionToString(transaction, mTransactionHandler));
94  
95          executeCallbacks(transaction);
96  
97          executeLifecycleState(transaction);
98          mPendingActions.clear();
99          if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
100      }

接下來(lái)我們關(guān)注executeLifecycleState函數(shù)晃危。

//frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
152      private void executeLifecycleState(ClientTransaction transaction) {
             //我們最開(kāi)始在ActivityStack.startPausingLocked方法里面scheduleTransaction
             //傳遞的是PauseActivityItem
153          final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
154          if (lifecycleItem == null) {
155              // No lifecycle request, return early.
156              return;
157          }
158  
159          final IBinder token = transaction.getActivityToken();
160          final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
161          if (DEBUG_RESOLVER) {
162              Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
163                      + lifecycleItem + " for activity: "
164                      + getShortActivityName(token, mTransactionHandler));
165          }
166  
167          if (r == null) {
168              // Ignore requests for non-existent client records for now.
169              return;
170          }
171  
172          // Cycle to the state right before the final requested state.
173          cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
174  
175          // Execute the final transition with proper parameters.
176          lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
             //調(diào)用PauseActivityItem.execute
177          lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
178      }

//frameworks/base/core/java/android/app/servertransaction/PauseActivityItem.java
43      public void execute(ClientTransactionHandler client, IBinder token,
44              PendingTransactionActions pendingActions) {
45          Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityPause");
46          client.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,
47                  "PAUSE_ACTIVITY_ITEM");
48          Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
49      }
50

在PauseActivityItem.execute方法中調(diào)用Activity.handlePauseActivity方法。

//frameworks/base/core/java/android/app/ActivityThread.java
4397      public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,
4398              int configChanges, PendingTransactionActions pendingActions, String reason) {
4399          ActivityClientRecord r = mActivities.get(token);
4400          if (r != null) {
4401              if (userLeaving) {
4402                  performUserLeavingActivity(r);
4403              }
4404  
4405              r.activity.mConfigChangeFlags |= configChanges;
4406              performPauseActivity(r, finished, reason, pendingActions);
4407  
4408              // Make sure any pending writes are now committed.
4409              if (r.isPreHoneycomb()) {
4410                  QueuedWork.waitToFinish();
4411              }
4412              mSomeActivitiesChanged = true;
4413          }
4414      }
 
4430      private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
4431              PendingTransactionActions pendingActions) {
4432          if (r.paused) {
4433              if (r.activity.mFinished) {
4434                  // If we are finishing, we won't call onResume() in certain cases.
4435                  // So here we likewise don't want to call onPause() if the activity
4436                  // isn't resumed.
4437                  return null;
4438              }
4439              RuntimeException e = new RuntimeException(
4440                      "Performing pause of activity that is not resumed: "
4441                      + r.intent.getComponent().toShortString());
4442              Slog.e(TAG, e.getMessage(), e);
4443          }
4444          if (finished) {
4445              r.activity.mFinished = true;
4446          }
4447  
4448          // Pre-Honeycomb apps always save their state before pausing
4449          final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();
4450          if (shouldSaveState) {
4451              callActivityOnSaveInstanceState(r);
4452          }
4453  
4454          performPauseActivityIfNeeded(r, reason);
          ........
 
4481      private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
4482          if (r.paused) {
4483              // You are already paused silly...
4484              return;
4485          }
4486  
4487          // Always reporting top resumed position loss when pausing an activity. If necessary, it
4488          // will be restored in performResumeActivity().
4489          reportTopResumedActivityChanged(r, false /* onTop */, "pausing");
4490  
4491          try {
4492              r.activity.mCalled = false;
4493              mInstrumentation.callActivityOnPause(r.activity);
4494              if (!r.activity.mCalled) {
4495                  throw new SuperNotCalledException("Activity " + safeToComponentShortString(r.intent)
4496                          + " did not call through to super.onPause()");
4497              }
4498          } catch (SuperNotCalledException e) {
4499              throw e;
4500          } catch (Exception e) {
4501              if (!mInstrumentation.onException(r.activity, e)) {
4502                  throw new RuntimeException("Unable to pause activity "
4503                          + safeToComponentShortString(r.intent) + ": " + e.toString(), e);
4504              }
4505          }
4506          r.setState(ON_PAUSE);
4507      }

繼調(diào)用Instrumentation老客。callActivityOnPause僚饭。

//frameworks/base/core/java/android/app/Instrumentation.java
1506      public void callActivityOnPause(Activity activity) {
1507          activity.performPause();
1508      }

在performPause方法中我們終于看到了熟悉的身影Activity生命周期的onPause方法，至此棧頂Activity的Pause流程全部結(jié)束胧砰。

//frameworks/base/core/java/android/app/Activity.java
7973      final void performPause() {
7974          dispatchActivityPrePaused();
7975          mDoReportFullyDrawn = false;
7976          mFragments.dispatchPause();
7977          mCalled = false;
7978          onPause();
7979          writeEventLog(LOG_AM_ON_PAUSE_CALLED, "performPause");
7980          mResumed = false;
7981          if (!mCalled && getApplicationInfo().targetSdkVersion
7982                  >= android.os.Build.VERSION_CODES.GINGERBREAD) {
7983              throw new SuperNotCalledException(
7984                      "Activity " + mComponent.toShortString() +
7985                      " did not call through to super.onPause()");
7986          }
7987          dispatchActivityPostPaused();
7988      }

我們繼續(xù)流程分析鳍鸵，步驟6為要啟動(dòng)的APP2創(chuàng)建Process。還是先把時(shí)序圖放上來(lái)尉间。

//frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
956      void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
957          // Is this activity's application already running?
958          final WindowProcessController wpc =
959                  mService.getProcessController(r.processName, r.info.applicationInfo.uid);
960  
961          boolean knownToBeDead = false;
962          if (wpc != null && wpc.hasThread()) {
963              try {
                     //如果進(jìn)程和線(xiàn)程存在偿乖，則直接調(diào)用realStartActivityLocked
964                  realStartActivityLocked(r, wpc, andResume, checkConfig);
965                  return;
966              } catch (RemoteException e) {
967                  Slog.w(TAG, "Exception when starting activity "
968                          + r.intent.getComponent().flattenToShortString(), e);
969              }
970  
971              // If a dead object exception was thrown -- fall through to
972              // restart the application.
973              knownToBeDead = true;
974          }
          ........
990              final Message msg = PooledLambda.obtainMessage(
991                      ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
992                      r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
993              mService.mH.sendMessage(msg);
994          } finally {
995              Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
996          }
997      }

ActivityManagerInternal的實(shí)現(xiàn)類(lèi)為ActivityManagerService.localService击罪。

//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
18400          public void startProcess(String processName, ApplicationInfo info,
18401                  boolean knownToBeDead, String hostingType, ComponentName hostingName) {
18402              try {
18403                  if (Trace.isTagEnabled(Trace.TRACE_TAG_ACTIVITY_MANAGER)) {
18404                      Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "startProcess:"
18405                              + processName);
18406                  }
18407                  synchronized (ActivityManagerService.this) {
18408                      startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
18409                              new HostingRecord(hostingType, hostingName),
18410                              false /* allowWhileBooting */, false /* isolated */,
18411                              true /* keepIfLarge */);
18412                  }
18413              } finally {
18414                  Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
18415              }
18416          }
 
3022      final ProcessRecord startProcessLocked(String processName,
3023              ApplicationInfo info, boolean knownToBeDead, int intentFlags,
3024              HostingRecord hostingRecord, boolean allowWhileBooting,
3025              boolean isolated, boolean keepIfLarge) {
3026          return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
3027                  hostingRecord, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
3028                  null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
3029                  null /* crashHandler */);
3030      }

startProcessLocked這個(gè)方法開(kāi)始準(zhǔn)備創(chuàng)建進(jìn)程，這個(gè)方法調(diào)用的是ProcessList的startProcessLocked方法贪薪。

1849      final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
1850              boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
1851              boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge,
1852              String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) {
          ........
1920          if (app == null) {
1921              checkSlow(startTime, "startProcess: creating new process record");
                  //創(chuàng)建ProcessRecord
1922              app = newProcessRecordLocked(info, processName, isolated, isolatedUid, hostingRecord);
          ........
1952          checkSlow(startTime, "startProcess: stepping in to startProcess");
1953          final boolean success = startProcessLocked(app, hostingRecord, abiOverride);
1954          checkSlow(startTime, "startProcess: done starting proc!");
1955          return success ? app : null;
1956      }
 
 
1842      final boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
1843              String abiOverride) {
1844          return startProcessLocked(app, hostingRecord,
1845                  false /* disableHiddenApiChecks */, false /* mountExtStorageFull */, abiOverride);
1846      }
 
1428      boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord,
1429              boolean disableHiddenApiChecks, boolean mountExtStorageFull,
1430              String abiOverride) {
          ........
1621              return startProcessLocked(hostingRecord, entryPoint, app, uid, gids,
1622                      runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith,
1623                      startTime);
1624          } catch (RuntimeException e) {
1625              Slog.e(ActivityManagerService.TAG, "Failure starting process " + app.processName, e);
1626  
1627              // Something went very wrong while trying to start this process; one
1628              // common case is when the package is frozen due to an active
1629              // upgrade. To recover, clean up any active bookkeeping related to
1630              // starting this process. (We already invoked this method once when
1631              // the package was initially frozen through KILL_APPLICATION_MSG, so
1632              // it doesn't hurt to use it again.)
1633              mService.forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid),
1634                      false, false, true, false, false, app.userId, "start failure");
1635              return false;
1636          }
1637      }
 
 
1640      boolean startProcessLocked(HostingRecord hostingRecord,
1641              String entryPoint,
1642              ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
1643              String seInfo, String requiredAbi, String instructionSet, String invokeWith,
1644              long startTime) {
          ........
1667                  try {
                          //注意這個(gè)參數(shù)final String entryPoint = "android.app.ActivityThread";
1668                      final Process.ProcessStartResult startResult = startProcess(app.hostingRecord,
1669                              entryPoint, app, app.startUid, gids, runtimeFlags, mountExternal,
1670                              app.seInfo, requiredAbi, instructionSet, invokeWith, app.startTime);
1671                      synchronized (mService) {
1672                          handleProcessStartedLocked(app, startResult, startSeq);
1673                      }
          ........

內(nèi)部經(jīng)過(guò)一系列startProcessLocked的調(diào)用會(huì)來(lái)到startProcess函數(shù)媳禁。我們需要注意其中

final String entryPoint = "android.app.ActivityThread";這個(gè)參數(shù)，這個(gè)參數(shù)會(huì)一路從Process傳遞到ZygoteProcess,并在ZygoteProcess中調(diào)用startViaZygote方法画切，fork出一個(gè)新的進(jìn)程竣稽。并根據(jù)傳遞的"android.app.ActivityThread"反射出該對(duì)象，于是進(jìn)程創(chuàng)建進(jìn)入到ActivityThread的main方法中霍弹。這一部分的具體流程我們會(huì)單獨(dú)在后面的博客中進(jìn)行講解毫别。

至此我們已經(jīng)創(chuàng)建好了進(jìn)程。當(dāng)Zygote創(chuàng)建完一個(gè)應(yīng)用進(jìn)程之后典格，得到的僅僅是一個(gè)可以運(yùn)行的載體拧烦，它還沒(méi)有和Android系統(tǒng)建立聯(lián)系，我們需要為它創(chuàng)建一個(gè)運(yùn)行環(huán)境Context钝计，然后在裝載Provider信息恋博，再將新創(chuàng)建的進(jìn)程綁定到AMS中，這才是一個(gè)完整的Android進(jìn)程私恬。這就是我們步驟7需要完成的操作债沮。

//frameworks/base/core/java/android/app/ActivityThread.java
7310      public static void main(String[] args) {
7311          Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
7312  
7313          // Install selective syscall interception
7314          AndroidOs.install();
7315  
7316          // CloseGuard defaults to true and can be quite spammy.  We
7317          // disable it here, but selectively enable it later (via
7318          // StrictMode) on debug builds, but using DropBox, not logs.
7319          CloseGuard.setEnabled(false);
7320  
7321          Environment.initForCurrentUser();
7322  
7323          // Make sure TrustedCertificateStore looks in the right place for CA certificates
7324          final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
7325          TrustedCertificateStore.setDefaultUserDirectory(configDir);
7326  
7327          Process.setArgV0("<pre-initialized>");
7328  
              //創(chuàng)建了主線(xiàn)程的Looper對(duì)象，并調(diào)用Looper.loop()方法啟動(dòng)Loop
7329          Looper.prepareMainLooper();
          ........
7342          ActivityThread thread = new ActivityThread();
7343          thread.attach(false, startSeq);
7344  
7345          if (sMainThreadHandler == null) {
7346              sMainThreadHandler = thread.getHandler();
7347          }
7348  
7349          if (false) {
7350              Looper.myLooper().setMessageLogging(new
7351                      LogPrinter(Log.DEBUG, "ActivityThread"));
7352          }
7353  
7354          // End of event ActivityThreadMain.
7355          Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
7356          Looper.loop();
7357  
7358          throw new RuntimeException("Main thread loop unexpectedly exited");
7359      }
 
7071      private void attach(boolean system, long startSeq) {
7072          sCurrentActivityThread = this;
7073          mSystemThread = system;
7074          if (!system) {
7075              android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
7076                                                      UserHandle.myUserId());
7077              RuntimeInit.setApplicationObject(mAppThread.asBinder());
7078              final IActivityManager mgr = ActivityManager.getService();
7079              try {
                      //這又是一個(gè)binder調(diào)用本鸣，它通過(guò)binder將ActivityThread中的IApplicationThread的實(shí)例傳遞給AMS疫衩，
                      //然后AMS就可以通過(guò)它與應(yīng)用程序進(jìn)行通信
7080                  mgr.attachApplication(mAppThread, startSeq);
          ........

//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
5175      public final void attachApplication(IApplicationThread thread, long startSeq) {
5176          synchronized (this) {
5177              int callingPid = Binder.getCallingPid();
5178              final int callingUid = Binder.getCallingUid();
5179              final long origId = Binder.clearCallingIdentity();
5180              attachApplicationLocked(thread, callingPid, callingUid, startSeq);
5181              Binder.restoreCallingIdentity(origId);
5182          }
5183      }
 
4762      private final boolean attachApplicationLocked(IApplicationThread thread,
4763              int pid, int callingUid, long startSeq) {
          ........
5058                  thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
5059                          null, null, null, testMode,
5060                          mBinderTransactionTrackingEnabled, enableTrackAllocation,
5061                          isRestrictedBackupMode || !normalMode, app.isPersistent(),
5062                          new Configuration(app.getWindowProcessController().getConfiguration()),
5063                          app.compat, getCommonServicesLocked(app.isolated),
5064                          mCoreSettingsObserver.getCoreSettingsLocked(),
5065                          buildSerial, autofillOptions, contentCaptureOptions);
          ........
                  //將thread傳給ProcessRecord.thread，可以理解為將應(yīng)用進(jìn)程與AMS建立起了綁定
5074              app.makeActive(thread, mProcessStats);

我們從應(yīng)用程序調(diào)用到AMS中又通過(guò)bindApplication調(diào)回到應(yīng)用程序荣德，它在AMS中最重要的事就是建立了應(yīng)用程序與AMS的聯(lián)系闷煤。之前我們Zygote fork的進(jìn)程并沒(méi)有包含任何與Activity相關(guān)的 信息，甚至連進(jìn)程名都沒(méi)有真正命名涮瞻。此處的bindApplication就是初始化這個(gè)新進(jìn)程并創(chuàng)建對(duì)應(yīng)的Android環(huán)境鲤拿。

//frameworks/base/core/java/android/app/ActivityThread.java
996          public final void bindApplication(String processName, ApplicationInfo appInfo,
997                  List<ProviderInfo> providers, ComponentName instrumentationName,
998                  ProfilerInfo profilerInfo, Bundle instrumentationArgs,
999                  IInstrumentationWatcher instrumentationWatcher,
1000                  IUiAutomationConnection instrumentationUiConnection, int debugMode,
1001                  boolean enableBinderTracking, boolean trackAllocation,
1002                  boolean isRestrictedBackupMode, boolean persistent, Configuration config,
1003                  CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
1004                  String buildSerial, AutofillOptions autofillOptions,
1005                  ContentCaptureOptions contentCaptureOptions) {
          ........
1034              AppBindData data = new AppBindData();
1035              data.processName = processName;
1036              data.appInfo = appInfo;
1037              data.providers = providers;
1038              data.instrumentationName = instrumentationName;
1039              data.instrumentationArgs = instrumentationArgs;
1040              data.instrumentationWatcher = instrumentationWatcher;
1041              data.instrumentationUiAutomationConnection = instrumentationUiConnection;
1042              data.debugMode = debugMode;
1043              data.enableBinderTracking = enableBinderTracking;
1044              data.trackAllocation = trackAllocation;
1045              data.restrictedBackupMode = isRestrictedBackupMode;
1046              data.persistent = persistent;
1047              data.config = config;
1048              data.compatInfo = compatInfo;
1049              data.initProfilerInfo = profilerInfo;
1050              data.buildSerial = buildSerial;
1051              data.autofillOptions = autofillOptions;
1052              data.contentCaptureOptions = contentCaptureOptions;
1053              sendMessage(H.BIND_APPLICATION, data);
1054          }

ActivityThread的接口被AMS調(diào)用后，會(huì)將參數(shù)保存到AppBindData對(duì)象中署咽，然后發(fā)送消息BIND_APPLICATION讓ActivityThread的主線(xiàn)程處理近顷。

6122      private void handleBindApplication(AppBindData data) {
          ........
6154          // send up app name; do this *before* waiting for debugger
              //設(shè)置進(jìn)程名
6155          Process.setArgV0(data.processName);
          ........
6428          try {
6429              // If the app is being launched for full backup or restore, bring it up in
6430              // a restricted environment with the base application class.
6431              app = data.info.makeApplication(data.restrictedBackupMode, null);
          ........

//frameworks/base/core/java/android/app/LoadedApk.java
1194      public Application makeApplication(boolean forceDefaultAppClass,
1195              Instrumentation instrumentation) {
          ........
1217              ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
1218              app = mActivityThread.mInstrumentation.newApplication(
1219                      cl, appClass, appContext);
          ........
1232          if (instrumentation != null) {
1233              try {
1234                  instrumentation.callApplicationOnCreate(app);
1235              } catch (Exception e) {
1236                  if (!instrumentation.onException(app, e)) {
1237                      Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
1238                      throw new RuntimeException(
1239                          "Unable to create application " + app.getClass().getName()
1240                          + ": " + e.toString(), e);
1241                  }
1242              }
1243          }
          ........

data.info.makeApplication方法，在創(chuàng)建Application的過(guò)程中宁否，接著調(diào)用Instrumentation的newApplication方法窒升。

//frameworks/base/core/java/android/app/Instrumentation.java
1151      public Application newApplication(ClassLoader cl, String className, Context context)
1152              throws InstantiationException, IllegalAccessException,
1153              ClassNotFoundException {
1154          Application app = getFactory(context.getPackageName())
1155                  .instantiateApplication(cl, className);
1156          app.attach(context);
1157          return app;
1158      }

newApplication方法通過(guò)反射的方法創(chuàng)建Application。因?yàn)閍pp安裝的時(shí)候會(huì)去解析manifest中的內(nèi)容慕匠，因此查詢(xún)系統(tǒng)可以知道要啟動(dòng)的application的具體類(lèi)名饱须，然后通過(guò)類(lèi)名反射創(chuàng)建application。至此application創(chuàng)建完成台谊。

創(chuàng)建application之后蓉媳，通過(guò)Instrumentation的callApplicationOnCreate方法調(diào)用了創(chuàng)建Application對(duì)象的onCreate方法歹苦。

//frameworks/base/core/java/android/app/Instrumentation.java
1188      public void callApplicationOnCreate(Application app) {
1189          app.onCreate();
1190      }

終于走到應(yīng)用的Application的onCreate方法，這一步驟結(jié)束督怜。

application創(chuàng)建完成之后，繼續(xù)回到AMS中的attachApplicationLocked方法狠角，接著啟動(dòng)Activity的流程号杠。

//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
4762      private final boolean attachApplicationLocked(IApplicationThread thread,
4763              int pid, int callingUid, long startSeq) {
          ........
5101          if (normalMode) {
5102              try {
5103                  didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
5104              } catch (Exception e) {
5105                  Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
5106                  badApp = true;
5107              }
5108          }
          ........

mAtmInternal是ActivityTaskManagerService的內(nèi)部類(lèi)LocalService。在localService的attachApplication方法中調(diào)用了RootActivityContainer的attachApplication方法丰歌。

//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
6867          public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
6868              synchronized (mGlobalLockWithoutBoost) {
6869                  return mRootActivityContainer.attachApplication(wpc);
6870              }
6871          }
 
//frameworks/base/services/core/java/com/android/server/wm/RootActivityContainer.java
768      boolean attachApplication(WindowProcessController app) throws RemoteException {
          ........
if (activity.app == null && app.mUid == activity.info.applicationInfo.uid
781                              && processName.equals(activity.processName)) {
782                          try {
783                              if (mStackSupervisor.realStartActivityLocked(activity, app,
784                                      top == activity /* andResume */, true /* checkConfig */)) {
785                                  didSomething = true;
786                              }
787                          } catch (RemoteException e) {
788                              Slog.w(TAG, "Exception in new application when starting activity "
789                                      + top.intent.getComponent().flattenToShortString(), e);
790                              throw e;
791                          }
792                      }
          ........

在這我們看到了realStartActivityLocked姨蟋，這個(gè)方法之前在startSpecificActivityLocked方法中見(jiàn)到過(guò)，只是當(dāng)時(shí)我們還沒(méi)有創(chuàng)建好進(jìn)程所以沒(méi)有執(zhí)行立帖。

//frameworks/base/services/core/java/com/android/server/wm/ActivityStackSupervisor.java
705      boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
706              boolean andResume, boolean checkConfig) throws RemoteException {
          ........
827                  // Create activity launch transaction.
828                  final ClientTransaction clientTransaction = ClientTransaction.obtain(
829                          proc.getThread(), r.appToken);
830  
831                  final DisplayContent dc = r.getDisplay().mDisplayContent;
832                  clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
833                          System.identityHashCode(r), r.info,
834                          // TODO: Have this take the merged configuration instead of separate global
835                          // and override configs.
836                          mergedConfiguration.getGlobalConfiguration(),
837                          mergedConfiguration.getOverrideConfiguration(), r.compat,
838                          r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
839                          r.icicle, r.persistentState, results, newIntents,
840                          dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
841                                  r.assistToken));
842  
843                  // Set desired final state.
844                  final ActivityLifecycleItem lifecycleItem;
845                  if (andResume) {
846                      lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
847                  } else {
848                      lifecycleItem = PauseActivityItem.obtain();
849                  }
850                  clientTransaction.setLifecycleStateRequest(lifecycleItem);
851  
852                  // Schedule transaction.
853                  mService.getLifecycleManager().scheduleTransaction(clientTransaction);
          ........

新建了一個(gè)ClientTransaction對(duì)象后眼溶，設(shè)置LaunchActivityItem的callback，然后調(diào)用mService的getLifecycleManager獲取到ClientLifecycleManager晓勇，在通過(guò)scheduleTransaction發(fā)送請(qǐng)求堂飞。這和pause Activity的流程類(lèi)似，就是改變activity的生命周期绑咱。

//frameworks/base/services/core/java/com/android/server/wm/ClientLifecycleManager.java
45      void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
46          final IApplicationThread client = transaction.getClient();
47          transaction.schedule();
48          if (!(client instanceof Binder)) {
49              // If client is not an instance of Binder - it's a remote call and at this point it is
50              // safe to recycle the object. All objects used for local calls will be recycled after
51              // the transaction is executed on client in ActivityThread.
52              transaction.recycle();
53          }
54      }
 
//frameworks/base/core/java/android/app/servertransaction/ClientTransaction.java
134      public void schedule() throws RemoteException {
135          mClient.scheduleTransaction(this);
136      }
 
//frameworks/base/core/java/android/app/ActivityThread.java
1665          public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
1666              ActivityThread.this.scheduleTransaction(transaction);
1667          }
 
//frameworks/base/core/java/android/app/ClientTransactionHandler.java
45      void scheduleTransaction(ClientTransaction transaction) {
46          transaction.preExecute(this);
47          sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
48      }

這邊經(jīng)過(guò)了一圈調(diào)用就是向ActivityThread發(fā)送一個(gè)EXECUTE_TRANSACTION绰筛。

//frameworks/base/core/java/android/app/ActivityThread.java
1853          public void handleMessage(Message msg) {
          ........
2014                  case EXECUTE_TRANSACTION:
2015                      final ClientTransaction transaction = (ClientTransaction) msg.obj;
2016                      mTransactionExecutor.execute(transaction);
2017                      if (isSystem()) {
2018                          // Client transactions inside system process are recycled on the client side
2019                          // instead of ClientLifecycleManager to avoid being cleared before this
2020                          // message is handled.
2021                          transaction.recycle();
2022                      }
2023                      // TODO(lifecycler): Recycle locally scheduled transactions.
2024                      break;
          ........

和之前pause時(shí)候類(lèi)似，ClientTransaction的execute會(huì)調(diào)用LaunchActivityItem的execute描融。

//frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java
76      public void execute(ClientTransactionHandler client, IBinder token,
77              PendingTransactionActions pendingActions) {
78          Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
79          ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
80                  mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
81                  mPendingResults, mPendingNewIntents, mIsForward,
82                  mProfilerInfo, client, mAssistToken);
83          client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
84          Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
85      }

此處的client是一個(gè)ActivityThread對(duì)象铝噩，因此這里調(diào)用的ActivityThread的handleLaunchActivity。

//frameworks/base/core/java/android/app/ActivityThread.java
3381      public Activity handleLaunchActivity(ActivityClientRecord r,
3382              PendingTransactionActions pendingActions, Intent customIntent) {
          ........
3409          final Activity a = performLaunchActivity(r, customIntent);
          ........
 
3159      private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
          ........
3178          ContextImpl appContext = createBaseContextForActivity(r);
3179          Activity activity = null;
3180          try {
3181              java.lang.ClassLoader cl = appContext.getClassLoader();
3182              activity = mInstrumentation.newActivity(
3183                      cl, component.getClassName(), r.intent);
3184              StrictMode.incrementExpectedActivityCount(activity.getClass());
3185              r.intent.setExtrasClassLoader(cl);
3186              r.intent.prepareToEnterProcess();
3187              if (r.state != null) {
3188                  r.state.setClassLoader(cl);
3189              }
          ........
3224                  activity.attach(appContext, this, getInstrumentation(), r.token,
3225                          r.ident, app, r.intent, r.activityInfo, title, r.parent,
3226                          r.embeddedID, r.lastNonConfigurationInstances, config,
3227                          r.referrer, r.voiceInteractor, window, r.configCallback,
3228                          r.assistToken);
          ........
3242                  if (r.isPersistable()) {
3243                      mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
3244                  } else {
3245                      mInstrumentation.callActivityOnCreate(activity, r.state);
3246                  }
          ........

performLaunchActivity中通過(guò)mInstrumentation的newActivity方法創(chuàng)建了一個(gè)activity窿克。activity就保存了上下文信息骏庸。然后通過(guò)attach將activity和ActivityThread，Instrumentation年叮，Application等重要的類(lèi)聯(lián)系起來(lái)具被。這一方法對(duì)Activity的ComponentName，ContextImpl只损，Activity以及Application對(duì)象進(jìn)行了初始化并相互關(guān)聯(lián)硬猫。最后調(diào)用callActivityOnCreate。

//frameworks/base/core/java/android/app/Instrumentation.java
1304      public void callActivityOnCreate(Activity activity, Bundle icicle) {
1305          prePerformCreate(activity);
1306          activity.performCreate(icicle);
1307          postPerformCreate(activity);
1308      }
1309  
 
 
//frameworks/base/core/java/android/app/Activity.java
 
7794      @UnsupportedAppUsage
7795      final void performCreate(Bundle icicle, PersistableBundle persistentState) {
7796          dispatchActivityPreCreated(icicle);
7797          mCanEnterPictureInPicture = true;
7798          restoreHasCurrentPermissionRequest(icicle);
7799          if (persistentState != null) {
7800              onCreate(icicle, persistentState);
7801          } else {
7802              onCreate(icicle);
7803          }
7804          writeEventLog(LOG_AM_ON_CREATE_CALLED, "performCreate");
7805          mActivityTransitionState.readState(icicle);
7806  
7807          mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
7808                  com.android.internal.R.styleable.Window_windowNoDisplay, false);
7809          mFragments.dispatchActivityCreated();
7810          mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
7811          dispatchActivityPostCreated(icicle);
7812      }

在performCreate中調(diào)用了activity的onCreate改执，Activity創(chuàng)建完成啸蜜。在Activity對(duì)象構(gòu)建成功，并成功走完onCreate辈挂，onStart兩個(gè)生命周期函數(shù)之后衬横，便要進(jìn)入onResume這個(gè)生命周期函數(shù)，至此完成Activity全部的啟動(dòng)操作终蒂。Activity的啟動(dòng)流程太過(guò)復(fù)雜蜂林，所以本篇博客只是總結(jié)了啟動(dòng)的大致流程遥诉，其中有很多細(xì)節(jié)并沒(méi)有深入描寫(xiě)。其中一些重要的細(xì)節(jié)噪叙，會(huì)在后續(xù)的博客中詳細(xì)分析矮锈。

基于Android Q的版本

• Activity.startActivity(有幾個(gè)重載方法)
• Activity.startActivityForResult
• Instrumentation.execStartActivity
• ActivityTaskManager.getService().startActivity
  即 IActivityTaskManagerSingleton.get().startActivity
  即 IActivityTaskManager.startActivity
  (aidl實(shí)現(xiàn)binder跨進(jìn)程通訊，通訊的客戶(hù)端睁蕾，以上部分在應(yīng)用進(jìn)程）
• ActivityTaskManagerService.startActivity
  (ActivityTaskManagerService 繼承 IActivityTaskManager.Stub苞笨，實(shí)現(xiàn)了中的startActivity startActivities startActivityAsUser等方法，是跨進(jìn)程通訊的服務(wù)端子眶，這部分在系統(tǒng)進(jìn)程)
• ActivityTaskManagerService.startActivityAsUser
• ActivityStarter.execute
• ActivityStarter.startActivityMayWait
• ActivityStarter.startActivity(有幾個(gè)重載方法)
• ActivityStarter.startActivityUnchecked
• ActivityStack.ensureActivitiesVisibleLocked(有幾個(gè)重載方法)
• ActivityRecord.makeClientVisible
• ActivityRecord.makeActiveIfNeeded
• ActivityStack.resumeTopActivityUncheckedLocked
• ActivityStack.resumeTopActivityInnerLocked
• ActivityStackSupervisor.startSpecificActivityLocked
• ActivityStackSupervisor.realStartActivityLocked
• mService.getLifecycleManager().scheduleTransaction(clientTransaction)
  即 ClientLifecycleManager.scheduleTransaction
• ClientTransaction.schedule
  (ClientTransaction中的mActivityCallbacks就是LaunchActivityItem)
• mClient.scheduleTransaction()
  即 IApplicationThread.scheduleTransaction
  (這里也是使用aidl通過(guò)binder通訊瀑凝，這是通訊的客戶(hù)端，這部分在系統(tǒng)進(jìn)程)
• ApplicationThread.scheduleTransaction
  (注：1.ApplicationThread是ActivityThread的內(nèi)部類(lèi))
  (注：2.ApplicationThread 繼承了 IApplicationThread.Stub臭杰，實(shí)現(xiàn)了scheduleTransaction等方法粤咪，跨進(jìn)程通訊的服務(wù)端，這部分在應(yīng)用進(jìn)程)
• ActivityThread.scheduleTransaction
• ClientTransactionHandler.scheduleTransaction
  (ActivityThread 繼承了 ClientTransactionHandler渴杆，此處調(diào)用父類(lèi)方法）
• ActivityThread.sendMessage (what = EXECUTE_TRANSACTION)
• ActivityThread$H.handleMessage
  （使用ActivityThread內(nèi)部Handler類(lèi)H的handleMessage方法接收)
• TransactionExecutor.execute
• TransactionExecutor.executeCallbacks
• ClientTransactionItem.execute
  (ClientTransactionItem 就是 LaunchActivityItem 的父類(lèi))
• ClientTransactionHandler.handleLaunchActivity
  (ClientTransactionHandler 是 ActivityThread 的父類(lèi))
• ActivityThread.performLaunchActivity
  {Instrumentation.newActivity創(chuàng)建activity實(shí)例 -> activity.attach -> activity.mIntent = customIntent -> activity.setTheme}
• Instrumentation.callActivityOnCreate
• Activity.performCreate
• Activity.onCreate
  到這里activity就被啟動(dòng)起來(lái)了寥枝。

總體來(lái)說(shuō)，不管是哪個(gè)版本都是：

• 首先startActivity
• 通過(guò)Instrumentation調(diào)用ActivityManagerService（簡(jiǎn)稱(chēng)AMS）通過(guò)跨進(jìn)程通訊磁奖，從應(yīng)用進(jìn)程調(diào)用到系統(tǒng)進(jìn)程脉顿，并在系統(tǒng)進(jìn)程中進(jìn)行一些列操作
• 在系統(tǒng)進(jìn)程處理完成后，通過(guò)IApplicationThread也進(jìn)行跨進(jìn)程通訊点寥，從系統(tǒng)進(jìn)程回到應(yīng)用進(jìn)程艾疟，通過(guò)ActivityThread中的Handler處理消息
• 最后又通過(guò)Instrumentation創(chuàng)建要啟動(dòng)的Activity，并調(diào)用創(chuàng)建的activity的onCreate方法
  也就是說(shuō)啟動(dòng)Activity其實(shí)是經(jīng)過(guò)了兩次跨進(jìn)程通訊才將Activity啟動(dòng)起來(lái)的敢辩。

感謝
https://blog.csdn.net/nanyou519/article/details/104735722

http://www.reibang.com/p/d94a40e0e5ec