前言

activity啟動的流程分為兩部分：一是在activity中通過startActivity(Intent intent)方法啟動一個Activity；二是我們在桌面通過點擊應用圖標啟動一個App然后顯示Activity；第二種方式相較于第一種方式更加全面，所以本文會以第二種流程來分析。

簡要

我們手機的桌面是一個叫做Launcher的Activity，它羅列了手機中的應用圖標，圖標中包含安裝apk時解析的應用默認啟動頁等信息。在點擊應用圖標時，即將要啟動的App和Launcher、AMS、Zygote所屬進程不同所以涉及到Launcher與AMS，AMS與Zygote，AMS與新App這四者多次通信，才會啟動一個App,然后再啟動Activity，整體的時序圖如下：

接下來根據源碼來梳理一下流程。

1.Launcher向AMS發送啟動Activity

Launcher本身是一個Activity，在用戶點擊應用圖標時，調用startActivitySafely方法，最后調用到Activity.startActivity()，函數調用如下

Launcher.java public boolean startActivitySafely(View v, Intent intent, ItemInfo item) { ... //標記在新的棧啟動 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); ... startActivity(intent, optsBundle); ... }Activity.java @Override public void startActivity(Intent intent) { this.startActivity(intent, null); } @Override public void startActivity(Intent intent, @Nullable Bundle options) { ... if (options != null) { //-1為requestCode表明不需要知道是否啟動成功 startActivityForResult(intent, -1, options); } else { startActivityForResult(intent, -1); } } public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) { ... Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity( this, mMainThread.getApplicationThread(), mToken,this,intent, requestCode, options); ... }

每個Activity都持有Instrumentation對象，通過它的execStartActivity函數來繼續完成啟動Activity的流程，這個函數中傳入了mMainThread.getApplicationThread()，它獲取到的是ActivityThread的內部類ApplicationThread，這是一個Binder對象，之后AMS通過此對象與App的通信。

Instrumentation.javapublic ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) { ...int result = ActivityTaskManager.getService().startActivity(whoThread,who.getBasePackageName(), who.getAttributionTag(),intent,intent.resolveTypeIfNeeded(who.getContentResolver()), token,target != null ? target.mEmbeddedID : null, requestCode, 0, null, options); ...}ActivityTaskManager.javapublic static IActivityTaskManager getService() { return IActivityTaskManagerSingleton.get();} private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton = new Singleton<IActivityTaskManager>() { @Override protected IActivityTaskManager create() { final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE); return IActivityTaskManager.Stub.asInterface(b); } }};

這一步Launcher開始向AMS通信，由于在不同的進程所以需要通過Binder來通信,IActivityTaskManager是一個代理AMS端Binder的對象，之后AMS開始startActivity。 到這里Launcher向AMS請求啟動一個Activity的流程就結束了。

2.AMS啟動Activity并通知Launcher進入Paused狀態

現在的流程是在AMS中，也就是另一個進程中，上一步通過代理調用到AMS的startActivity方法，接下來的調用如下：

ActivityTaskManagerService.java @Override public final int startActivity(IApplicationThread caller, String callingPackage, String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) { return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, UserHandle.getCallingUserId()); } @Override public int startActivityAsUser(IApplicationThread caller, String callingPackage, String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) { return startActivityAsUser(caller, callingPackage, callingFeatureId, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, userId, true /*validateIncomingUser*/); } private int startActivityAsUser(IApplicationThread caller, String callingPackage, @Nullable String callingFeatureId, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) { ... userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser, Binder.getCallingPid(), Binder.getCallingUid(), 'startActivityAsUser'); return getActivityStartController().obtainStarter(intent, 'startActivityAsUser') .setCaller(caller) .setCallingPackage(callingPackage) .setCallingFeatureId(callingFeatureId) .setResolvedType(resolvedType) .setResultTo(resultTo) .setResultWho(resultWho) .setRequestCode(requestCode) .setStartFlags(startFlags) .setProfilerInfo(profilerInfo) .setActivityOptions(bOptions) .setUserId(userId) .execute(); } ActivityStarter obtainStarter(Intent intent, String reason) { return mFactory.obtain().setIntent(intent).setReason(reason); }

上面幾步主要是做權限檢查

ActivityStarter.java int execute() { ... res = executeRequest(mRequest); ... }//層層調用會到下面這個方法ActivityStack.java private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) { ... if (mResumedActivity != null) { pausing |= startPausingLocked(userLeaving, false , next); } ... mStackSupervisor.startSpecificActivity(next, true, false); ... }

startPausingLocked方法主要是通知Launcher進入Paused狀態，在它進入這個狀態后，在ActivityStackSupervisor.startSpecificActivity方法判斷新的App進程狀態做出不同響應，如下：

ActivityStackSupervisor.javavoid startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) { // 獲取要啟動的Activity進程信息 final WindowProcessController wpc = mService.getProcessController(r.processName, r.info.applicationInfo.uid); boolean knownToBeDead = false; //如果進程存在且有進程中有線程存在 就是啟動一個同應用的Activity（普通Activity就在此執行） if (wpc != null && wpc.hasThread()) { try { realStartActivityLocked(r, wpc, andResume, checkConfig); return; } catch (RemoteException e) { Slog.w(TAG, 'Exception when starting activity ' + r.intent.getComponent().flattenToShortString(), e); } // If a dead object exception was thrown -- fall through to // restart the application. knownToBeDead = true; }//否則通過AMS向Zygote進程請求創建新的進程 r.notifyUnknownVisibilityLaunchedForKeyguardTransition(); final boolean isTop = andResume && r.isTopRunningActivity(); mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? 'top-activity' : 'activity');}

截止到這里完成了Launcher和AMS的通信，以及AMS和Zygote進程的通信，接下來我們要創建要啟動的App的線程，即ActivityThread。

3.新的進程啟動，ActivityThread的main函數入口

上一部分Zygote啟動新的進程時標記ActivityThread.main函數，在Zygote創建好新進程后通過反射調用此方法，現在處于新App的進程中。

ActivityThread.java public static void main(String[] args) { ... Looper.prepareMainLooper();... ActivityThread thread = new ActivityThread(); thread.attach(false, startSeq);... Looper.loop();... } private void attach(boolean system, long startSeq) { final IActivityManager mgr = ActivityManager.getService(); try { mgr.attachApplication(mAppThread, startSeq); } catch (RemoteException ex) { throw ex.rethrowFromSystemServer(); } ... }ActivityManagerService.java private boolean attachApplicationLocked(@NonNull IApplicationThread thread, int pid, int callingUid, long startSeq) { ... thread.bindApplication(processName, appInfo, providerList, instr2.mClass, profilerInfo, instr2.mArguments, instr2.mWatcher, instr2.mUiAutomationConnection, testMode, mBinderTransactionTrackingEnabled, enableTrackAllocation, isRestrictedBackupMode || !normalMode, app.isPersistent(), new Configuration(app.getWindowProcessController().getConfiguration()), app.compat, getCommonServicesLocked(app.isolated), mCoreSettingsObserver.getCoreSettingsLocked(), buildSerial, autofillOptions, contentCaptureOptions, app.mDisabledCompatChanges); ... didSomething = mAtmInternal.attachApplication(app.getWindowProcessController()); ... }

這里主要是創建了Looper和ActivityThread對象，然后將當前應用ApplicationThread注冊到AMS中，ApplicationThread是ActivityThread的內部類實現了IApplicationThread.Stub用此對象可跨進程通信，上面的代碼邏輯分兩步，第一步，在AMS綁定ApplicationThread時，發送了一個H.BIND_APPLICATION的Message，在Handler中處理該消息時調用了Application的onCreate方法，第二步，在mAtmInternal的attachApplication層層調用到ActivityStackSupervisor.realStartActivityLocked方法，整體如下：

public final void bindApplication(String processName, ApplicationInfo appInfo, ProviderInfoList providerList, ComponentName instrumentationName, ProfilerInfo profilerInfo, Bundle instrumentationArgs, IInstrumentationWatcher instrumentationWatcher, IUiAutomationConnection instrumentationUiConnection, int debugMode, boolean enableBinderTracking, boolean trackAllocation, boolean isRestrictedBackupMode, boolean persistent, Configuration config, CompatibilityInfo compatInfo, Map services, Bundle coreSettings, String buildSerial, AutofillOptions autofillOptions, ContentCaptureOptions contentCaptureOptions, long[] disabledCompatChanges) { ... sendMessage(H.BIND_APPLICATION, data); } public void handleMessage(Message msg) { switch (msg.what) { case BIND_APPLICATION: AppBindData data = (AppBindData)msg.obj; handleBindApplication(data); Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); break; ... }}private void handleBindApplication(AppBindData data) {...mInstrumentation.callApplicationOnCreate(app);...}

到這里為止，新的App線程已經啟動并且綁定了Application。

4.創建Activity

ActivityStackSupervisor.javaboolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc, boolean andResume, boolean checkConfig) throws RemoteException { ... final ClientTransaction clientTransaction = ClientTransaction.obtain( proc.getThread(), r.appToken); final DisplayContent dc = r.getDisplay().mDisplayContent; clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent), System.identityHashCode(r), r.info, mergedConfiguration.getGlobalConfiguration(), mergedConfiguration.getOverrideConfiguration(), r.compat, r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(), results, newIntents, dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(), r.assistToken, r.createFixedRotationAdjustmentsIfNeeded())); final ActivityLifecycleItem lifecycleItem; if (andResume) { lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward()); } else { lifecycleItem = PauseActivityItem.obtain(); } clientTransaction.setLifecycleStateRequest(lifecycleItem); //執行clientTransaction mService.getLifecycleManager().scheduleTransaction(clientTransaction); ...}

ClientTransaction管理了Activity的啟動信息，由ClientLifecycleManager執行，scheduleTransaction方法中發送了EXECUTE_TRANSACTION的消息給ActivityThread的H類處理，然后執行TransactionExecutor.execute()，之后執行handleLaunchActivity方法，如下

void scheduleTransaction(ClientTransaction transaction) throws RemoteException { final IApplicationThread client = transaction.getClient(); transaction.schedule(); ... } public void schedule() throws RemoteException { mClient.scheduleTransaction(this); } void scheduleTransaction(ClientTransaction transaction) { transaction.preExecute(this); sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction); } class H extends Handler { ... public void handleMessage(Message msg) { ... case EXECUTE_TRANSACTION: final ClientTransaction transaction = (ClientTransaction) msg.obj; mTransactionExecutor.execute(transaction); if (isSystem()) { transaction.recycle(); } break; ... } ... } public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) { ... client.handleLaunchActivity(r, pendingActions, null /* customIntent */); }

接下來由ActivityThread來處理后續操作

public Activity handleLaunchActivity(ActivityClientRecord r, PendingTransactionActions pendingActions, Intent customIntent) { ... final Activity a = performLaunchActivity(r, customIntent); ... return a;}private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) { ContextImpl appContext = createBaseContextForActivity(r); ... java.lang.ClassLoader cl = appContext.getClassLoader(); activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); ... Application app = r.packageInfo.makeApplication(false, mInstrumentation); ... 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, r.assistToken); ... activity.setTheme(theme); ... mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);}

performLaunchActivity方法中主要做了以下幾件事：

創建要啟動activity的上下文環境 通過Instrumentation的newActivity方法，以反射形式創建activity實例 如果Application不存在的話會創建Application并調用Application的onCreate方法 初始化Activity，創建Window對象（PhoneWindow）并實現Activity和Window相關聯 通過Instrumentation調用Activity的onCreate方法 總結

根Activity整體上學習意義較大，建議從整體流程入手，遇到流程不通時也可以debug。 Activity的整體啟動流程：

點擊圖標，Launcher向AMS請求啟動該App AMS反饋收到啟動請求,并告知Launcher進入pause狀態 Launcher進入Paused狀態并告知AMS AMS檢測新的App是否已啟動，否則通知Zygote創建新的進程并啟動ActivityThread.main() 應用進程啟動ActivityThread ActivityThread中H處理需要啟動Activity的請求消息

以上就是詳解Android Activity的啟動流程的詳細內容，更多關于Android Activity的啟動流程的資料請關注好吧啦網其它相關文章！