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

本文轉載自查看原文 2020-12-12 20:17 1411 Android

前言

Activity作為Android四大組件之一，他的啟動絕對沒有那么簡單。這里涉及到了系統服務進程，啟動過程細節很多，這里我只展示主體流程。activity的啟動流程隨着版本的更替，代碼細節一直在進行更改，每次都會有很大的修改，如android5.0 android8.0。我這里的版本是基於android api28，也是目前我可以查得到的最新源碼了。事實上大題的流程是相同的，掌握了一個版本，其他的版本通過源碼也可以很快地掌握。

因為涉及到不同的進程之間的通信：系統服務進程和本地進程，在最新版本的android使用的是AIDL來跨進程通信。所以需要對AIDL有一定的了解，會幫助理解整個啟動流程。

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

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

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

整體流程概述

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

普通Activity的創建

普通Activity創建也就是平常我們在代碼中采用startActivity(Intent intent)方法來創建Activity的方式。總體流程如下圖：

啟動過程設計到兩個進程：本地進程和系統服務進程。本地進程也就是我們的應用所在進程，系統服務進程為所有應用共用的服務進程。整體思路是：

activity向Instrumentation請求創建
Instrumentation通過AMS在本地進程的IBinder接口，訪問AMS，這里采用的跨進程技術是AIDL。
然后AMS進程一系列的工作，如判斷該activity是否存在，啟動模式是什么，有沒有進行注冊等等。
通過ClientLifeCycleManager，利用本地進程在系統服務進程的IBinder接口直接訪問本地ActivityThread。

ApplicationThread是ActivityThread的內部類，IApplicationThread是在遠程服務端的Binder接口
ApplicationThread接收到服務端的事務后，把事務直接轉交給ActivityThread處理。
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進程，負責創建進程
應用程序進程，也就是即將要啟動的進程

主要流程：

Launcher進程請求AMS創建activity
AMS請求Zygote創建進程。
Zygote通過fork自己來創建進程。並通知AMS創建完成。
AMS通知應用進程創建根Activity。

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

源碼講解

Activity請求AMS的過程

流程圖

源碼

系統通過調用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;
    }

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

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處理請求的過程

流程圖

源碼

接下來看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);
}

這部分主要是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);
        }
    }
}

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;
}

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;
}

這里又回到了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;
}

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

把事務交給本地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的過程

流程圖

源碼

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

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

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

事務池對事務進行處理。事務池會把事務中的兩個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);
}

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

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

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

最后一步，通過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啟動過程(最詳細&最簡單)

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Android8.0（API26）之Activity啟動流程(顯示啟動) Android Activity啟動流程源碼全解析（1） Android Activity的4種啟動模式詳解（示例） Android中Activity啟動模式詳解 androd hook acitivity 啟動流程，替換啟動的activity（Android Instrumentation） Activity啟動流程 android系統啟動框架、Activity界面顯示過程詳解 Android——Activity以及Service的啟動方式 Android Activity.startActivity流程簡介 Android的開機啟動流程