前言
平常开发中Activity是我们必不可少的组件，但是对于一个新启动的Activity 中你是否对他有过了解，之前我就写写xml，直接调用Api，今天我们来了解一下Acitivty的启动经历了一个怎样的流程。
调用方式
- 主动调用型，Android 应用程序内启动过程；
- 被动调用型，Launcher进程启动；
一 、Android 应用程序内启动过程查看源码分析
1、Activity客户端发起
startActivity 的操作是由客户端主动发起的，启动一个新的 Activity 只需要在当前 Activity 中调用startActivity方法，并传入一个Intent 即可，例如，从 MainActivity 启动一个 ZxxActivity 代码如下：
Intent intent = new Intent(this, ZxxActivity.class);
startActivity(intent);
Activity 调用startActivity最终都会调用startActivityForResult方法
// frameworks/base/core/java/android/app/Activity.java
@Override
public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
getAutofillClientController().onStartActivity(intent, mIntent);
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);
}
}
startActivityForResult的方法源码如下：
// frameworks/base/core/java/android/app/Activity.java
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,
@Nullable Bundle options) {
//判读当前Activity是否为空，为空调用Instrumentation的execStartActivity进行创建
//Instrumentation是Android系统里面的一套控制方法或者”钩子“。这方法，可以用来独立地控制某个组件的生命周期。它们同时可以控制Android如何加载应用程序。
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
//启动activity主要调用execStartActivity
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
//.......
} else {
//.......
}
}
Instrumentation类中的execStartActivity方法：
// frameworks/base/core/java/android/app/Instrumentation.java
@UnsupportedAppUsage
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
Uri referrer = target != null ? target.onProvideReferrer() : null;
if (referrer != null) {
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
//......
try {
intent.migrateExtraStreamToClipData(who);
intent.prepareToLeaveProcess(who);
// 通过 ActivityTaskManager 获取 Service 调用startActivity来启动 Activity
int result = ActivityTaskManager.getService().startActivity(whoThread,
who.getOpPackageName(), who.getAttributionTag(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()), token,
target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
notifyStartActivityResult(result, options);
// 检查 Activity 的启动结果，例如是否在 AndroidManifest 文件中注册，没有则抛出异常
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
启动Activity最终调用的是ActivityTaskManager.getService().startActivity方法，而ActivityTaskManager的getService()返回的是ActivityTaskManagerService(ATMS)对象，它是一个Binder对象。ActivityTaskManagerService(ATMS)继承自IActivityTaskManager.Stub对象。 getService方法如下：
// frameworks/base/core/java/android/app/ActivityTaskManager.java
/** @hide */
public static IActivityTaskManager getService() {
return IActivityTaskManagerSingleton.get();
}
@UnsupportedAppUsage(trackingBug = 129726065)
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);
}
};
checkStartActivityResult方法是用来检查Activity启动的结果，比如没有在AndroidManifest.xml中注册这个Activity实例对象：
// frameworks/base/core/java/android/app/Instrumentation.java
public static void checkStartActivityResult(int res, Object intent) {
if (!ActivityManager.isStartResultFatalError(res)) {
return;
}
switch (res) {
case ActivityManager.START_INTENT_NOT_RESOLVED:
case ActivityManager.START_CLASS_NOT_FOUND:
if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
throw new ActivityNotFoundException(
"Unable to find explicit activity class "
+ ((Intent)intent).getComponent().toShortString()
+ "; have you declared this activity in your AndroidManifest.xml"
+ ", or does your intent not match its declared <intent-filter>?");
throw new ActivityNotFoundException(
"No Activity found to handle " + intent);
case ActivityManager.START_PERMISSION_DENIED:
throw new SecurityException("Not allowed to start activity "
+ intent);
case ActivityManager.START_FORWARD_AND_REQUEST_CONFLICT:
throw new AndroidRuntimeException(
"FORWARD_RESULT_FLAG used while also requesting a result");
case ActivityManager.START_NOT_ACTIVITY:
throw new IllegalArgumentException(
"PendingIntent is not an activity");
case ActivityManager.START_NOT_VOICE_COMPATIBLE:
throw new SecurityException(
"Starting under voice control not allowed for: " + intent);
case ActivityManager.START_VOICE_NOT_ACTIVE_SESSION:
throw new IllegalStateException(
"Session calling startVoiceActivity does not match active session");
case ActivityManager.START_VOICE_HIDDEN_SESSION:
throw new IllegalStateException(
"Cannot start voice activity on a hidden session");
case ActivityManager.START_ASSISTANT_NOT_ACTIVE_SESSION:
throw new IllegalStateException(
"Session calling startAssistantActivity does not match active session");
case ActivityManager.START_ASSISTANT_HIDDEN_SESSION:
throw new IllegalStateException(
"Cannot start assistant activity on a hidden session");
case ActivityManager.START_CANCELED:
throw new AndroidRuntimeException("Activity could not be started for "
+ intent);
default:
throw new AndroidRuntimeException("Unknown error code "
+ res + " when starting " + intent);
}
}
到这个时候，我们应用内的调用基本完成，由 ActivityTaskManager的getService获取返回一个ActivityTaskManagerService(ATMS)服务，它继承于IActivityTaskManager.stub，我们查找frameworks/base/core/java/android/app/IActivityTaskManager.aidl，发现他是一个aidl，IActivityTaskManager#startActivity 在这里肯定是一个跨进程的操作，这时候已经从App进程进入system_server进程简称“系统服务进程”当中。
2、ATMS服务端的调用
ActivityTaskManagerService的startActivity方法：
// frameworks/base/services/core/java/com/android/server/wm/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) {
Log.e("zxx","system_server startActivity",new Exception());
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) {
final SafeActivityOptions opts = SafeActivityOptions.fromBundle(bOptions);
//...........
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)
.setCallingFeatureId(callingFeatureId)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(opts)
.setUserId(userId)
.execute();
}
ATMS在这个类中 startActivity 最终调用了 startActivityAsUser 方法，这个方法中的代码也比较简单，就是通过 getActivityStartController().obtainStarter 来配置相关参数，并最终执行 execute。
getActivityStartController() 获取到的是一个 ActivityStartController 对象，如下：
ActivityStartController getActivityStartController() {
return mActivityStartController;
}
ActivityStartController 对象是ActivityStarter的一个控制管理类，通过调用obtainStarter返回一个ActivityStarter
// frameworks/base/services/core/java/com/android/server/wm/ActivityStartController.java
/**
* @return A starter to configure and execute starting an activity. It is valid until after
* {@link ActivityStarter#execute} is invoked. At that point, the starter should be
* considered invalid and no longer modified or used.
*/
ActivityStarter obtainStarter(Intent intent, String reason) {
return mFactory.obtain().setIntent(intent).setReason(reason);
}
通过obtainStarter方法注意我们可以发现，“A starter to configure and execute starting an activity”通过execute开始一个activity，如下
// frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
int execute() {
try {
onExecutionStarted();
// If the caller hasn't already resolved the activity, we're willing
// to do so here. If the caller is already holding the WM lock here,
// and we need to check dynamic Uri permissions, then we're forced
// to assume those permissions are denied to avoid deadlocking.
//.......
// Add checkpoint for this shutdown or reboot attempt, so we can record the original
// intent action and package name.
//.......
int res;
synchronized (mService.mGlobalLock) {
//.......
//请求启动
res = executeRequest(mRequest);
// 通知已经启动完成等待绘制
mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(launchingState, res,
newActivityCreated, mLastStartActivityRecord, originalOptions);
if (mRequest.waitResult != null) {
mRequest.waitResult.result = res;
res = waitResultIfNeeded(mRequest.waitResult, mLastStartActivityRecord,
launchingState);
}
return getExternalResult(res);
}
} finally {
onExecutionComplete();
}
}
execute 方法又调用了 executeRequest(mRequest) 方法，源码如下：
// frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
private int executeRequest(Request request) {
//判断权限，包括进程检测，intent检查，权限检查等
//......
final ActivityRecord r = new ActivityRecord.Builder(mService)
.setCaller(callerApp)
.setLaunchedFromPid(callingPid)
.setLaunchedFromUid(callingUid)
.setLaunchedFromPackage(callingPackage)
.setLaunchedFromFeature(callingFeatureId)
.setIntent(intent)
.setResolvedType(resolvedType)
.setActivityInfo(aInfo)
.setConfiguration(mService.getGlobalConfiguration())
.setResultTo(resultRecord)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setComponentSpecified(request.componentSpecified)
.setRootVoiceInteraction(voiceSession != null)
.setActivityOptions(checkedOptions)
.setSourceRecord(sourceRecord)
.build();
//......
//启动最后需要启动的activity，也就是当前activity
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions,
inTask, inTaskFragment, restrictedBgActivity, intentGrants);
if (request.outActivity != null) {
request.outActivity[0] = mLastStartActivityRecord;
}
return mLastStartActivityResult;
}
在executeRequest方法中会进行一些校验和判断权限，包括进程检测，intent检查，权限检查等，后面会创建ActivityRecord，每个Activity都会对应一个ActivityRecord对象，接着就会调用startActivityUnChecked方法对要启动的Activity做任务栈管理。
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
TaskFragment inTaskFragment, boolean restrictedBgActivity,
NeededUriGrants intentGrants) {
int result = START_CANCELED;
final Task startedActivityRootTask;
//......
try {
mService.deferWindowLayout();
try {
Trace.traceBegin(Trace.TRACE_TAG_WINDOW_MANAGER, "startActivityInner");
//在大多数初步检查已经完成的情况下开始进行下一步确认拥有必要的权限。startActivityInner()用来检查启动所必须要有的权限。
result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, inTaskFragment, restrictedBgActivity,
intentGrants);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_WINDOW_MANAGER);
startedActivityRootTask = handleStartResult(r, options, result, newTransition,
remoteTransition);
}
} finally {
mService.continueWindowLayout();
}
postStartActivityProcessing(r, result, startedActivityRootTask);
return result;
}
startActivityUnchecked 方法中又调用了 startActivityInner，源码如下
// frameworks/base/services/core/java/com/android/server/wm/ActivityStarter.java
int startActivityInner(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, Task inTask,
TaskFragment inTaskFragment, boolean restrictedBgActivity,
NeededUriGrants intentGrants) {
//初始化设置，mStartActivity,mLaunchMode等
setInitialState(r, options, inTask, inTaskFragment, doResume, startFlags, sourceRecord,
voiceSession, voiceInteractor, restrictedBgActivity);
//计算启动Activity的Flag值，判断启动模式，并且在mLaunchFlags上追加对应标记
computeLaunchingTaskFlags();
// 获取启动 Activity 的任务栈，这里即获取 MainActivity 所在的任务栈
computeSourceRootTask();
//设置LaunchFlags到intent上，也就是设置启动模式
mIntent.setFlags(mLaunchFlags);
boolean dreamStopping = false;
for (ActivityRecord stoppingActivity : mSupervisor.mStoppingActivities) {
if (stoppingActivity.getActivityType()
== WindowConfiguration.ACTIVITY_TYPE_DREAM) {
dreamStopping = true;
break;
}
}
//决定是否应将新Activity插入Task中。返回null,如果不是则应将新Activity添加到其中的task进行Activity记录。
//查找可用的任务栈
final Task prevTopRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
final Task prevTopTask = prevTopRootTask != null ? prevTopRootTask.getTopLeafTask() : null;
// 查找可用的任务栈
final Task reusedTask = getReusableTask();
// If requested, freeze the task list
if (mOptions != null && mOptions.freezeRecentTasksReordering()
&& mSupervisor.mRecentTasks.isCallerRecents(r.launchedFromUid)
&& !mSupervisor.mRecentTasks.isFreezeTaskListReorderingSet()) {
mFrozeTaskList = true;
mSupervisor.mRecentTasks.setFreezeTaskListReordering();
}
// 如果 reusedTask 不空，则使用 reusedTask 任务栈，否则寻找目标任务栈
final Task targetTask = reusedTask != null ? reusedTask : computeTargetTask();
// 目标任务栈为空，则标记为使用新任务栈，需要新建任务栈
final boolean newTask = targetTask == null;
mTargetTask = targetTask;
computeLaunchParams(r, sourceRecord, targetTask);
//检查是否允许在给定的Task或者新的Task上启动Activity
int startResult = isAllowedToStart(r, newTask, targetTask);
if (startResult != START_SUCCESS) {
if (r.resultTo != null) {
r.resultTo.sendResult(INVALID_UID, r.resultWho, r.requestCode, RESULT_CANCELED,
null /* data */, null /* dataGrants */);
}
return startResult;
}
if (targetTask != null) {
mPriorAboveTask = TaskDisplayArea.getRootTaskAbove(targetTask.getRootTask());
}
final ActivityRecord targetTaskTop = newTask
? null : targetTask.getTopNonFinishingActivity();
if (targetTaskTop != null) {
// Recycle the target task for this launch.
startResult = recycleTask(targetTask, targetTaskTop, reusedTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
} else {
mAddingToTask = true;
}
//如果正在启动的Activity与当前位于栈顶的Activity相同
//则需要检查它是否应该只启动一次
final Task topRootTask = mPreferredTaskDisplayArea.getFocusedRootTask();
if (topRootTask != null) {
startResult = deliverToCurrentTopIfNeeded(topRootTask, intentGrants);
if (startResult != START_SUCCESS) {
return startResult;
}
}
if (mTargetRootTask == null) {
mTargetRootTask = getOrCreateRootTask(mStartActivity, mLaunchFlags, targetTask,
mOptions);
}
if (newTask) {
// 创建一个新的任务栈
final Task taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null)
? mSourceRecord.getTask() : null;
// 将 Activity 放入新建的任务栈
setNewTask(taskToAffiliate);
} else if (mAddingToTask) {
// 加入已有的任务栈
addOrReparentStartingActivity(targetTask, "adding to task");
}
if (!mAvoidMoveToFront && mDoResume) {
mTargetRootTask.getRootTask().moveToFront("reuseOrNewTask", targetTask);
if (!mTargetRootTask.isTopRootTaskInDisplayArea() && mService.isDreaming()
&& !dreamStopping) {
// Launching underneath dream activity (fullscreen, always-on-top). Run the launch-
// -behind transition so the Activity gets created and starts in visible state.
mLaunchTaskBehind = true;
r.mLaunchTaskBehind = true;
}
}
mService.mUgmInternal.grantUriPermissionUncheckedFromIntent(intentGrants,
mStartActivity.getUriPermissionsLocked());
if (mStartActivity.resultTo != null && mStartActivity.resultTo.info != null) {
// we need to resolve resultTo to a uid as grantImplicitAccess deals explicitly in UIDs
final PackageManagerInternal pmInternal =
mService.getPackageManagerInternalLocked();
final int resultToUid = pmInternal.getPackageUid(
mStartActivity.resultTo.info.packageName, 0 /* flags */,
mStartActivity.mUserId);
pmInternal.grantImplicitAccess(mStartActivity.mUserId, mIntent,
UserHandle.getAppId(mStartActivity.info.applicationInfo.uid) /*recipient*/,
resultToUid /*visible*/, true /*direct*/);
}
//......
if (mDoResume) {
final ActivityRecord topTaskActivity = startedTask.topRunningActivityLocked();
if (!mTargetRootTask.isTopActivityFocusable()
|| (topTaskActivity != null && topTaskActivity.isTaskOverlay()
&& mStartActivity != topTaskActivity)) {
//......
} else {
//......
//启动栈中顶部的Activity
mRootWindowContainer.resumeFocusedTasksTopActivities(
mTargetRootTask, mStartActivity, mOptions, mTransientLaunch);
}
}
mRootWindowContainer.updateUserRootTask(mStartActivity.mUserId, mTargetRootTask);
// Update the recent tasks list immediately when the activity starts
mSupervisor.mRecentTasks.add(startedTask);
mSupervisor.handleNonResizableTaskIfNeeded(startedTask,
mPreferredWindowingMode, mPreferredTaskDisplayArea, mTargetRootTask);
// If Activity's launching into PiP, move the mStartActivity immediately to pinned mode.
// Note that mStartActivity and source should be in the same Task at this point.
if (mOptions != null && mOptions.isLaunchIntoPip()
&& sourceRecord != null && sourceRecord.getTask() == mStartActivity.getTask()) {
mRootWindowContainer.moveActivityToPinnedRootTask(mStartActivity,
sourceRecord, "launch-into-pip");
}
return START_SUCCESS;
}
这个方法里主要是处理任务栈相关的逻辑，如果找到可用的任务栈则直接使用这个任务栈，如果没有找到，则新建一个任务栈。 在完成任务栈的处理之后通过mRootWindowContainer.resumeFocusedTasksTopActivities继续 Activity 的启动流程，这里的 mRootWindowContainer 是 RootWindowContainer 的实例，mRootWindowContainer.resumeFocursedTasksTopActivities方法的具体操作：
// frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java
boolean resumeFocusedTasksTopActivities(
Task targetRootTask, ActivityRecord target, ActivityOptions targetOptions,
boolean deferPause) {
//......
result |= resumedOnDisplay[0];
if (!resumedOnDisplay[0]) {
//获取当前屏幕设备的焦点任务栈
final Task focusedRoot = display.getFocusedRootTask();
if (focusedRoot != null) {
//如果焦点任务栈不为空则唤醒顶部的Activity
result |= focusedRoot.resumeTopActivityUncheckedLocked(target, targetOptions);
} else if (targetRootTask == null) {
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
}
}
return result;
}
mRootWindowContainer.resumeFocusedStacksToActivities()方法会恢复对应任务栈顶部的Activity，方法中会检查一些可见性相关的属性，后转交给Task调用resumeTopActivityUncheckedLocked方法来继续启动流程。
//frameworks/base/services/core/java/com/android/server/wm/Task.java
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
if (mInResumeTopActivity) {
// Don't even start recursing.
return false;
}
boolean someActivityResumed = false;
try {
// Protect against recursion.
mInResumeTopActivity = true;
if (isLeafTask()) {
//继续调用resumeTopActivityInnerLocked方法
if (isFocusableAndVisible()) {
someActivityResumed = resumeTopActivityInnerLocked(prev, options, deferPause);
}
} else {
int idx = mChildren.size() - 1;
while (idx >= 0) {
//......
someActivityResumed |= child.resumeTopActivityUncheckedLocked(prev, options, deferPause);
}
}
final ActivityRecord next = topRunningActivity(true /* focusableOnly */);
if (next == null || !next.canTurnScreenOn()) {
checkReadyForSleep();
}
} finally {
mInResumeTopActivity = false;
}
return someActivityResumed;
}
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
return resumeTopActivityUncheckedLocked(prev, options, false /* skipPause */);
}
@GuardedBy("mService")
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
if (!mAtmService.isBooting() && !mAtmService.isBooted()) {
// Not ready yet!
return false;
}
// 任务栈栈顶正在运行的 Activity
final ActivityRecord topActivity = topRunningActivity(true /* focusableOnly */);
if (topActivity == null) {
// 空任务栈 There are no activities left in this task, let's look somewhere else.
return resumeNextFocusableActivityWhenRootTaskIsEmpty(prev, options);
}
final boolean[] resumed = new boolean[1];
final TaskFragment topFragment = topActivity.getTaskFragment();
//调用TaskFragment的一个关键方法resumeTopActivity来继续唤醒顶部Activity
resumed[0] = topFragment.resumeTopActivity(prev, options, deferPause);
// ...
return resumed[0];
}
在 Task 的 resumeTopActivityUncheckedLocked 方法中进而又调用了resumeTopActivityUncheckedLocked，在 resumeTopActivityInnerLocked 中通过 TaskFragment 调用了 resumeTopActivity，接着来看 TaskFragment 中的实现。
//frameworks/base/services/core/java/com/android/server/wm/TaskFragment.java
final boolean resumeTopActivity(ActivityRecord prev, ActivityOptions options,
boolean deferPause) {
ActivityRecord next = topRunningActivity(true /* focusableOnly */);
if (next == null || !next.canResumeByCompat()) {
return false;
}
//......
//如果我们当前正在暂停一项活动，那么在该活动完成之前不要执行任何操作。
final boolean allPausedComplete = mRootWindowContainer.allPausedActivitiesComplete();
if (!allPausedComplete) {
ProtoLog.v(WM_DEBUG_STATES,
"resumeTopActivity: Skip resume: some activity pausing.");
return false;
}
mTaskSupervisor.mStoppingActivities.remove(next);
mTaskSupervisor.setLaunchSource(next.info.applicationInfo.uid);
boolean pausing = !deferPause && taskDisplayArea.pauseBackTasks(next);
if (mResumedActivity != null) {
// 暂停栈顶的Activity
pausing |= startPausing(mTaskSupervisor.mUserLeaving, false /* uiSleeping */,
next, "resumeTopActivity");
}
if (next.attachedToProcess()) {
//......
ActivityRecord lastResumedActivity =
lastFocusedRootTask == null ? null
: lastFocusedRootTask.getTopResumedActivity();
//......
try {
// 开启一个事务
final ClientTransaction transaction =
ClientTransaction.obtain(next.app.getThread(), next.token);
//......
// 添加 onNewIntent 的 callback ，最终会在APP端执行 onNewIntent()
if (next.newIntents != null) {
transaction.addCallback(
NewIntentItem.obtain(next.newIntents, true /* resume */));
}
//设置 Activity 最终的生命周期状态为 Resume
transaction.setLifecycleStateRequest(
ResumeActivityItem.obtain(next.app.getReportedProcState(),
dc.isNextTransitionForward()));
// 开始执行事务
mAtmService.getLifecycleManager().scheduleTransaction(transaction);
} catch (Exception e) {
//......
//启动 Activity
mTaskSupervisor.startSpecificActivity(next, true, false);
return true;
}
} else {
// 启动 Activity
mTaskSupervisor.startSpecificActivity(next, true, true);
}
return true;
}
resumeTopActivity 方法中主要有两部分内容。
next.attachedToProcess() 为 true，即要启动的这个 Activity 已经存在，并且设置了像“singleInstance” 的启动模式，无需重新创建 Activity 的情况下，则先通过 ClientTransaction 添加了一个 NewIntentItem 的 callback，接下来通过 setLifecycleStateRequest 设置了一个 ResumeActivityItem 对象。 next.attachedToProcess() 为 false ，则会调用mTaskSupervisor.StartSpecificActivity()开启指定的activity ，代码如下：
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
//获取目标进程
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
//进程已经创建的话，直接启动activity
if (wpc != null && wpc.hasThread()) {
try {
//Activity的启动事务就是在realStartActivityLoked方法中启动
//如果进程存在，启动Activity并返回
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
//......
}
//......
}
在该方法中ActivityTaskSupervisor.startSpecificActivity()方法中获取WindowProcessController,通过wpc.hasThread()方法判断应用进程是否已创建并运行中，其内部是通过IApplicationThread是否已经被赋值来判断的，如果已被赋值则表示应用进程已创建且运行中，此时进入判断体内部，走ActivityTaskSupervisor.realStartActivityLocked()方法继续Activity的启动流程，即普通Activity的启动流程。如果未被赋值，则需要创建。在这里我们先看进程已经创建并且执行realStartActivity()方法
//frameworks/base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
// ...
final Task task = r.getTask();
final Task rootTask = task.getRootTask();
try {
// ...
// 创建启动 Activity 的事务
final ClientTransaction clientTransaction = ClientTransaction.obtain(
proc.getThread(), r.token);
final boolean isTransitionForward = r.isTransitionForward();
final IBinder fragmentToken = r.getTaskFragment().getFragmentToken();
// 添加启动 Activity 的 callback，执行launchActivity
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.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
results, newIntents, r.takeOptions(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken));
// Activity 启动后最终的生命周期状态
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
// 将最终生命周期设置为 Resume 状态
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
// 将最终生命周期设置为 Pause 状态
lifecycleItem = PauseActivityItem.obtain();
}
// 设置 Activity 启动后最终的生命周期状态
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// 开启事务
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
// ...
} catch (RemoteException e) {
// ...
}
} finally {
// ...
}
// ...
return true;
}
realStartActivityLocked方法中获取了一个ClientTransaction实例，并调用了它的addCallback方法，与上面的不同的是这里添加了一个LaunchActivityItem实例
3、线程切换及消息处理——mH
ClientTransaction
ClientTransaction是包含了一系列要执行的事务项的事务。我们可以通过调用它的addCallback方法来添加一个事务项，你也可以多次调用来添加多个事务项。addCallback接收的参数类型为ClientTransactionItem,而这个ClientTransactionItem有多个子类，例如上面已经出现的NewIntentItem、LaunchActivityItem等都是其子类。 另外可以通过ClientTransactionItem的setLifecycleStateRequest方法设置Activity执行完后最终的生命周期状态，其参数的类型为ActivityLifecycleItem。ActivityLifecycleItem也是继承自ClientTransactionItem。同时ActivityLifecycleItem也有多个子类，它的每个子类都对应了Activity的一个生命周期事件。 在完成callback与LifecycleStateRequest的设置之后，便通过调用 mService.getLifecycleManager().scheduleTransaction(clientTransaction)方法开启事务项的执行。 这里的mService.getLifecycleManager()获取到的是什么呢？跟踪ActivityTaskManagerService源码我们可以找到getLifecycleManager的代码如下:
frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
ClientLifecycleManager getLifecycleManager() {
return mLifecycleManager;
}
getLifecycleManager返回了一个ClientLifecycleManager的实例，并调用了scheduleTransaction方法，代码如下：
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
transaction.recycle();
}
}
核心代码是调用了 ClientTransaction 的 schedule 方法，schedule 方法源码如下：
//frameworks/base/core/java/android/app/ClientTransaction.java
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
在 schedule 方法中通过 mClient 调用了 scheduleTransaction， 这里的 mClient 即为 IApplicationThread，这个参数是在实例化 ClientTransaction 时传进来的，IApplicationThread 是一个aidl 类，那么通过编译后它会生成一个 IApplicationThread.Stub 类，ActivityThread中ApplicationThread 就是继承了IApplicationThread.Stub。
//frameworks/base/core/java/android/app/ActivityThread#ApplicationThread
private class ApplicationThread extends IApplicationThread.Stub {
// ...
}
在ActivityThread的类里面发现没有实现scheduleTransaction方法，想到子类可以调用父类的方法，ActivityThread继承了ClientTransactionHandler，所以可以去ClientTransactionHandler.java类里面去查找scheduleTransaction方法,
//frameworks/base/core/java/android/app/ClientTransactionHandler
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
ClientTransaction#transaction作为参数调用了sendMessage方法:
void sendMessage(int what, Object obj) {
sendMessage(what, obj, 0, 0, false);
}
private void sendMessage(int what, Object obj, int arg1) {
sendMessage(what, obj, arg1, 0, false);
}
private void sendMessage(int what, Object obj, int arg1, int arg2) {
sendMessage(what, obj, arg1, arg2, false);
}
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);
}
mH.sendMessage(msg);
}
**【反向推理重复】**最终将ClientTransaction与EXECUTE_TRANSACTION打包成一个message，并且将这个message设置成了异步消息，最终通过mH发送了出去，这里的mH是一个继承自Handler的H类，位于ActivityThread类的内部。 H类的内部是如何处理这条消息的，EXECUTE_TRANSACTION可以看到如下代码：
// frameworks/base/core/java/android/app/ActivityThread#H
public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
// ...
break;
}
}
通过 Message 拿到 ClientTransaction 后，然后通过 TransactionExecutor 的 execute 方法来执行 ClientTransaction:
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public void execute(ClientTransaction transaction) {
// ...
// 执行 callback
executeCallbacks(transaction);
//处理生命周期状态
executeLifecycleState(transaction);
mPendingActions.clear();
}
这个方法里的执行逻辑可以分为两部分： 1、通过executeCallbacks方法执行所有被添加进来的ClientTransactionItem 2、通过executeLifecycleState方法将Activity的生命周期执行到指定的状态。
executeCallbacks方法分析
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null || callbacks.isEmpty()) {
return;
}
final IBinder token = transaction.getActivityToken();
ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
: UNDEFINED;
// Index of the last callback that requests some post-execution state.
final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
final int size = callbacks.size();
//遍历callbacks数组
for (int i = 0; i < size; ++i) {
//从callbacks数组中取出item
final ClientTransactionItem item = callbacks.get(i);
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callback: " + item);
final int postExecutionState = item.getPostExecutionState();
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState, transaction);
}
//调用launchActivityItem的execute方法
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
//......
}
}
在 executeCallbacks 中遍历了所有的 ClientTransactionItem 并执行了 ClientTransactionItem 的 execute 方法。前面我们分析了，当 Activity 正常启动时，通过 addCallback 添加的是一个 LaunchActivityItem 的实例。以此为例，这里就会首先执行 LaunchActivityItem 的 execute 方法，进而执行 Activity 的实例化及 onCreate 生命周期的调用。这块源码留作后边再来分析。
ClientTransactionItem
ClientTransactionItem 有多个实现类，这些实现类对应了 Activity 中不同的执行流程。例如在 Activity 启动时如果不需要重新创建 Activity ，则会通过 addCallback 添加了一个 NewIntentItem 来执行 Activity 的 onNewIntennt 方法。而当需要重新创建 Activity 时，则传入的是一个 LaunchActivityItem，用来创建并启动Activity。
ClientTransactionItem 的所有子类或相关类均在 frameworks/base/core/java/android/app/servertransaction/ 目录下，如下图所示：
上文中提到的 ActivityLifecycleItem 继承自 ActivityTransactionItem#ClientTransactionItem ，且其子类均为 Activity 生命周相关的实现，例如，StartActivityItem、ResumeActivityItem、DestroyActivityItem 等。显而易见的是，这里将 Activity 的生命周期以及其它相关方法以面向对象的思想封装成了一个个的对象来执行。相比早些年的 Android 版本代码，所有生命周期以及相关方法都通过 Handler 的 sendMessage 的方式发送出来，这种面向对象的思想的逻辑更加清晰，且代码更容易维护。
public abstract class ActivityLifecycleItem extends ActivityTransactionItem {
@IntDef(prefix = { "UNDEFINED", "PRE_", "ON_" }, value = {
UNDEFINED,
PRE_ON_CREATE,
ON_CREATE,
ON_START,
ON_RESUME,
ON_PAUSE,
ON_STOP,
ON_DESTROY,
ON_RESTART
})
@Retention(RetentionPolicy.SOURCE)
public @interface LifecycleState{}
public static final int UNDEFINED = -1;
public static final int PRE_ON_CREATE = 0;
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public static final int ON_PAUSE = 4;
public static final int ON_STOP = 5;
public static final int ON_DESTROY = 6;
public static final int ON_RESTART = 7;
/** A final lifecycle state that an activity should reach. */
@LifecycleState
public abstract int getTargetState();
/** Called by subclasses to make sure base implementation is cleaned up */
@Override
public void recycle() {
}
}
executeLifecycleState函数
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void executeLifecycleState(ClientTransaction transaction) {
//获取ActivityLifecycleItem，我们知道这里获取的是我们之前添加的ResumeActivityItem
//其值是由第14步ActivityStackSupervisor中的realStartActivityLocked函数
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
+ lifecycleItem + " for activity: "
+ getShortActivityName(token, mTransactionHandler));
}
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
//ResumeActivityItem的getTargetState 是 ON_RESUME
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
//ResumeActivityItem 的 execute
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
关键点在于 cycleToPath 。同时，通过 lifecycleItem.getTargetState() 作为结束时的生命周期状态。由于此时设置的是一个 ResumeActivityItem(ctivityTaskSupervisor.java#realStartActivityLocked中setLifecycleStateRequest 设置的是一个 ResumeActivityItem)，它的 getTargetState 返回的是一个 ON_RESUME 的值，代码如下:
// frameworks/base/core/java/android/app/servertransaction/ResumeActivityItem.java
@Override
public int getTargetState() {
return ON_RESUME;
}
**cycleToPath **源码：
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
ClientTransaction transaction) {
// 获取当前 Activity 的生命周期状态，即开始时的状态
final int start = r.getLifecycleState();
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Cycle activity: "
+ getShortActivityName(r.token, mTransactionHandler)
+ " from: " + getStateName(start) + " to: " + getStateName(finish)
+ " excludeLastState: " + excludeLastState);
}
// 获取要执行的生命周期数组
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
// 按顺序执行 Activity 的生命周期
performLifecycleSequence(r, path, transaction);
}
getLifecyclePath源码做了什么：
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutorHelper.java
@VisibleForTesting
public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {
if (start == UNDEFINED || finish == UNDEFINED) {
throw new IllegalArgumentException("Can't resolve lifecycle path for undefined state");
}
if (start == ON_RESTART || finish == ON_RESTART) {
throw new IllegalArgumentException(
"Can't start or finish in intermittent RESTART state");
}
if (finish == PRE_ON_CREATE && start != finish) {
throw new IllegalArgumentException("Can only start in pre-onCreate state");
}
mLifecycleSequence.clear();
if (finish >= start) {
if (start == ON_START && finish == ON_STOP) {
// A case when we from start to stop state soon, we don't need to go
// through the resumed, paused state.
mLifecycleSequence.add(ON_STOP);
} else {
// just go there
for (int i = start + 1; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
} else { // finish < start, can't just cycle down
if (start == ON_PAUSE && finish == ON_RESUME) {
// Special case when we can just directly go to resumed state.
mLifecycleSequence.add(ON_RESUME);
} else if (start <= ON_STOP && finish >= ON_START) {
// Restart and go to required state.
// Go to stopped state first.
for (int i = start + 1; i <= ON_STOP; i++) {
mLifecycleSequence.add(i);
}
// Restart
mLifecycleSequence.add(ON_RESTART);
// Go to required state
for (int i = ON_START; i <= finish; i++) {
mLifecycleSequence.add(i);
}
} else {
// Relaunch and go to required state
// Go to destroyed state first.
for (int i = start + 1; i <= ON_DESTROY; i++) {
mLifecycleSequence.add(i);
}
// Go to required state
for (int i = ON_CREATE; i <= finish; i++) {
mLifecycleSequence.add(i);
}
}
}
// Remove last transition in case we want to perform it with some specific params.
if (excludeLastState && mLifecycleSequence.size() != 0) {
mLifecycleSequence.remove(mLifecycleSequence.size() - 1);
}
return mLifecycleSequence;
}
根据上边分析，此时的 start 为 ON_CREATE（值为 1），而 finish 的值为 ON_RESUME(值为 2)。因此，执行完 getLifecyclePath 后，会得到一个包含了 ON_START 与 ON_RESUME 的数组
performLifecycleSequence中的代码：
// frameworks/base/core/java/android/app/servertransaction/TransactionExecutor.java
private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
ClientTransaction transaction) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Transitioning activity: "
+ getShortActivityName(r.token, mTransactionHandler)
+ " to state: " + getStateName(state));
}
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions,
null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions,
null /* activityOptions */);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r, false /* finalStateRequest */,
r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r, false /* finished */,
false /* userLeaving */, 0 /* configChanges */,
false /* autoEnteringPip */, mPendingActions,
"LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r, 0 /* configChanges */,
mPendingActions, false /* finalStateRequest */,
"LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r, false /* finishing */,
0 /* configChanges */, false /* getNonConfigInstance */,
"performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
executeLifecycleState的执行，当这个函数执行完成cycleToPath函数之后（里面会触发ActivityThread的handleStartActivity去执行acitivty的onStart 生命周期）就会运行lifecycleItem.execute(mTransactionHandler, token, mPendingActions)。lifecycleItem在executeLifecycleState 中我们知道lifecycleItem的值是ResumeActivityItem，此时代码就会运行到ResumeActivityItem#execute(),最后会调用ActivityThread的handleResumeActivity(),进而执行Activity的onResume生命周期
阶段小结
当前阶段，主要是在Application进程通过跨进程接收从ATMS封装好的ClientTransaction对象，ClientTransaction对象里面封装了需要App进程执行Activity生命周期的所有的事件，然后在activity所在的进程中，按照触发器的触发逻辑，顺序的执行activity的 创建->attach->onCreate->onStart->onResume生命周期。 在ATMS进程中的会通过ActivityTaskSupervisor将activity启动相关的事件封装成为一个ClientTransaction对象，然后由ClientLifecycleManager通过ClientTransaction的函数将ClientTransaction对象以跨进程通信的方式传递给ApplicationThread。在完成了跨进程后，这个触发器所携带的命令就会在Application进程中得到触发。Application所在的进程会通过Handler来启动触发器TransactionExecutor的执行。TransactionExecutor会按照ATMS中设置的逻辑，逐步去分发Activity的生命周期，直到整个触发器所携带的生命周期状态被执行完成为止，也就是onResume状态得到执行为止。
4、Activity启动核心实现——Activity的创建与生命周期的执行
onCreate方法
Activity的启动是在服务端通过添加一个LaunchActivityItem到ClientTransaction中实现的，然后通过IApplicationThread跨进程将ClientTransaction传到了客户端来执行的。客户端通过遍历ClientTransaction中的所有ClientTransactionItem，并执行了它的execute方法进而来执行Activity的创建过程。那接下来看LaunchActivityItem的execute方法调用后到底是如何执行的
//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, mActivityOptions, mIsForward, mProfilerInfo,
client, mAssistToken, mShareableActivityToken, mLaunchedFromBubble,
mTaskFragmentToken);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
LaunchActivityItem的execute方法调用了ClientTransactionHandler的handleLaunchActivity，而这里的ClientTransactionHandler就是ActivityThread。ActivityThread中的handleLaunchActivity的源码如下：
//frameworks/base/core/java/android/app/ActivityThread.java
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
// 如果我们在进入后台后准备进行垃圾回收，那么
// 我们又恢复活动了，所以跳过它。
unscheduleGcIdler();
//......
WindowManagerGlobal.initialize();
//......
final Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfigurationController.getConfiguration());
reportSizeConfigurations(r);
if (!r.activity.mFinished && pendingActions != null) {
pendingActions.setOldState(r.state);
pendingActions.setRestoreInstanceState(true);
pendingActions.setCallOnPostCreate(true);
}
} else {
// 如果出于任何原因出现错误，请告诉活动管理器阻止我们。
ActivityClient.getInstance().finishActivity(r.token, Activity.RESULT_CANCELED,
null /* resultData */, Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
}
return a;
}
在 handleLaunchActivity 方法中首先去初始化了 WindowManagerGlobal，紧接着调用了 performLaunchActivity 并返回了一个 Activity 实例，那么 Activity 的实例化必定是在 performLaunchActivity 中完成的。
//frameworks/base/core/java/android/app/ActivityThread.java
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//Activity的创建信息
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
//获取上下文
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
//拿到类加载器
java.lang.ClassLoader cl = appContext.getClassLoader();
//实例化
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess(isProtectedComponent(r.activityInfo),
appContext.getAttributionSource());
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
try {
Application app = r.packageInfo.makeApplicationInner(false, mInstrumentation);
if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
if (localLOGV) Slog.v(
TAG, r + ": app=" + app
+ ", appName=" + app.getPackageName()
+ ", pkg=" + r.packageInfo.getPackageName()
+ ", comp=" + r.intent.getComponent().toShortString()
+ ", dir=" + r.packageInfo.getAppDir());
// updatePendingActivityConfiguration()从mActivities中读取进行更新
// 在不同线程中运行的 ActivityClientRecord。 保护对以下内容的修改
// mActivities 以避免抢占。
synchronized (mResourcesManager) {
mActivities.put(r.token, r);
}
if (activity != null) {
//......
// 必须使用与 Activity 相同的加载器来初始化 Activity 资源
// 应用程序上下文。
appContext.getResources().addLoaders(
app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
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.activityConfigCallback,
r.assistToken, r.shareableActivityToken);
//......
r.activity = activity;
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
//......
}
r.setState(ON_CREATE);
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to start activity " + component
+ ": " + e.toString(), e);
}
}
return activity;
}
我们可以知道在ActivityThread的performLaunchActivity 方法里面Instrumentation通过newActivity实例化了Activity，接着调用了Activity的attach方法
//frameworks/base/core/java/android/app/Activity.java
final void attach(Context context, ActivityThread aThread,
Instrumentation instr, IBinder token, int ident,
Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
NonConfigurationInstances lastNonConfigurationInstances,
Configuration config, String referrer, IVoiceInteractor voiceInteractor,
Window window, ActivityConfigCallback activityConfigCallback, IBinder assistToken,
IBinder shareableActivityToken) {
attachBaseContext(context);
mFragments.attachHost(null /*parent*/);
//创建PhoneWindow
mWindow = new PhoneWindow(this, window, activityConfigCallback);
mWindow.setWindowControllerCallback(mWindowControllerCallback);
//将Activity 自身设置到 PhoneWindow
mWindow.setCallback(this);
mWindow.setOnWindowDismissedCallback(this);
mWindow.getLayoutInflater().setPrivateFactory(this);
if (info.softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED) {
mWindow.setSoftInputMode(info.softInputMode);
}
if (info.uiOptions != 0) {
mWindow.setUiOptions(info.uiOptions);
}
//Activity的当前线程就是UIThread
mUiThread = Thread.currentThread();
mMainThread = aThread;
mInstrumentation = instr;
mToken = token;
mAssistToken = assistToken;
mShareableActivityToken = shareableActivityToken;
mIdent = ident;
mApplication = application;
mIntent = intent;
mReferrer = referrer;
mComponent = intent.getComponent();
mActivityInfo = info;
mTitle = title;
mParent = parent;
mEmbeddedID = id;
mLastNonConfigurationInstances = lastNonConfigurationInstances;
if (voiceInteractor != null) {
if (lastNonConfigurationInstances != null) {
mVoiceInteractor = lastNonConfigurationInstances.voiceInteractor;
} else {
mVoiceInteractor = new VoiceInteractor(voiceInteractor, this, this,
Looper.myLooper());
}
}
//将PhoneWindow关联到WindowManager
mWindow.setWindowManager(
(WindowManager)context.getSystemService(Context.WINDOW_SERVICE),
mToken, mComponent.flattenToString(),
(info.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0);
if (mParent != null) {
mWindow.setContainer(mParent.getWindow());
}
//在Activity中持有windowManager
mWindowManager = mWindow.getWindowManager();
mCurrentConfig = config;
mWindow.setColorMode(info.colorMode);
mWindow.setPreferMinimalPostProcessing(
(info.flags & ActivityInfo.FLAG_PREFER_MINIMAL_POST_PROCESSING) != 0);
getAutofillClientController().onActivityAttached(application);
setContentCaptureOptions(application.getContentCaptureOptions());
}
Instrumentation执行了Activity的callActivityOnCreate方法：
public void callActivityOnCreate(Activity activity, Bundle icicle,
PersistableBundle persistentState) {
prePerformCreate(activity);
activity.performCreate(icicle, persistentState);
postPerformCreate(activity);
}
onStart方法
//frameworks/base/core/java/android/app/ActivityThread.java
@Override
public void handleStartActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, ActivityOptions activityOptions) {
final Activity activity = r.activity;
if (!r.stopped) {
throw new IllegalStateException("Can't start activity that is not stopped.");
}
if (r.activity.mFinished) {
// TODO(lifecycler): How can this happen?
return;
}
// 如果我们在进入后台后准备进行垃圾回收，那么
// 我们又恢复活动了，所以跳过它。
unscheduleGcIdler();
if (activityOptions != null) {
activity.mPendingOptions = activityOptions;
}
//调用Activity的performStart进而执行onStart
activity.performStart("handleStartActivity");
//将生命周期状态设置为on_start
r.setState(ON_START);
if (pendingActions == null) {
// No more work to do.
return;
}
//.....
// Call postOnCreate()
if (pendingActions.shouldCallOnPostCreate()) {
activity.mCalled = false;
if (r.isPersistable()) {
mInstrumentation.callActivityOnPostCreate(activity, r.state,
r.persistentState);
} else {
mInstrumentation.callActivityOnPostCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString()
+ " did not call through to super.onPostCreate()");
}
}
updateVisibility(r, true /* show */);
mSomeActivitiesChanged = true;
}
onResume方法
onResume 方法是通过 ActivityThread 的 handleResumeActivity 来执行：
// frameworks/base/core/java/android/app/ActivityThread.java
@Override
public void handleResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
boolean isForward, String reason) {
//......
// 防止两次 r.mFinish = true 的情况，跳过以下步骤。
if (!performResumeActivity(r, finalStateRequest, reason)) {
return;
}
//......
if (r.window == null && !a.mFinished && willBeVisible) {
//获取PhoneWindow
r.window = r.activity.getWindow();
//获取DecorView
View decor = r.window.getDecorView();
//设置DecorView不可见
decor.setVisibility(View.INVISIBLE);
//获取WindowManager
ViewManager wm = a.getWindowManager();
//获取window的属性参数
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (r.mPreserveWindow) {
a.mWindowAdded = true;
r.mPreserveWindow = false;
// 通常 ViewRoot 会与 Activity 设置回调
// 在 addView->ViewRootImpl#setView 中。 如果我们重用
// 装饰视图我们必须通知视图根
// 回调可能已更改。
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
}
if (a.mVisibleFromClient) {
if (!a.mWindowAdded) {
a.mWindowAdded = true;
//通过WindowManager将DecorView添加到窗口
wm.addView(decor, l);
} else {
a.onWindowAttributesChanged(l);
}
}
// If the window has already been added, but during resume
// we started another activity, then don't yet make the
// window visible.
} else if (!willBeVisible) {
if (localLOGV) Slog.v(TAG, "Launch " + r + " mStartedActivity set");
r.hideForNow = true;
}
//.....
Looper.myQueue().addIdleHandler(new Idler());
}
handleResumeActivity方法中的逻辑比较复杂，但核心主要有两点： 1、调用performResumeActivity执行onResume的生命周期 2、将DecorView添加到Window中。 先来看performResumeActivity方法其源码如下：
// frameworks/base/core/java/android/app/ActivityThread.java
public boolean performResumeActivity(ActivityClientRecord r, boolean finalStateRequest,
String reason) {
//......
//执行activity的performResume进而执行onResume
r.activity.performResume(r.startsNotResumed, reason);
r.state = null;
r.persistentState = null;
//设置为onResume
r.setState(ON_RESUME);
reportTopResumedActivityChanged(r, r.isTopResumedActivity, "topWhenResuming");
} catch (Exception e) {
if (!mInstrumentation.onException(r.activity, e)) {
throw new RuntimeException("Unable to resume activity "
+ r.intent.getComponent().toShortString() + ": " + e.toString(), e);
}
}
return true;
}
在performResumeActivity中先对Activity的状态进行了判断，如果符合状态，则会调用Activity的performResume方法，进而执行Activity的onResume。 在完成了performResume的调用后，performResumeActivity方法中接着执行了将DecorView添加到Window的过程，代码如上所示，可以看到核心就是wm.addView(decor,1)这行代码，通过ViewManager的addView方法将DecorView添加到了窗口中。窗口的添加过程会完成DecorView的布局、测量与绘制。当完成窗口的添加后Activity的View才被显示出来，且有了宽度。
二 、Launcher进程启动，反向日志堆栈分析
我们通过一些日志方向推理，我们先来介绍几个方法：
-
Log：Log.i("zxx","onCreate",new Exception())，在java层代码打印堆栈；
-
grep：grep "onCreate" ./ -rn，查看匹配字符在哪个文件出现；
在activity被启动优先调用onCreate方法，我们首先打印堆栈
// frameworks/base/core/java/android/app/Activity.java
protected void onCreate(@Nullable Bundle savedInstanceState) {
Log.i("zxx","onCreate",new Exception());
//......
}
02-01 08:12:05.820 1772 1772 I zxx : onCreate
02-01 08:12:05.820 1772 1772 I zxx : java.lang.Exception
02-01 08:12:05.820 1772 1772 I zxx : at android.app.Activity.onCreate(Activity.java:1633)
02-01 08:12:05.820 1772 1772 I zxx : at androidx.core.app.ComponentActivity.onCreate(ComponentActivity.java:88)
02-01 08:12:05.820 1772 1772 I zxx : at androidx.activity.ComponentActivity.onCreate(ComponentActivity.java:378)
02-01 08:12:05.820 1772 1772 I zxx : at androidx.fragment.app.FragmentActivity.onCreate(FragmentActivity.java:217)
02-01 08:12:05.820 1772 1772 I zxx : at com.android.car.carlauncher.CarLauncher.onCreate(CarLauncher.java:109)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.Activity.performCreate(Activity.java:8306)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.Activity.performCreate(Activity.java:8285)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1417)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:3626)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:3782)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.servertransaction.LaunchActivityItem.execute(LaunchActivityItem.java:101)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.servertransaction.TransactionExecutor.executeCallbacks(TransactionExecutor.java:135)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:95)
//关键行，我们关注一下这一行
02-01 08:12:05.820 1772 1772 I zxx : at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2307)
02-01 08:12:05.820 1772 1772 I zxx : at android.os.Handler.dispatchMessage(Handler.java:106)
02-01 08:12:05.820 1772 1772 I zxx : at android.os.Looper.loopOnce(Looper.java:201)
02-01 08:12:05.820 1772 1772 I zxx : at android.os.Looper.loop(Looper.java:288)
02-01 08:12:05.820 1772 1772 I zxx : at android.app.ActivityThread.main(ActivityThread.java:7872)
02-01 08:12:05.820 1772 1772 I zxx : at java.lang.reflect.Method.invoke(Native Method)
02-01 08:12:05.820 1772 1772 I zxx : at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:578)
02-01 08:12:05.820 1772 1772 I zxx : at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:946)
查看关键行，at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2307)，我们发现他是调用handleMessage的EXECUTE_TRANSACTION，所以我们查看一下，谁发送sendMessage
// frameworks/base/core/java/android/app/ActivityThread.java
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()) {
// 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;
}
}
//匹配关键字符
zhangxiaoxiao@ubuntu:~/aosp/frameworks$ grep "EXECUTE_TRANSACTION" ./ -rn
./base/boot/hiddenapi/hiddenapi-max-target-o.txt:1989:Landroid/app/ActivityThread$H;->EXECUTE_TRANSACTION:I
./base/core/java/android/app/ClientTransactionHandler.java:51: sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
./base/core/java/android/app/ActivityThread.java:2061: public static final int EXECUTE_TRANSACTION = 159;
./base/core/java/android/app/ActivityThread.java:2111: case EXECUTE_TRANSACTION: return "EXECUTE_TRANSACTION";
./base/core/java/android/app/ActivityThread.java:2305: case EXECUTE_TRANSACTION:
我们看到ClientTransactionHandler的51行发送sendMessage()，我们继续打印堆栈
// frameworks/base/core/java/android/app/ClientTransactionHandler.java
void scheduleTransaction(ClientTransaction transaction) {
Log.i("zxx","scheduleTransaction",new Exception());
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
//匹配关键字符
zhangxiaoxiao@ubuntu:~/aosp/frameworks$ grep "scheduleTransaction" ./ -rn
./base/boot/hiddenapi/hiddenapi-max-target-o.txt:1935:Landroid/app/ActivityThread$ApplicationThread;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/boot/hiddenapi/hiddenapi-max-target-o.txt:4628:Landroid/app/ClientTransactionHandler;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/boot/hiddenapi/hiddenapi-max-target-o.txt:6202:Landroid/app/IApplicationThread$Stub$Proxy;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/boot/hiddenapi/hiddenapi-max-target-o.txt:6256:Landroid/app/IApplicationThread$Stub;->TRANSACTION_scheduleTransaction:I
./base/boot/hiddenapi/hiddenapi-max-target-o.txt:6300:Landroid/app/IApplicationThread;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/boot/boot-image-profile.txt:843:HSPLandroid/app/ActivityThread$ApplicationThread;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/boot/boot-image-profile.txt:1384:HSPLandroid/app/ClientTransactionHandler;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/core/java/android/app/servertransaction/ClientTransaction.java:136: mClient.scheduleTransaction(this);
./base/core/java/android/app/ClientTransactionHandler.java:50: void scheduleTransaction(ClientTransaction transaction) {
./base/core/java/android/app/ClientTransactionHandler.java:51: Log.i("zxx","scheduleTransaction",new Exception());
./base/core/java/android/app/ActivityThread.java:1846: public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
./base/core/java/android/app/ActivityThread.java:1847: ActivityThread.this.scheduleTransaction(transaction);
./base/core/java/android/app/ActivityThread.java:3466: mAppThread.scheduleTransaction(clientTransaction);
./base/core/java/android/app/IApplicationThread.aidl:153: void scheduleTransaction(in ClientTransaction transaction);
./base/core/tests/coretests/src/android/app/servertransaction/TransactionParcelTests.java:409: public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:119: appThread.scheduleTransaction(newRelaunchResumeTransaction(activity));
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:120: appThread.scheduleTransaction(newRelaunchResumeTransaction(activity));
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:129: appThread.scheduleTransaction(newRelaunchResumeTransaction(activity));
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:130: appThread.scheduleTransaction(newResumeTransaction(activity));
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:336: appThread.scheduleTransaction(transaction);
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:342: appThread.scheduleTransaction(transaction);
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:384: appThread.scheduleTransaction(newActivityConfigTransaction(activity, config));
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:394: appThread.scheduleTransaction(newActivityConfigTransaction(activity, config));
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:399: appThread.scheduleTransaction(newActivityConfigTransaction(activity, config));
./base/core/tests/coretests/src/android/app/activity/ActivityThreadTest.java:404: appThread.scheduleTransaction(newActivityConfigTransaction(activity, config));
./base/config/boot-image-profile.txt:843:HSPLandroid/app/ActivityThread$ApplicationThread;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/config/boot-image-profile.txt:1384:HSPLandroid/app/ClientTransactionHandler;->scheduleTransaction(Landroid/app/servertransaction/ClientTransaction;)V
./base/services/core/java/com/android/server/wm/ActivityTaskSupervisor.java:926: mService.getLifecycleManager().scheduleTransaction(clientTransaction);
./base/services/core/java/com/android/server/wm/ActivityRecord.java:1409: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:1426: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:1447: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:2650: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:3771: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:4658: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:4684: mAtmService.getLifecycleManager().scheduleTransaction(transaction);
./base/services/core/java/com/android/server/wm/ActivityRecord.java:4760: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:5935: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:5949: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:6236: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/ActivityRecord.java:9212: mAtmService.getLifecycleManager().scheduleTransaction(transaction);
./base/services/core/java/com/android/server/wm/ActivityRecord.java:9282: mAtmService.getLifecycleManager().scheduleTransaction(app.getThread(), token,
./base/services/core/java/com/android/server/wm/WindowProcessController.java:1450: mAtm.getLifecycleManager().scheduleTransaction(thread,
./base/services/core/java/com/android/server/wm/ActivityClientController.java:912: mService.getLifecycleManager().scheduleTransaction(transaction);
./base/services/core/java/com/android/server/wm/ActivityClientController.java:934: mService.getLifecycleManager().scheduleTransaction(transaction);
./base/services/core/java/com/android/server/wm/TaskFragment.java:1453: mAtmService.getLifecycleManager().scheduleTransaction(transaction);
./base/services/core/java/com/android/server/wm/TaskFragment.java:1688: mAtmService.getLifecycleManager().scheduleTransaction(prev.app.getThread(),
./base/services/core/java/com/android/server/wm/ClientLifecycleManager.java:45: void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
./base/services/core/java/com/android/server/wm/ClientLifecycleManager.java:65: void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
./base/services/core/java/com/android/server/wm/ClientLifecycleManager.java:69: scheduleTransaction(clientTransaction);
./base/services/core/java/com/android/server/wm/ClientLifecycleManager.java:81: void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken,
./base/services/core/java/com/android/server/wm/ClientLifecycleManager.java:85: scheduleTransaction(clientTransaction);
./base/services/core/java/com/android/server/wm/ClientLifecycleManager.java:96: void scheduleTransaction(@NonNull IApplicationThread client,
./base/services/core/java/com/android/server/wm/ClientLifecycleManager.java:100: scheduleTransaction(clientTransaction);
根据上面你会发现，都是调用mAtmService.getLifecycleManager().scheduleTransaction()方法，那我们在里面打一下堆栈：
//frameworks/base/core/java/android/app/servertransaction/ClientTransaction
public void schedule() throws RemoteException {
Log.i("zxx","schedule",new Exception());
mClient.scheduleTransaction(this);
}
02-20 04:49:56.467 662 1538 I zxx : schedule
02-20 04:49:56.467 662 1538 I zxx : java.lang.Exception
02-20 04:49:56.467 662 1538 I zxx : at android.app.servertransaction.ClientTransaction.schedule(ClientTransaction.java:137)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ClientLifecycleManager.scheduleTransaction(ClientLifecycleManager.java:47)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ClientLifecycleManager.scheduleTransaction(ClientLifecycleManager.java:69)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskFragment.schedulePauseActivity(TaskFragment.java:1688)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskFragment.startPausing(TaskFragment.java:1627)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskFragment.startPausing(TaskFragment.java:1535)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskDisplayArea.lambda$pauseBackTasks$6(TaskDisplayArea.java:1301)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskDisplayArea$$ExternalSyntheticLambda6.accept(Unknown Source:6)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskFragment.forAllLeafTaskFragments(TaskFragment.java:1817)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskDisplayArea.lambda$pauseBackTasks$7$com-android-server-wm-TaskDisplayArea(TaskDisplayArea.java:1298)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskDisplayArea$$ExternalSyntheticLambda4.accept(Unknown Source:8)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.Task.forAllLeafTasks(Task.java:3149)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.Task.forAllLeafTasks(Task.java:3137)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.WindowContainer.forAllLeafTasks(WindowContainer.java:2013)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskDisplayArea.pauseBackTasks(TaskDisplayArea.java:1284)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.TaskFragment.resumeTopActivity(TaskFragment.java:1212)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.Task.resumeTopActivityInnerLocked(Task.java:4958)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.Task.resumeTopActivityUncheckedLocked(Task.java:4893)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.RootWindowContainer.resumeFocusedTasksTopActivities(RootWindowContainer.java:2258)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ActivityStarter.startActivityInner(ActivityStarter.java:1700)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ActivityStarter.startActivityUnchecked(ActivityStarter.java:1397)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ActivityStarter.executeRequest(ActivityStarter.java:1226)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ActivityStarter.execute(ActivityStarter.java:702)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ActivityTaskManagerService.startActivityAsUser(ActivityTaskManagerService.java:1293)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ActivityTaskManagerService.startActivityAsUser(ActivityTaskManagerService.java:1234)
02-20 04:49:56.467 662 1538 I zxx : at android.app.IActivityTaskManager$Stub.onTransact(IActivityTaskManager.java:952)
02-20 04:49:56.467 662 1538 I zxx : at com.android.server.wm.ActivityTaskManagerService.onTransact(ActivityTaskManagerService.java:5343)
02-20 04:49:56.467 662 1538 I zxx : at android.os.Binder.execTransactInternal(Binder.java:1344)
02-20 04:49:56.467 662 1538 I zxx : at android.os.Binder.execTransact(Binder.java:1275)
这时候我们就会发现ATMS调用了“startActivityAsUser”->"execute"->"executeRequest"->"startActivityUnchecked"->"startActivityInner"->"resumeFocusedTasksTopActivities"->"resumeTopActivityUncheckedLocked"->"resumeTopActivityInnerLocked"->"resumeTopActivity"和我们前面分析是一致的。
// frameworks/base/core/java/android/app/ContextImpl.java
/** @hide */
@Override
public void startActivityAsUser(Intent intent, Bundle options, UserHandle user) {
Log.e("zxx","Activity startActivityAsUser",new Exception());
try {
ActivityTaskManager.getService().startActivityAsUser(
mMainThread.getApplicationThread(), getOpPackageName(), getAttributionTag(),
intent, intent.resolveTypeIfNeeded(getContentResolver()),
null, null, 0, Intent.FLAG_ACTIVITY_NEW_TASK, null, options,
user.getIdentifier());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
02-27 06:32:52.650 2851 2851 E zxx : Activity startActivityAsUser
02-27 06:32:52.650 2851 2851 E zxx : java.lang.Exception
02-27 06:32:52.650 2851 2851 E zxx : at android.app.ContextImpl.startActivityAsUser(ContextImpl.java:1110)
02-27 06:32:52.650 2851 2851 E zxx : at android.content.ContextWrapper.startActivityAsUser(ContextWrapper.java:460)
02-27 06:32:52.650 2851 2851 E zxx : at com.android.systemui.car.systembar.CarSystemBarButton.lambda$getButtonClickListener$0(CarSystemBarButton.java:329)
02-27 06:32:52.650 2851 2851 E zxx : at com.android.systemui.car.systembar.CarSystemBarButton.$r8$lambda$9ueL4x0GeeYznw3a7AqfDCUbzdE(CarSystemBarButton.java:0)
02-27 06:32:52.650 2851 2851 E zxx : at com.android.systemui.car.systembar.CarSystemBarButton$$ExternalSyntheticLambda1.onClick(R8$$SyntheticClass:0)
02-27 06:32:52.650 2851 2851 E zxx : at android.view.View.performClick(View.java:7506)
02-27 06:32:52.650 2851 2851 E zxx : at android.view.View.performClickInternal(View.java:7483)
02-27 06:32:52.650 2851 2851 E zxx : at android.view.View.-$$Nest$mperformClickInternal(Unknown Source:0)
02-27 06:32:52.650 2851 2851 E zxx : at android.view.View$PerformClick.run(View.java:29345)
02-27 06:32:52.650 2851 2851 E zxx : at android.os.Handler.handleCallback(Handler.java:942)
02-27 06:32:52.650 2851 2851 E zxx : at android.os.Handler.dispatchMessage(Handler.java:99)
02-27 06:32:52.650 2851 2851 E zxx : at android.os.Looper.loopOnce(Looper.java:201)
02-27 06:32:52.650 2851 2851 E zxx : at android.os.Looper.loop(Looper.java:288)
02-27 06:32:52.650 2851 2851 E zxx : at android.app.ActivityThread.main(ActivityThread.java:7872)
02-27 06:32:52.650 2851 2851 E zxx : at java.lang.reflect.Method.invoke(Native Method)
02-27 06:32:52.650 2851 2851 E zxx : at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:578)
02-27 06:32:52.650 2851 2851 E zxx : at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:946)
三、总结、
1、通过源码，调用链路一步一步断点、日志，深入调用查看，查看最终实现；
2、通过逆向查看，日志和字符查找盲猜在继续日志标志，一些常用命令：
2.1、Log.e("zxx","Activity startActivityAsUser",new Exception()); java层代码打印堆栈；
2.2、grep "onCreate" ./ -rn，查看匹配字符在哪个文件出现；
2.3、adb shell 、logcat -c、logcat -s "zxx"
感谢
zhuanlan.zhihu.com/p/615272198 blog.csdn.net/yangfengxia… blog.csdn.net/datian1234/…
