一.重点角色
要将启动流程,首先介绍一下activity启动流程中几个重要的角色
Activity //activity本身的类对象
Instrumentation //代理操作activity所有流程的代理类
ActivityThread //app生命周期管理的实现类,一个app的启动,这个类里面的main函数就是入口
IApplicationThread //app进程中的ApplicationThread在系统进程中的bindler接口类
ActivityThread.ApplicationThread //上面接口类的具体实现
IActivityTaskManager //系统进程中的ActivityTaskManager在app进程中的binder的接口类
ActivityTaskManagerService //IActivityTaskManager的bindle接口类的具体实现
ActivityStarter //系统进程中负责APP中的activity管理的控制类
流程示意图:
二.代码调用逻辑
Activity
1.startActivity() ->
2.startActivityForResult() ->
Instrumentation
1.execStartActivity() ->
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
...
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
int result = ActivityTaskManager.getService()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mEmbeddedID : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
throw new RuntimeException("Failure from system", e);
}
return null;
}
ActivityTaskManager.getService()这里获取到的是是一个binder,binder的aidl是IActivityTaskManager,实现类是ActivityTaskManagerService。所以这里调用startActivity,最终会通过binder机制跨进程调用到ActvityTaskManagerService的startActvitiy()方法。
ActvityTaskManagerService
1.startActivity()
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());
}
这里接收到的caller为app进程中的ApplicationThead的binder对象,用于通知app进程进行相关的activity的操作。所以这里对象会一路作为参数传递下去。
2.startActivityAsUser()
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)
.execute();
}
这里getActivityStartController获取到的对象为ActivityStartController,最终的执行者是ActivityStarter。ActivityStarter来负责控制activity的启动流程。
各种set为标准的构造者模式,把必要的参数传到request当中,把request作为唯一参数往下传递,否则会导致方法参数太多。
ActivityStarter
1.execute()->
2.startActivity()->
3.startActivity()重载的方法1->
4.startActivity()重载的方法2->主要做了一些权限验证以及监控相关的功能
5.startActivity()重载的方法3->调用startActivityUnchecked
6.startActivityUnchecked()->这个是控制activity启动的主流程
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask,
ActivityRecord[] outActivity, boolean restrictedBgActivity) {
//设置初始状态
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession,
voiceInteractor, restrictedBgActivity);
final int preferredWindowingMode = mLaunchParams.mWindowingMode;
//计算应该使用哪种启动模式
computeLaunchingTaskFlags();
computeSourceStack();
mIntent.setFlags(mLaunchFlags);
ActivityRecord reusedActivity = getReusableIntentActivity();//获取是否有可复用的actvitiy,根据activity的启动模式来判定
mSupervisor.getLaunchParamsController().calculate(
reusedActivity != null ? reusedActivity.getTaskRecord() : mInTask,
r.info.windowLayout, r, sourceRecord, options, PHASE_BOUNDS, mLaunchParams);
...
if (dontStart) {
// For paranoia, make sure we have correctly resumed the top activity.
topStack.mLastPausedActivity = null;
if (mDoResume) {
mRootActivityContainer.resumeFocusedStacksTopActivities();//这里是下一步的入口方法,负责正在展示的activity隐藏和将要展示的activity的显示
}
...
return START_DELIVERED_TO_TOP;
}
...
return START_SUCCESS;
}
RootActivityContainer
resumeFocusedStacksTopActivities()->
resumeFocusedStacksTopActivities()->
boolean resumeFocusedStacksTopActivities(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
...
if (display.isTopStack(stack) && topRunningActivity.isState(RESUMED)) {
// Kick off any lingering app transitions form the MoveTaskToFront operation,
// but only consider the top task and stack on that display.
stack.executeAppTransition(targetOptions);
} else {
resumedOnDisplay |= topRunningActivity.makeActiveIfNeeded(target);//这里会把topRunning设置未不可见状态,并调用对应activity的pause()方法
}
}
if (!resumedOnDisplay) {
// In cases when there are no valid activities (e.g. device just booted or launcher
// crashed) it's possible that nothing was resumed on a display. Requesting resume
// of top activity in focused stack explicitly will make sure that at least home
// activity is started and resumed, and no recursion occurs.
final ActivityStack focusedStack = display.getFocusedStack();
if (focusedStack != null) {
focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
}
}
return result;
}
mStackSupervisor是ActivityStackSupervisor,则会调用startSpecificActivityLocked方法
ActivityStackSupervisor
1.ActivityStackSupervisor.startSpecificActivityLocked()
2.ActivityStackSupervisor.realStartActivityLocked()
生成一个ClientTransaction对象,这里面添加了两个任务,一个是launch目标activity,一个是resume目标Activity
LaunchActivityItem
ResumeActivityItem
添加了这两个任务添加到事物对象后,通过binder机制传递会ApplicationThread,由ApplicationThread处理这两个任务,由app的进程负责activity的launch和resume
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
...
final DisplayContent dc = r.getDisplay().mDisplayContent;
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));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(dc.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}