一、用戶啟動Activity，發送消息給ATMS的過程（Launcher > ATMS階段）
開發中我們會調用startActivity來啟動一個Activity，最終會調到startActivityForResult：
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
//通過Instrumentation啟動Activity
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
}
Instrumentation是Android系統里面的一套控制方法或者“鉤子”。這些鉤子可以在正常的生命周期（正常是由操作系統控制的）之外控制Android控件的運行。
Application和Activity的所有生命周期中，都會先調用Instrumentation提供的相應方法（如callActivityOnCreate，callApplicationOnCreate，newActivity，callActivityOnNewIntent）
Instrumentation.execStartActivity
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, String target,
Intent intent, int requestCode, Bundle options) {
//通過ATMS啟動Activity（API 29是ATMS）
int result = ActivityTaskManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target, requestCode, 0, null, options);
}
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
@UnsupportedAppUsage(trackingBug = 129726065)
private static final Singleton<IActivityTaskManager> IActivityTaskManagerSingleton =
new Singleton<IActivityTaskManager>() {
@Override
protected IActivityTaskManager create() {
//找到Binder服務
final IBinder b = ServiceManager.getService(Context.ACTIVITY_TASK_SERVICE);
return IActivityTaskManager.Stub.asInterface(b);
}
};
ActivityTaskManager.getService()返回了一個IActivityTaskManager，拿到的是ATMS的代理對象，跨進程調用了ATMS的startActivity方法。
二、ATMS接收到啟動請求并處理的過程（ATMS > ApplicationThread階段）
//ActivityTaskManagerService.java
@Override
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());
}
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("startActivityAsUser");
userId = getActivityStartController().checkTargetUser(userId, validateIncomingUser,
Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
// TODO: Switch to user app stacks here.
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)
//調用了ActivityStarter的execute
.execute();
}
int execute() {
return startActivityMayWait(/**省略參數**/);
}
ActivityStarter.startActivityMayWait
//ActivityStarter.java
private int startActivityMayWait(/**省略參數**/){
//收集目標Intent信息（更加Intent的action，可用于雙開，選擇打開）
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
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, originatingPendingIntent,
allowBackgroundActivityStart);
}
private int startActivity(/**省略參數**/){
mLastStartActivityResult = startActivity(/**省略參數**/)
}
private int startActivity(/**省略參數**/){
//處理startActivityForResult，對result進行轉發
final int launchFlags = intent.getFlags();
if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) {
// Transfer the result target from the source activity to the new
// one being started, including any failures.
if (requestCode >= 0) {
SafeActivityOptions.abort(options);
return ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT;
}
resultRecord = sourceRecord.resultTo;
if (resultRecord != null && !resultRecord.isInStackLocked()) {
resultRecord = null;
}
resultWho = sourceRecord.resultWho;
requestCode = sourceRecord.requestCode;
sourceRecord.resultTo = null;
if (resultRecord != null) {
resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode);
}
if (sourceRecord.launchedFromUid == callingUid) {
// The new activity is being launched from the same uid as the previous
// activity in the flow, and asking to forward its result back to the
// previous. In this case the activity is serving as a trampoline between
// the two, so we also want to update its launchedFromPackage to be the
// same as the previous activity. Note that this is safe, since we know
// these two packages come from the same uid; the caller could just as
// well have supplied that same package name itself. This specifially
// deals with the case of an intent picker/chooser being launched in the app
// flow to redirect to an activity picked by the user, where we want the final
// activity to consider it to have been launched by the previous app activity.
callingPackage = sourceRecord.launchedFromPackage;
}
}
//接下來做一些校驗判斷
//從Intent中找不到相應Component
if (err == ActivityManager.START_SUCCESS && intent.getComponent() == null) {
// We couldn't find a class that can handle the given Intent.
// That's the end of that!
err = ActivityManager.START_INTENT_NOT_RESOLVED;
}
//從Intent中找不到相應AppInfo
if (err == ActivityManager.START_SUCCESS && aInfo == null) {
// We couldn't find the specific class specified in the Intent.
// Also the end of the line.
err = ActivityManager.START_CLASS_NOT_FOUND;
}
//...
//校驗當前應用是否開啟權限
boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho,
requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity,
inTask != null, callerApp, resultRecord, resultStack);
//創建目標ActivityRecord對象，存數組索引為0的位置
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;
}
//繼續調用startActivity
final int res = startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags,
true /* doResume */, checkedOptions, inTask, outActivity, restrictedBgActivity);
return res;
}
private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity, boolean restrictedBgActivity) {
//startActivityUnchecked
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity, restrictedBgActivity);
}
ActivityStarter中做了一系列的調用（收集Intent信息，處理startActivityForResult，做一些校驗判斷等），最終進入startActivityUnchecked。
startActivityUnchecked
// Note: This method should only be called from {@link startActivity}.
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity, boolean restrictedBgActivity) {
//根據Intent識別啟動模式
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor, restrictedBgActivity);
//判斷啟動模式，并在mLaunchFlags追加對應的標記
computeLaunchingTaskFlags();
//獲取Activity的啟動棧
computeSourceStack();
//根據上面的計算，設置Intent的flags
mIntent.setFlags(mLaunchFlags);
//處理完啟動棧后，準備執行發起者的Resume狀態了
if (mDoResume) {
//resume我們的Activity
mRootActivityContainer.resumeFocusedStacksTopActivities(
mTargetStack, mStartActivity, mOptions);
}
}
startActivityUnchecked中處理了關于Activity啟動模式的處理，接著真正的resume我們的Activity
//RootActivityContainer.java
boolean resumeFocusedStacksTopActivities(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
//調用ActivityStack（Activity棧）的resumeTopActivityUncheckedLocked方法
result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
//ActivityStack.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
result = resumeTopActivityInnerLocked(prev, options);
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
//將發起者置為onPause狀態
boolean pausing = getDisplay().pauseBackStacks(userLeaving, next, false);
//繼續當前Activity
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
//ActivityStackSupervisor.java
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
// Is this activity's application already running?
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
if (wpc != null && wpc.hasThread()) {
try {
//如果這個app已經啟動，執行realStartActivityLocked并return（熱啟動）
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;
}
// Post message to start process to avoid possible deadlock of calling into AMS with the
// ATMS lock held.
//創建應用進程
final Message msg = PooledLambda.obtainMessage(
ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
mService.mH.sendMessage(msg);
}
這里會先判斷應用進程是否創建，創建了就進入realStartActivityLocked，沒創建就會調用ActivityManagerInternal.startProcess
①熱啟動realStartActivityLocked
//ActivityStackSupervisor.java
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.appToken);
//addCallback，傳入參數LaunchActivityItem
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, proc.getReportedProcState(),
r.icicle, r.persistentState, results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken));
// Schedule transaction.
//獲取ClientLifecycleManager對象進行調度
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}
//ClientLifecycleManager.java
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
//調用ClientTransaction的schedule
transaction.schedule();
if (!(client instanceof Binder)) {
// If client is not an instance of Binder - it's a remote call and at this point it is
// safe to recycle the object. All objects used for local calls will be recycled after
// the transaction is executed on client in ActivityThread.
transaction.recycle();
}
}
//ClientTransaction.java
/** Target client. */
private IApplicationThread mClient;
public void schedule() throws RemoteException {
//mClient為IApplicationThread，調度到主進程處理
mClient.scheduleTransaction(this);
}
三、ApplicationThread接收到調度請求并處理的過程（Application > Activity階段）
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
}
public abstract class ClientTransactionHandler {
// Schedule phase related logic and handlers.
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
//發送消息給H（H是ActivityThread的一個內部類）
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
}
接著看ActivityThread中接收并處理消息的handleMessage
public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
//取出消息，執行execute方法
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
}
}
//TransactionExecutor.java
public void execute(ClientTransaction transaction) {
executeCallbacks(transaction);
executeLifecycleState(transaction);
}
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
//取出上面realStartActivityLocked中設置的LaunchActivityItem類型的CallBack
final ClientTransactionItem item = callbacks.get(i);
//調用LaunchActivityItem的execute
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
}
}
前面realStartActivityLocked方法中通過addCallback，傳入參數LaunchActivityItem。executeCallbacks方法中取出callbacks集合中的LaunchActivityItem，并調用其execute方法
//LaunchActivityItem.java
@Override
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, mAssistToken);
//ClientTransactionHandler的子類ActivityThread執行handleLaunchActivity方法
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
handleLaunchActivity
//ActivityThread.java
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
final Activity a = performLaunchActivity(r, customIntent);
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//通過Instrumentation創建Activity
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
//拿到Application
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
//調用Activity的attach
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);
//通過Instrumentation調用Activity的onCreate方法
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
//設置狀態
r.setState(ON_CREATE);
}
②冷啟動創建應用進程ActivityManagerInternal.startProcess
ActivityManagerInternal的實現類是AMS中的LocalService，AMS通過Socket與Zygote通信，fork出App進程，app進程創建后，會執行ActivityThread的main方法（Android進程入口方法）
//ActivityThread.java
public static void main(String[] args) {
//創建Looper
Looper.prepareMainLooper();
//創建ActivityThread
ActivityThread thread = new ActivityThread();
//[1]attach
thread.attach(false, startSeq);
//loop循環
Looper.loop();
}
調用ActivityThread的attach
private void attach(boolean system, long startSeq) {
//system傳的false
final IActivityManager mgr = ActivityManager.getService();
//[2]調用AMS的attachApplication
mgr.attachApplication(mAppThread, startSeq);
}
//ActivityManagerService.java
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
//[3]attachApplicationLocked
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid, int callingUid, long startSeq) {
//[4]bindApplication
thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.isPersistent(),
new Configuration(app.getWindowProcessController().getConfiguration()),
app.compat, getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, autofillOptions, contentCaptureOptions);
app.makeActive(thread, mProcessStats);
//[5]調用ATMS的attachApplication
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
}
[4]thread.bindApplication 這是一個binder通信的過程
public final void bindApplication(String processName, ApplicationInfo appInfo,
List<ProviderInfo> providers, 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, boolean autofillCompatibilityEnabled) {
//創建一個AppBindData
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
//...data賦值操作...
//最后發送Handler消息
sendMessage(H.BIND_APPLICATION, data);
}
ActivityThread內部的Handler接收到BIND_APPLICATION消息
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
private void handleBindApplication(AppBindData data) {
//獲取LoadedApk對象
data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
//創建ContextImpl上下文
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
//創建Instrumentation
try {
final ClassLoader cl = instrContext.getClassLoader();
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate instrumentation "
+ data.instrumentationName + ": " + e.toString(), e);
}
//通過反射創建目標Application對象
app = data.info.makeApplication(data.restrictedBackupMode, null);
//調用Application的onCreate方法
mInstrumentation.callApplicationOnCreate(app);
}
回到上面attachApplicationLocked的mAtmInternal.attachApplication，調用ATMS的attachApplication
//ActivityTaskManagerService.java
public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
synchronized (mGlobalLockWithoutBoost) {
return mRootActivityContainer.attachApplication(wpc);
}
}
//RootActivityContainer.java
boolean attachApplication(WindowProcessController app) throws RemoteException {
//看到了似曾相識的realStartActivityLocked。
mStackSupervisor.realStartActivityLocked(activity, app,
top == activity /* andResume */, true /* checkConfig */)
}
看到了似曾相識的realStartActivityLocked，后面流程和之前一樣。Activity啟動流程分析完畢。
總結
1）與Activity管理有關的類：
ActivityRecord：歷史棧中的一個條目，代表一個Activity
TaskRecord：內部維護了一個ArrayList<ActivityRecord> ，來保存ActivityRecord
ActivityStack：內部維護了一個ArrayList<TaskRecord>，用來管理TaskRecord
ActivityStackSupervisor：用來管理ActivityStack的
2）Activity啟動流程
-
Launcher > ATMS階段
Launcher>ATMS階段.png -
ATMS > ApplicationThread階段
ATMS > ApplicationThread階段.png -
ApplicationThread > Activity階段
ApplicationThread > Activity階段.png
