Activity啓動基本流程分析

1.概述

基於Android9.0（SDK 28）源碼。
關鍵類：

ActivityThred
ApplicationThread
ActivityManagerService
ProcessRecord 進程信息
ActivityRecord Activity信息
ActivityStack
ActivityStackSupervisor
LoadApk

2.Activity類中流程分析

2.1 Activity->startActivity()

 @Override
 public void startActivity(Intent intent, @Nullable Bundle options) {
     if (options != null) {
      startActivityForResult(intent, -1, options);
    } else {
       //startActivity(Intent)：requestCode是-1了
       startActivityForResult(intent, -1); //2.2 Activity->startActivityForResult()
     }
}

2.2 Activity->startActivityForResult()

//requestCode=-1
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, Bundle options) {
       ...
       //轉調到Instrumentation的execStartActivity()
       Instrumentation.ActivityResult ar =
              mInstrumentation.execStartActivity(this, mMainThread.getApplicationThread(), mToken, 
              this, intent, requestCode, options);
 	   ...
}

• mMainThread.getApplicationThread():
  mMainThread是ActivityThread類型的實例,getApplicationThread獲取的是ActivityThread的內部類ApplicationThread類型的實例，ApplicationThread實際上也是IPC調用,對應的AIDL文件是IApplicationThread.aidl。

3 Instrumentation類中流程

Activity->startActivityForResult()方法中轉調到了Instrumentation->execStartActivity():

public ActivityResult execStartActivity(Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) { 
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    ...
	//result是執行啓動後的結果,類似於錯誤碼,標記不同的錯誤類型
	//從這裏調用了ActivityManagerService的startActivity()，是ipc調用，ActivityManager.getService()是通過單例模式實現的
	int result = ActivityManager.getService().startActivity(whoThread, who.getBasePackageName(), intent,
                        intent.resolveTypeIfNeeded(who.getContentResolver()),
                        token, target != null ? target.mEmbeddedID : null,
                        requestCode, 0, null, options);
	//根據AMS啓動Activity的result值，進行錯誤的處理，如果啓動失敗會拋出各種類型的異常，成功則直接return
	checkStartActivityResult(result, intent);
}

public class ActivityManagerService extends IActivityManager.Stub implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
        ...
}

• ActivityManager.getService().startActivity()這個調用，是將whoThread（ActivityThread.ApplicationThread）接口引用傳到了AMS中。
• ActivityManager.getService()實際上獲取的是AMS的實例。

4 轉到SystemServer進程中：ActivityManagerService->startActivity()

AMS中startActivity()最後會轉調到startActivityAsUser():

 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) {
        ...
        //這裏先轉調ActivityStartController進行userId檢查
        userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,  Binder.getCallingPid(), 
        Binder.getCallingUid(), "startActivityAsUser");
        //又轉調到ActivityStarter的execute()方法
        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) //mRequest.mayWait = true;會直接將mayWait標記爲true
                .execute();
    }

2.5 ActivityStarter->execute()，會繼續調用到ActivityStarter->startActivityMayWait()方法

• 2.5.1 ActivityStarter->startActivityMayWait()

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()
            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);
            ...
            } 

• 2.5.2 ActivityStarter->startActivity()：

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, String reason,
            boolean allowPendingRemoteAnimationRegistryLookup) {
        mLastStartActivityResult = startActivity(caller, intent, ephemeralIntent, resolvedType,
                aInfo, rInfo, voiceSession, voiceInteractor, resultTo, resultWho, requestCode,
                callingPid, callingUid, callingPackage, realCallingPid, realCallingUid, startFlags,
                options, ignoreTargetSecurity, componentSpecified, mLastStartActivityRecord,
                inTask, allowPendingRemoteAnimationRegistryLookup);
        return getExternalResult(mLastStartActivityResult);
    }

• 2.5.3 ActivityStarter->startActivity()：

private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent,...) {
	//這裏startActivity()傳入的Bundle類型的option參數由ActivityOptions進行管理了
	final Bundle verificationBundle = options != null ? options.popAppVerificationBundle() : null;
    ProcessRecord callerApp = null;
     return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
                true /* doResume */, checkedOptions, inTask, outActivity);

• 2.5.4 ActivityStarter->startActivity()：

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;
        result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags, doResume, options, inTask, outActivity);
        return result;
    }

• 2.5.5 ActivityStarter-> startActivityUnchecked():

private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
            IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
            int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
            ActivityRecord[] outActivity) {
       if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask
                && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) {
            newTask = true;
            result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
        } else if (mSourceRecord != null) {
            result = setTaskFromSourceRecord();
        } else if (mInTask != null) {
            result = setTaskFromInTask();
        } else {
            setTaskToCurrentTopOrCreateNewTask();
        }
        if (mDoResume) {
        	final ActivityRecord topTaskActivity = mStartActivity.getTask().topRunningActivityLocked();
            if (!mTargetStack.isFocusable()
                    || (topTaskActivity != null && topTaskActivity.mTaskOverlay
                    && mStartActivity != topTaskActivity)) {
                mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
                mService.mWindowManager.executeAppTransition();
            } else {    
                //流程轉調到ActivityStackSupervisor類的resumeFocusedStackTopActivity()方法
                mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
                        mOptions);
            }
        }
		            
}

• mSupervisor:ActivityStackSupervisor,Activity棧的管理者。

3.ActivityStackSupervisor中的流程

• 3.1 ActivityStackSupervisor::resumeFocusedStackTopActivityLocked():

boolean resumeFocusedStackTopActivityLocked(
            ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
        //獲取要啓動Activity所在棧的棧頂的不是處於停止狀態的Activiy的ActivityRecord
        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中的流程

4.1ActivityStack->resumeTopActivityUncheckedLocked()

boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
     	...
        boolean result = false;
        result = resumeTopActivityInnerLocked(prev, options);
        return result;
    }

4.2ActivityStack->resumeTopActivityInnerLocked()

private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
		final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
		if (next.app != null && next.app.thread != null) {
				mStackSupervisor.startSpecificActivityLocked(next, true, true);
		}
}

4.3 ActivityStackSupervisor->startSpecificActivityLocked()

void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
	//用進程名拿到ProcessRecord實例
     ProcessRecord app = mService.getProcessRecordLocked(r.processName,  r.info.applicationInfo.uid, true);
     if (app != null && app.thread != null) {
      	 realStartActivityLocked(r, app, andResume, checkConfig);
     }           
}

4.4 ActivityStackSupervisor->realStartActivityLocked()

final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, 
boolean checkConfig) throws RemoteException {
     final TaskRecord task = r.getTask();
     final ActivityStack stack = task.getStack();   	
     // 創建一個啓動Activity的事務,並且將applicationThread傳給ClienTransaction類中
     final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread, r.appToken);
     clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
     System.identityHashCode(r), r.info,
     mergedConfiguration.getGlobalConfiguration(),
     mergedConfiguration.getOverrideConfiguration(), r.compat,
     r.launchedFromPackage, task.voiceInteractor, app.repProcState,
     r.icicle, r.persistentState, results, newIntents, 
     mService.isNextTransitionForward(), profilerInfo));
	
	final ActivityLifecycleItem lifecycleItem;
    if (andResume) {
         lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
     } else {
         lifecycleItem = PauseActivityItem.obtain();
     }
    clientTransaction.setLifecycleStateRequest(lifecycleItem);
    //1.以事務的形式轉發
    mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}

• 1.這裏的mService就是AMS實例，mService.getLifecycleManager()獲取的mLifecycleManager是在ActivityManagerService的構造函數中new出來的

4.5 ClientLifecycleManager->scheduleTransaction()

//ClientLifecycleManager::scheduleTransaction()，ClientTransaction實現了Parcelable接口，所以支持跨進程傳輸
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        final IApplicationThread client = transaction.getClient();
        //ClinetTransaction會直接調用IApplicationThread的scheduleTransaction(ClinetTrasaction)，
       //IApplicationThread的實現類是ActivityThread的內部類ApplicationThread
        transaction.schedule(); 
        if (!(client instanceof Binder)) {
            transaction.recycle();
        }
  }

• ClientTransaction

//ActivityStackSupervisor->realStartActivityLocked()中： ClientTransaction.obtain(app.thread, r.appToken)的app.thread對象
private IApplicationThread mClient;
public IApplicationThread getClient() {
    return mClient;
}
public void schedule() throws RemoteException {
    mClient.scheduleTransaction(this);
}

ApplicationThread->scheduleTransaction()

@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
	//ActivityThread中並沒有scheduleTransaction()方法實現代碼，
	//其實是調用了父類ClientTransactionHandler::scheduleTransaction()方法
     ActivityThread.this.scheduleTransaction(transaction);
}

ClientTransactionHandler::scheduleTransaction()方法

//ActivityThread是繼承自ClientTransactionHandler
class ActivityThread extends ClientTransactionHandler {}
void scheduleTransaction(ClientTransaction transaction) {
        transaction.preExecute(this);
        //將事務發到H(Handler)了
        sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

//H::handleMessgae()
case EXECUTE_TRANSACTION:
      final ClientTransaction transaction = (ClientTransaction) msg.obj;
      //執行了TransactionExecutor的execute方法，會執行一個executeCallbacks()，
      //然後調用cycleToPath()，最終會調用到performLifecycleSequence()
      mTransactionExecutor.execute(transaction);
      if (isSystem()) {
            transaction.recycle();
      }
      break;
    }

TransactionExecutor::execute()->executeLifecycleState()->cycleToPath()->performLifecycleSequence()

//performLifecycleSequence(),通過TransactionHandler就可以回調到ActivityThread的各種生命週期方法了
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
        final int size = path.size();
        for (int i = 0, state; i < size; i++) {
            state = path.get(i);
            log("Transitioning to state: " + state);
            switch (state) {
                case ON_CREATE:
                   //調用ActivityThread的handleLaunchActivity，會進一步調用創建Activity實例，回調Activity的onCreate方法等
                    mTransactionHandler.handleLaunchActivity(r, mPendingActions,null);
                    break;
                case ON_START:
                   //onStart()
                    mTransactionHandler.handleStartActivity(r, mPendingActions);
                    break;
                case ON_RESUME:
                    //onResume()
                    mTransactionHandler.handleResumeActivity(r.token, false ,r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
                    break;
                case ON_PAUSE:
                   //onPause()
                    mTransactionHandler.handlePauseActivity(r.token, false , false , 0 , 
                    mPendingActions,  "LIFECYCLER_PAUSE_ACTIVITY");
                    break;
                case ON_STOP:
                	//onStop()
                    mTransactionHandler.handleStopActivity(r.token, false,
                          0, mPendingActions, false ,"LIFECYCLER_STOP_ACTIVITY");
                    break;
                case ON_DESTROY:
                	//onDestroy()
                    mTransactionHandler.handleDestroyActivity(r.token, false ,
                            0, false ,"performLifecycleSequence. cycling to:" + path.get(size - 1));
                    break;
                case ON_RESTART:
                	//onRestart()
                    mTransactionHandler.performRestartActivity(r.token, false );
                    break;
                default:
                    throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
            }
        }

從上述代碼可以看出，ClientTrasactionHandler最後通過TransactionExecutor真正發起Activity的各種生命週期方法的調用，如果在創建Activity實例時，Application實例未被創建，就會先創建Application實例，二者都是通過類全限定名和ClassLoader完成實例的創建。

ActivityThread中的啓動流程

• Activity啓動的核心方法： ActivityThread::performLaunchActivity()

//android.app.ActivityThread#performLaunchActivity
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
       //這個Context是Activity級別的
       ContextImpl appContext = createBaseContextForActivity(r);
        //1.使用Instrumentation和ClassLoader採用反射方式創建Activity實例
	    Activity activity = null;
            java.lang.ClassLoader cl = appContext.getClassLoader();
            activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
            r.intent.setExtrasClassLoader(cl);
            r.intent.prepareToEnterProcess();
            if (r.state != null) {
                r.state.setClassLoader(cl);
        //2.獲取Application實例，如果爲null同樣會同樣使用反射和classsLoader創建實例，是使用Instrumentation創建的，具體實現代碼在：android.app.LoadedApk#makeApplication()
        Application app = r.packageInfo.makeApplication(false, mInstrumentation);
         ...
         //3.初始化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);
        //4.Activity，Application都創建完成了，轉調Activity的onCreate()方法
        if (r.isPersistable()) {
            mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
         } else {
           mInstrumentation.callActivityOnCreate(activity, r.state);
        }
}

ContextImpl的創建時機，是怎麼和Activity關聯起來的？Activity重寫的getSystemService()方法最終中間是由ContextImpl轉調的，但是沒有看大ContextImpl是怎麼傳到Activity內的。

//android.app.ActivityThread#performLaunchActivity()中有一段代碼是這樣：
 private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
 	ContextImpl appContext = createBaseContextForActivity(r);
 	...
 	//這裏將創建的ContextImpl實例傳給了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);
 }

Activity對象的創建過程

在ActivityThread::performLaunchActivity()中，調用了Instrumentation#newActivity()方法，這個就是開始創建Activity實例的開始。

//android.app.Instrumentation#newActivity(java.lang.ClassLoader, java.lang.String, android.content.Intent)
public Activity newActivity(ClassLoader cl, String className,
            Intent intent)
            throws InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        String pkg = intent != null && intent.getComponent() != null
                ? intent.getComponent().getPackageName() : null;
        return getFactory(pkg).instantiateActivity(cl, className, intent);
}

AppComponentFactory->instantiateActivity:直接通過反射創建Activity對象

public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
            @Nullable Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (Activity) cl.loadClass(className).newInstance();
}

Application對象的創建過程:LoadApk->makeApplication()

public Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) {
        if (mApplication != null) {
            return mApplication;
        }
		 Application app = null;
        String appClass = mApplicationInfo.className;
        //如果className爲null就默認爲android.app.Application
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";
        }
        java.lang.ClassLoader cl = getClassLoader();
            if (!mPackageName.equals("android")) {
                initializeJavaContextClassLoader();  //檢查創建PathClassLoader對象
       }
      ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
      app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
      appContext.setOuterContext(app);
}

參考文獻
[1]http://gityuan.com/2016/03/12/start-activity/
[2]Android開發藝術探索，任玉剛
[3]Android進階解密，劉望舒