本文按照 App A的A activity 启动 App B的B activity 跟踪。
主线流程大概是这样的：
- A activity向AMS发起启动B activity的请求。
- AMS进行一系列的权限校验以及准备工作。
- 暂停A activity。
- 为AppB启动新进程。
- 在新进程内创建B activity，并启动
1.1 Activity -> startActivity
启动activity的入口，intent可为显式或隐式。
@Override
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
startActivityForResult(intent, -1);
}
}
1.2 Activity -> startActivityForResult()
requestCode<0表示不接收activity启动的结果,否则会回掉调用者activity的onActivityResult()方法。此处默认为-1.
options用于指定启动Activity的动画
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode,@Nullable Bundle options) {
if (mParent == null) {
...
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,intent, requestCode, options);
...
}
Instrumentation类监控着应用进程与系统的所有交互。
mMainThread.getApplicationThread()表示调用者主线程，mToken是调用者activity的代理，在AMS中可以获取对应的ActivityRecord。这两个参数是在ActivityThread调用activity.attach()方法时被赋值的。
1.3 Instrumentation -> execStartActivity
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) {
...
try { ...
//调用ActivityManager的getService()方法获取AMS得代理对象，接着调用AMS的startActivity方法
int result = ActivityManager.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;
}
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
此处，我们已经获取到了AMS的代理，接下来进入AMS进程。
2.1 AMS -> startActivity
/**
* @param caller : ApplicationThread，表示调用者的主线程
* @param callingPackage : 表示调用者的进程包名
* @param resultTo : 调用者Activity传来的token代理，对应AMS的ActivityRecord
**/
@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(..., UserHandle.getCallingUserId(),true /*validateIncomingUser*/);
}
public final int startActivityAsUser(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId, boolean validateIncomingUser) {
//通过userId检查调用者是否有权限启动Activity
enforceNotIsolatedCaller("startActivity");
userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser,Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser");
//获取ActivityStarter，并且执行启动流程
return mActivityStartController.obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId) //设置maywait=true
.execute();
}
首先通过userId进行一些权限校验，然后通过ActivityStartController获取ActivityStarter，设置一系列启动Activity所需要的参数并封装在Request里，最终通过execute()启动activity。
ActivityStartController管理启动activity的请求列表，真正的启动逻辑由ActivityStarter来处理。
class ActivityStarter {
//该类使用对象池，可复用，池内只有3个活跃对象
int execute() {
try {
if (mRequest.mayWait) { //在上一步setMayWait(userId）设置成true
return startActivityMayWait(mRequest.caller, mRequest.callingUid, mRequest.callingPackage, mRequest.intent, mRequest.resolvedType, mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo, mRequest.resultWho, mRequest.requestCode, mRequest.startFlags, mRequest.profilerInfo, mRequest.waitResult, mRequest.globalConfig, mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.userId, mRequest.inTask, mRequest.reason, mRequest.allowPendingRemoteAnimationRegistryLookup);
}else {
//...
}
} finally {
onExecutionComplete(); //最后，会调用ActivityStartController的对应方法，进行Starter的释放回收
}
}
}
2.2 ActivityStarter -> startActivityMayWait
final int startActivityMayWait(IApplicationThread caller, int callingUid, String callingPackage, Intent intent, String resolvedType, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, WaitResult outResult, Configuration globalConfig, Bundle bOptions, boolean ignoreTargetSecurity, int userId, TaskRecord inTask, String reason) {
...
intent = new Intent(intent);
...
//ActivityStackSupervisor通过PackageManager对intent进行解析，查询与intent匹配的Activity
ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId, 0 /* matchFlags */, computeResolveFilterUid(callingUid, realCallingUid, mRequest.filterCallingUid));
...
ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo);
synchronized (mService) {
...
final ActivityStack stack = mSupervisor.mFocusedStack;
final ActivityRecord[] outRecord = new ActivityRecord[1];
//调用startActivity()去执行，返回启动结果
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);
mSupervisor.getActivityMetricsLogger().notifyActivityLaunched(res, outRecord[0]);
return res;
}
通过resolveIntent找到匹配的Activity，然后在ActivityStarter中经过一连串的权限校验，包括检查调用方的权限、检查调用方是否需要返回结果、检查Intent是否正确、检查目标Activity是否存在、检查是否有startActivity权限、检查当前能否切换Activity(调用者activity是否进入pause/stop/destroy)。最终调用startActivityUnchecked()。
2.3 ActivityStarter -> startActivityUnchecked()
(前面的重载方法里check了无数次了，此处uncheck…)
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask, ActivityRecord[] outActivity) {
//初始化ActivityStarter的state，包括mLaunchMode ，mLaunchFlags等
setInitialState(r, options, inTask, doResume, startFlags, sourceRecord, voiceSession, voiceInteractor);
//计算与启动模式有关的Flag
computeLaunchingTaskFlags();
//计算targetActivity所属的Task
computeSourceStack();
mIntent.setFlags(mLaunchFlags);
ActivityRecord reusedActivity = getReusableIntentActivity(); //遍历遍历ActivityStack中所有的TaskRecord,遍历mHistory里面所有ActivityRecord，寻找可复用的Activity
if (reusedActivity != null) {
//......
//如果有可复用的activity，则会根据launchMode和launchFlags去做处理，通过clearTop去把targetActivity移到栈顶，然后执行deliverNewIntent()，也就对应着Activity中的onNewIntent()
}
//检查即将启动的Activity与当前栈顶的Activity是否相同
final ActivityStack topStack = mSupervisor.mFocusedStack;
final ActivityRecord topFocused = topStack.getTopActivity();
final ActivityRecord top = topStack.topRunningNonDelayedActivityLocked(mNotTop);
final boolean dontStart = top != null && mStartActivity.resultTo == null && top.realActivity.equals(mStartActivity.realActivity) && top.userId == mStartActivity.userId && top.app != null && top.app.thread != null && ((mLaunchFlags & FLAG_ACTIVITY_SINGLE_TOP) != 0 || isLaunchModeOneOf(LAUNCH_SINGLE_TOP, LAUNCH_SINGLE_TASK));
if (dontStart) { //相同则不需要重新启动
...
deliverNewIntent(top); //最终执行栈顶Activity的onNewIntent
...
return START_DELIVERED_TO_TOP;
}
//根据launchMode和Flags创建出targetActivity所属的TaskRecord，将这个task加入ActivityStack中，并且把这个栈切换到前台
//...
setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack);
//把targetActivity放到栈顶，设置可见性以及WMS准备切换动画等
mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition, mOptions);
//mDoResume 是否使目标activity立即可见
if (mDoResume) {
final ActivityRecord topTaskActivity = mStartActivity.getTask().topRunningActivityLocked();
//判断目标栈是否获取焦点
if (!mTargetStack.isFocusable() || (topTaskActivity != null && topTaskActivity.mTaskOverlay && mStartActivity != topTaskActivity)) {
mTargetStack.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
mService.mWindowManager.executeAppTransition();
} else {
//初次启动时未获得焦点，进入else分支
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions);
}
} else if (mStartActivity != null) {
mSupervisor.mRecentTasks.add(mStartActivity.getTask());
}
return START_SUCCESS;
}
总结：1.计算launchMode和Flags，2.确定是否有可以复用的activity和task，如果没有则新建，3.activity放入栈顶，task放入activityStack.
关于ActivityRecord,TaskRecord,ActivityStack,以及ActivityStackSupervisor的关系，可以参照下图。
以及对应的时序图
2.4 ActivityStackSupervisor -> resumeFocusedStackTopActivityLocked(params…)
boolean resumeFocusedStackTopActivityLocked(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (!readyToResume()) {
return false;
}
//targetStack已在前台
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
...
}
2.5 ActivityStack -> resumeTopActivityUncheckedLocked(params…)
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
//mStackSupervisor.inResumeTopActivity当前是否正在启动activity
if (mStackSupervisor.inResumeTopActivity) {
return false;
}
boolean result = false;
try {
mStackSupervisor.inResumeTopActivity = true;
result = resumeTopActivityInnerLocked(prev, options);
//...
}
} finally {
mStackSupervisor.inResumeTopActivity = false;
}
return result;
}
2.6 ActivityStack -> resumeTopActivityInnerLocked(params…)
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
//栈顶正在启动的Activity，即我们的targetActivity
final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */);
...
// mResumedActivity -> 正在运行的Activity -> A
// next-> 栈顶需要启动的targetActivity. -> B
//相同则返回
if (mResumedActivity == next && next.isState(RESUMED)
&& mStackSupervisor.allResumedActivitiesComplete()) {
//...
return false;
}
//如果屏幕关闭了，没有Activity需要启动，并且栈顶的Activity已经暂停，则返回
if (shouldSleepOrShutDownActivities()
&& mLastPausedActivity == next
&& mStackSupervisor.allPausedActivitiesComplete()) {
//...
return false;
}
//...
//确保该Activity的状态是正确的，从等待队列移除等
mStackSupervisor.mStoppingActivities.remove(next);
mStackSupervisor.mGoingToSleepActivities.remove(next);
next.sleeping = false;
mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(next);
//当前有Activity的pause操作还没有执行完毕，return
if (!mStackSupervisor.allPausedActivitiesComplete()) {
//...
return false;
}
//暂停后备堆栈中的所有Activity
boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false);
if (mResumedActivity != null) {
//在启动activity之前，暂停当前处于Resumed状态的Activity
pausing |= startPausingLocked(userLeaving, false, next, false);
}
ActivityStack lastStack = mStackSupervisor.getLastStack();
if (next.app != null && next.app.thread != null) {
//...
} else {
//此方法为真正启动Activity的地方，但此处调用不生效
//只有所有Activity全部处于暂停状态，才可以通过以下方法启动新的Activity
mStackSupervisor.startSpecificActivityLocked(next, true, true);
}
return true;
}
2.7 ActivityStack -> startPausingLocked(params…)
接下来需要暂停当前处于Resumed状态的Activity A
final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping,
ActivityRecord resuming, boolean pauseImmediately) {
ActivityRecord prev = mResumedActivity;
//...
//根据prev和resuming来判断是否需要执行pause操作
if (prev.app != null && prev.app.thread != null) {
try {
mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving, prev.configChangeFlags, pauseImmediately));
}
}
if (mPausingActivity != null) {
if (!uiSleeping) {
//在新Activity启动前，暂停key dispatch事件
prev.pauseKeyDispatchingLocked();
}
if (pauseImmediately) {
completePauseLocked(false, resuming);
return false;
} else {
//指定超时处理，防止无响应
schedulePauseTimeout(prev);
return true;
}
} else {
if (resuming == null) {
//如果Pause操作失败，只需要启动栈顶Activity
mStackSupervisor.resumeFocusedStackTopActivityLocked();
}
return false;
}
}
2.8 ClientLifecycleManager -> scheduleTransaction(params…)
void scheduleTransaction(@NonNull IApplicationThread client, @NonNull IBinder activityToken, @NonNull ActivityLifecycleItem stateRequest) throws RemoteException {
//将请求封装成ClientTransaction对象，ClientTransaction实现了Parcelable接口，可序列化，用于后续跨进程传输
final ClientTransaction clientTransaction = transactionWithState(client, activityToken, stateRequest);
scheduleTransaction(clientTransaction);
}
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
//执行后回收
transaction.recycle();
}
}
2.9 ClientTransaction -> schedule()
public void schedule() throws RemoteException {
//mClient为IApplicationThread，是调用者app的代理，此处从AMS进程切换到调用者进程
mClient.scheduleTransaction(this);
}
接下来进入调用者进程
3.1 IApplicationThread -> scheduleTransaction(transaction)
public final class ActivityThread extends ClientTransactionHandler {
//ApplicationThread为ActivityThread内部类
private class ApplicationThread extends IApplicationThread.Stub {
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
//此处实际上是交由ActivityThread的父类ClientTransactionHandler来实现
ActivityThread.this.scheduleTransaction(transaction);
}
}
}
3.2 ClientTransactionHandler -> scheduleTransaction(transaction)
public abstract class ClientTransactionHandler {
/** Prepare and schedule transaction for execution. */
void scheduleTransaction(ClientTransaction transaction) {
//执行一些之前添加的callback
transaction.preExecute(this);
//发送消息至主线程执行
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
}
3.3 ActivityThread -> sendMessage(params…)
最终接收消息的是ActivityThread中的H(handler)
public final class ActivityThread extends ClientTransactionHandler {
//...
class H extends Handler {
public void handleMessage(Message msg) {
//根据不同的消息类型进行不同的处理
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
if (isSystem()) {
transaction.recycle();
}
break;
}
}
}
}
3.4 TransactionExecutor -> execute(ClientTransaction)
public void execute(ClientTransaction transaction) {
...
executeCallbacks(transaction); //pause操作没有添加callback
//执行pause操作
executeLifecycleState(transaction);
mPendingActions.clear();
log("End resolving transaction");
}
3.5 TransactionExecutor -> executeLifecycleState(transaction)
/** Transition to the final state if requested by the transaction. */
private void executeLifecycleState(ClientTransaction transaction) {
//此处为PauseLifecycleItem.
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
final IBinder token = transaction.getActivityToken();
//ActivityClientRecord在App中的作用，相当于ActivityRecord在AMS中的作用
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
//把ActivityClientRecord的状态切换到target状态，这里是pause，表示把Activity切换到暂停状态
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */);
// Execute the final transition with proper parameters.
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
//此处会调用到ActivityManager.getService().activityPaused(token);通知AMS完成了pause操作
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
private void cycleToPath(ActivityClientRecord r, int finish,
boolean excludeLastState) {
final int start = r.getLifecycleState();
//计算出状态变化路径
//比如：onCreate->onResume的变化路径有：onStart、onResume等(不包括初始状态)
final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
performLifecycleSequence(r, path); //沿着此路径依次切换状态
}
/** 该方法把Activity的状态沿着路径进行切换 */
private void performLifecycleSequence(ActivityClientRecord r, IntArray path) {
final int size = path.size();
for (int i = 0, state; i < size; i++) {
state = path.get(i);
switch (state) {
case ON_CREATE:
mTransactionHandler.handleLaunchActivity(r, mPendingActions, null /* customIntent */);
break;
case ON_START:
mTransactionHandler.handleStartActivity(r, mPendingActions);
break;
case ON_RESUME:
mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */, r.isForward, "LIFECYCLER_RESUME_ACTIVITY");
break;
case ON_PAUSE:
mTransactionHandler.handlePauseActivity(r.token, false /* finished */, false /* userLeaving */, 0 /* configChanges */, mPendingActions, "LIFECYCLER_PAUSE_ACTIVITY");
break;
case ON_STOP:
mTransactionHandler.handleStopActivity(r.token, false /* show */, 0 /* configChanges */, mPendingActions, false /* finalStateRequest */, "LIFECYCLER_STOP_ACTIVITY");
break;
case ON_DESTROY:
mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */, 0 /* configChanges */, false /* getNonConfigInstance */, "performLifecycleSequence. cycling to:" + path.get(size - 1));
break;
case ON_RESTART:
mTransactionHandler.performRestartActivity(r.token, false /* start */);
break;
default:
throw new IllegalArgumentException("Unexpected lifecycle state: " + state);
}
}
}
状态切换的具体逻辑还是要mTransactionHandler去执行。（其实就是继承了TransactionHandler的ActivityThread。）
3.6 ActivityThread-> handlePauseActivity(params…)
@Override
public void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving, int configChanges, PendingTransactionActions pendingActions, String reason) {
ActivityClientRecord r = mActivities.get(token);
if (r != null) {
...
performPauseActivity(r, finished, reason, pendingActions);
}
}
private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,
PendingTransactionActions pendingActions) {
//Honeycomb版本之前的APP在暂停的时候会保存状态
final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();
if (shouldSaveState) {
callActivityOnSaveInstanceState(r);
}
performPauseActivityIfNeeded(r, reason);
// Notify any outstanding on paused listeners
ArrayList<OnActivityPausedListener> listeners;
synchronized (mOnPauseListeners) {
listeners = mOnPauseListeners.remove(r.activity);
}
int size = (listeners != null ? listeners.size() : 0);
for (int i = 0; i < size; i++) {
listeners.get(i).onPaused(r.activity);
}
...
return shouldSaveState ? r.state : null;
}
private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {
if (r.paused) {
return;
}
try {
r.activity.mCalled = false;
mInstrumentation.callActivityOnPause(r.activity);
} catch (Exception e) {
}
r.setState(ON_PAUSE);
}
此处，又回到Instrumentation中执行，会调用activity.performPause();所以直接进入Activity中看实现。
3.7 Activity -> performPause()
final void performPause() {
mDoReportFullyDrawn = false;
mFragments.dispatchPause(); //把暂停事件分发给Fragment
mCalled = false;
onPause(); //调用onPause
writeEventLog(LOG_AM_ON_PAUSE_CALLED, "performPause");
mResumed = false;
}
至此，pause流程结束，会执行PauseActivityItem->postExecute()，通知AMS已经pause完毕。接下来就是创建activity所属进程，然后启动activity啦。
4.1 ActivityManagerService -> activityPaused(token)
此处回到AMS进程，收到pause操作已经完成的通知。
@Override
public final void activityPaused(IBinder token) {
final long origId = Binder.clearCallingIdentity();
synchronized(this) {
ActivityStack stack = ActivityRecord.getStackLocked(token);
if (stack != null) {
stack.activityPausedLocked(token, false);
}
}
Binder.restoreCallingIdentity(origId);
}
3.2 ActivityStack -> activityPausedLocked(params…)
final void activityPausedLocked(IBinder token, boolean timeout) {
final ActivityRecord r = isInStackLocked(token);
if (r != null) {
mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r);
//如果二者相等，表示记录的需要暂停的Activity已经暂停完毕
if (mPausingActivity == r) {
mService.mWindowManager.deferSurfaceLayout();
try {
completePauseLocked(true /* resumeNext */, null /* resumingActivity */);
} finally {
mService.mWindowManager.continueSurfaceLayout();
}
return;
} else {
//省略...
}
}
mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS);
}
3.3 ActivityStack -> completePauseLocked(params…)
private void completePauseLocked(boolean resumeNext, ActivityRecord resuming) {
//将调用者app状态设置为paused，并且addToStopping，加入待stop列表
//省略...
if (resumeNext) {
final ActivityStack topStack = mStackSupervisor.getFocusedStack();
if (!topStack.shouldSleepOrShutDownActivities()) {
//再次走到resumeFocusedStackTopActivityLocked
mStackSupervisor.resumeFocusedStackTopActivityLocked(topStack, prev, null);
} else {
//...
}
}
}
这次所有activity已经处于暂停状态，可以执行真正的acrivity启动方法了。
3.4 ActivityStackSupervisor -> startSpecificActivityLocked(params…)
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
//获取targetActivity所在进程
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
...
//若该进程已启动，则直接启动Activity
if (app != null && app.thread != null) {
try {
//检查Activity的flag是否包含多进程标志位 或 不是安卓框架的组件
if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0
|| !"android".equals(r.info.packageName)) {
// Don't add this if it is a platform component that is marked
// to run in multiple processes, because this is actually
// part of the framework so doesn't make sense to track as a
// separate apk in the process.
app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode,
mService.mProcessStats);
}
//真正启动Activity的方法
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
//...
}
}
//若targetActivity所在的进程不存在，则先启动一个新的进程，再启动Activity
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true);
}
接下来看如何启动新进程
4.1 ActivityManagerService -> startProcessLocked(params…)
//一系列startProcessLocked(params..)重载方法的调用
//最终会调用下面的startProcess(params..)方法
private ProcessStartResult startProcess(String hostingType, String entryPoint, ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal, String seInfo, String requiredAbi, String instructionSet, String invokeWith, long startTime) {
try {
final ProcessStartResult startResult;
if (hostingType.equals("webview_service")) {
...
} else {
//传入信息，初始化进程
startResult = Process.start(entryPoint, app.processName, uid, uid, gids, runtimeFlags, mountExternal, app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet, app.info.dataDir, invokeWith, new String[] {PROC_START_SEQ_IDENT + app.startSeq});
}
return startResult;
}
}
4.2 Process -> start(params…)
public static final ProcessStartResult start(final String processClass, final String niceName, int uid, int gid, int[] gids, int runtimeFlags, int mountExternal, int targetSdkVersion, String seInfo, String abi, String instructionSet, String appDataDir, String invokeWith, String[] zygoteArgs) {
return zygoteProcess.start(processClass, niceName, uid, gid, gids, runtimeFlags, mountExternal, targetSdkVersion, seInfo, abi, instructionSet, appDataDir, invokeWith, zygoteArgs);
}
AMS通过socket跨进程通信的方式通知了zygote进程来fork一个子进程，并且获取到了子进程的pid。该子进程创建、启动完毕之后，以processClass为类名的类的main(args)函数会被调用, 而此处的processClass是“android.app.ActivityThread”， 也就是说ActivityThread的main()方法就得到了调用。
4.3 ActivityThread -> main()
从此处开始，已经进入我们新创建的进程中。进行了一些初始化工作，开始了主线程的消息循环。
public static void main(String[] args) {
//初始化环境
Environment.initForCurrentUser();
...
//为主线程准备Looper
Looper.prepareMainLooper();
...
//创建ActivityThread的实例
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq); //通知AMS进行绑定操作
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
Looper.loop(); //启动主线程的消息循环
throw new RuntimeException("Main thread loop unexpectedly exited");
}
4.4 ActivityThread -> attach(params…)
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mSystemThread = system;
if (!system) {
//获取AMS代理
final IActivityManager mgr = ActivityManager.getService();
try {
//进行跨进程通信，通知AMS进行绑定
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
} else {
//...
}
//...
}
新的进程创建完毕，接下来要通知AMS，进行信息绑定。
5.1 ActivityManagerService -> attachApplication(params…)
回到AMS进程，主要是将AMS内的ProcessRecord与IApplicationThread(targetApp的代理)进行绑定。
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
synchronized (this) {
//..
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
}
}
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid, int callingUid, long startSeq) {
ProcessRecord app;
long startTime = SystemClock.uptimeMillis();
//根据pid来获取targetProcessRecord
if (pid != MY_PID && pid >= 0) {
synchronized (mPidsSelfLocked) {
app = mPidsSelfLocked.get(pid);
}
} else {
app = null;
}
...
app.makeActive(thread, mProcessStats);
...
if (app.isolatedEntryPoint != null) {
//...
} else if (app.instr != null) {
//thread是targetApp的代理，与AMS内ProcessRecord进行绑定，将信息传递过去
thread.bindApplication(processName, appInfo, providers, app.instr.mClass, profilerInfo, app.instr.mArguments, app.instr.mWatcher, app.instr.mUiAutomationConnection, testMode, mBinderTransactionTrackingEnabled, enableTrackAllocation, isRestrictedBackupMode || !normalMode, app.persistent, new Configuration(getGlobalConfiguration()), app.compat, getCommonServicesLocked(app.isolated), mCoreSettingsObserver.getCoreSettingsLocked(), buildSerial, isAutofillCompatEnabled);
} else {
//...
}
}
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
//通知ActivityStackSupervisor，targetApp已经完成了绑定操作，可以启动一个Activity了
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
}
}
return true;
}
5.2 ApplicationThread -> bindApplication(params…)
回到targetApp进程
public final void bindApplication(params..) {
if (services != null) {
ServiceManager.initServiceCache(services);
}
setCoreSettings(coreSettings);
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providers;
//...将传递过来的信息封装在AppBindData中
//然后发送到主线程处理
sendMessage(H.BIND_APPLICATION, data);
}
public void handleMessage(Message msg) {
switch (msg.what) {
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;
}
Object obj = msg.obj;
if (obj instanceof SomeArgs) {
((SomeArgs) obj).recycle();
}
}
5.3 ActivityThread -> handleBindApplication(data)
private void handleBindApplication(AppBindData data) {
//...初始化
//创建上下文环境context
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
Application app;
try {
app = data.info.makeApplication(data.restrictedBackupMode, null);
//....
try {
mInstrumentation.callApplicationOnCreate(app);
}
}
}
进入Instrumentation，最终会执行到app的onCreate()方法。
5.4 ActivityStackSupervisor -> attachApplicationLocked(app)
回到AMS进程，此时app端已经启动完成。
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
final String processName = app.processName;
boolean didSomething = false;
for (...) {
for (...) {
for (int i = 0; i < size; i++) {
final ActivityRecord activity = mTmpActivityList.get(i);
//找到正确的任务栈，则真正开始启动activity
if (activity.app == null && app.uid == activity.info.applicationInfo.uid
&& processName.equals(activity.processName)) {
try {
//启动该Activity
if (realStartActivityLocked(activity, app, top == activity /* andResume */, true /* checkConfig */)) {
didSomething = true;
}
}
}
}
}
}
return didSomething;
}
5.5 ActivityStackSupervisor -> realStartActivityLocked(params…)
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
//此时所有需要暂停的activity已经暂停完成，可以继续启动activity了
if (!allPausedActivitiesComplete()) {
return false;
}
final TaskRecord task = r.getTask();
final ActivityStack stack = task.getStack();
try {
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
//此处添加了callback: LaunchActivityItem
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent), System.identityHashCode(r), r.info, mergedConfiguration.getGlobalConfiguration(), mergedConfiguration.getOverrideConfiguration(), r.compat, r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results, newIntents, mService.isNextTransitionForward(), profilerInfo));
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
}
return true;
}
接下来的调用和之前pause是一样的，但在TransactionExecutor.execute(transaction)会多执行一个之前添加的callback: LaunchActivityItem.
5.6 LaunchActivityItem#execute(params…)
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);
//ActivityThread继承ClientTransactionHandler，所以实际上调用的是ActivityThread的handleLaunchActivity方法
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
5.7 ActivityThread -> handleLaunchActivity(params…)
public Activity handleLaunchActivity(ActivityClientRecord r, PendingTransactionActions pendingActions, Intent customIntent) {
//....
final Activity a = performLaunchActivity(r, customIntent);
//...
return a;
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//...
ActivityInfo aInfo = r.activityInfo;
ContextImpl appContext = createBaseContextForActivity(r); //创建Context
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent); //通过反射创建一个新的Activity
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (activity != null) {
appContext.setOuterContext(activity);
//activity绑定application
activity.attach(appContext, this, getInstrumentation(), r.token, r.ident, app, r.intent, r.activityInfo, title, r.parent, r.embeddedID, r.lastNonConfigurationInstances, config, r.referrer, r.voiceInteractor, window, r.configCallback);
//交回Instrumentation，触发它的生命周期方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
r.activity = activity;
}
r.setState(ON_CREATE); //设置Activity此时的状态为onCreate
mActivities.put(r.token, r);
return activity;
}
5.8 Instrumentation -> callActivityOnCreate(params…)
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
5.9 Activity -> performCreate(bundle)
final void performCreate(Bundle icicle) {
performCreate(icicle, null);
}
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle); //触发onCreate()生命周期
}
writeEventLog(LOG_AM_ON_CREATE_CALLED, "performCreate");
mActivityTransitionState.readState(icicle);
mVisibleFromClient = !mWindow.getWindowStyle().getBoolean(
com.android.internal.R.styleable.Window_windowNoDisplay, false);
mFragments.dispatchActivityCreated(); //分发给Fragments
mActivityTransitionState.setEnterActivityOptions(this, getActivityOptions());
}
至此，activity终于成功的启动啦～撒花～～
扫一扫
381
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
