本文基于Android10源码进行分析，分析之前先上一个概览图，说明APP启动的一个流程
Launcher进程在Instrumentation中通过ActivityTaskManager.getService().startActivity进入到AMS所在的ServiceManager进程 AMS中依次经过ActivityStartController、ActivityStart、RootActivityContainer、ActivityStack、ActivityStackSupervisor的调用最终走到realStartActivityLocked，在realStartActivityLocker中会判断当前APP对应的进程是否存在，不存在则经过一系列调用走到ZygoteProcess.attemptZygoteSendArgsAndGetResult()发送消息给Zygote进程 Zygote进程收到消息，开始执行启动APP子进程，启动进程结束以后返回结果给AMS进程，同时在RuntimeInit$MethodAndArgsCaller中通过反射执行子进程ActivityThread的main函数 App进程开始执行ActivityThread的main函数，进程开始运行，然后经过一系列的调用又回到AMS所在的ServiceManager进程，然后在AMS中会走到步骤2中的realStartActivityLocked函数中，在该函数中封装了ClientTransaction对象，通过mService.getLifecycleManager().scheduleTransaction(clientTransaction)回调到ActivityThread中，然后开始执行ClientTransaction中的LauncherActivityItem对象，最终调用到ActivityThread的handleLauncherActiivty中，通过Instrumentation执行Activity的onCreate方法 APP启动（冷启动）涉及进程以及相关java类，具体函数调用关系和流程在下面有详细贴出来
系统桌面Launcher App进程 LauncherActivity、Activity、Instrumentation
ServiceManager进程 ActivityTaskManagerService、ActivityStartController、ActivityStarter、RootActivityContainer、ActivityStack、ActivityStackSupervisor、ProcessList、Process
Zygore进程 ZygoteInit、ZygoteConnection、ZygoteInit、RuntimeInit、Zygote
App进程 ActivityThread、ActivityThread.ApplicationThread、ActivityThread.H、Instrumentation、ActivityTaskManagerService、RootActivityContainer、ActivityStackSupervisor、 ClientTransactionHandler、TransactionExecutor 、LaunchActivityItem
LauncherActivity /**
* 点击桌面icon，调用Activity的startActivity(Intent intent)
*/
protected void onListItemClick(ListView l, View v, int position, long id) {
Intent intent = intentForPosition(position);
startActivity(intent);
}
Activity public void startActivity(Intent intent) {
this.startActivity(intent, null);
}
/**
*
* @param intent
* @param options null
*/
public void startActivity(Intent intent, @Nullable Bundle options) {
if (options != null) {
startActivityForResult(intent, -1, options);
} else {
startActivityForResult(intent, -1);
}
}
/**
* @param intent
* @param requestCode -1
*/
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode) {
startActivityForResult(intent, requestCode, null);
}
/**
* LauncherActivity不存在父activity，走if代码块，然后调用Instrumentation.execStartActivity()
* 继续执行activity的启动操作
*
* @param intent
* @param requestCode -1
* @param options null
*/
public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) {
if (mParent == null) {
options = transferSpringboardActivityOptions(options);
Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this, intent,
requestCode, options);
if (ar != null) {
//发送结果，即onActivityResult会被调用
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(), ar.getResultData());
}
if (requestCode >= 0) {
mStartedActivity = true;
}
cancelInputsAndStartExitTransition(options);
}
................
}
Instrumentation /**
* @param who LauncherActivity
* @param contextThread LauncherActivity所在进程的ActivityThread$ApplicationThread的实例,
* AMS与Launcher进程通信时会用到
* @param token LauncherActivity对应的token，Token是ActivityRecord中的一个内部类，
* 继承自IApplicationToken.Stub，在AMS中通知Launcher进入pause状态时会用到
* @param target token对应的target，即LauncherActivity
* @param intent 启动目标activity的intent
* @param requestCode -1
* @param options null
* @return
*/
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) {//referrer为null
intent.putExtra(Intent.EXTRA_REFERRER, referrer);
}
if (mActivityMonitors != null) {
synchronized (mSync) {
//先查找一遍看是否存在这个activity
final int N = mActivityMonitors.size();
for (int i = 0; i < N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
ActivityResult result = null;
if (am.ignoreMatchingSpecificIntents()) {
result = am.onStartActivity(intent);
}
...........
}
}
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess(who);
//通过IPC机制调用到AMS的startActivity方法，开发进入到AMS进程
//ActivityTaskManager.getService()返回的是AMS的Binder通信代理
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;
}
ActivityTaskManagerService（AMS） /**
* @param caller LauncherActivity所在进程的ActivityThread$ApplicationThread的实例，
* AMS与Launcher进程通信时会用到
* @param callingPackage LauncherActivity的包名
* @param intent 启动目标activity的意图
* @param resolvedType MIME type of this intent
* @param resultTo LauncherActivity的mToken
* @param resultWho LauncherActivity.mEmbeddedID
* @param requestCode -1
* @param startFlags 0
* @param profilerInfo null
* @param bOptions null
* @return
*/
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());
}
/**
* 这里新增了userId参数
*
* @param userId Launcher进程uid
* @return
*/
public int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle bOptions, int userId) {
return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo,
resultWho, requestCode, startFlags, profilerInfo, bOptions, userId,
true /*validateIncomingUser*/);
}
/**
* 新增了 validateIncomingUser
*
* @param validateIncomingUser true
* @return
*/
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");
// getActivityStartController().obtainStarter返回ActivityStarter对象
return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
.setCaller(caller)
.setCallingPackage(callingPackage)
.setResolvedType(resolvedType)
.setResultTo(resultTo)
.setResultWho(resultWho)
.setRequestCode(requestCode)
.setStartFlags(startFlags)
.setProfilerInfo(profilerInfo)
.setActivityOptions(bOptions)
.setMayWait(userId)//这里会决定这里会决定ActivityStarter.execute()中的if(MayWait)判断
.execute();//ActivityStarter的execute()
}
ActivityStartController ActivityStarter obtainStarter(Intent intent, String reason) {
//mFactory为ActivityStarter内部类DefaultFactory
return mFactory.obtain().setIntent(intent).setReason(reason);
}
ActivityStarter int execute() {//line num 509
// for transactional diffs and preprocessing.
if (mRequest.mayWait) {//这里的mayWait是步骤4中的setUserId()中赋值的
return startActivityMayWait(......);
}
}
private int startActivityMayWait(......) {//line num 1134
int res = startActivity(......);
return res;
}
//startActivity 01 创建了ActivityInfo
private int startActivity(......) {//line num 566
mLastStartActivityResult = startActivity(......);
return getExternalResult(mLastStartActivityResult);
}
// startActivity02 创建了ActivityRecord
private int startActivity(.....) {//line num 611
final int res = startActivity(......);
return res;
}
//startActivity03
private int startActivity(......) {//line num 1386
try {
result = startActivityUnchecked(......);
}
return result;
}
private int startActivityUnchecked(......) {//line num 1464
if (mDoResume) {
mRootActivityContainer.resumeFocusedStacksTopActivities();
}
}
RootActivityContainer boolean resumeFocusedStacksTopActivities(ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (targetStack != null && (targetStack.isTopStackOnDisplay() || getTopDisplayFocusedStack() == targetStack)) {
result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
return result;
}
ActivityStack boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
boolean result = false;
try {
result = resumeTopActivityInnerLocked(prev, options);
}
return result;
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
if (mResumedActivity != null) {
pausing |= startPausingLocked(userLeaving, false, next, false);//通知launcher进入pause状态
}
mStackSupervisor.startSpecificActivityLocked(next, true, true);//继续执行启动APP
}
ActivityStackSupervisor void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
final WindowProcessController wpc = mService.getProcessController(r.processName, r.info.applicationInfo.uid);
if (wpc != null && wpc.hasThread()) { //目标activity所在进程已经启动直接启动activity
try {
//这里需重点留意，等zygote创建完APP进程以后，Zygote通过反射执行ActivityThread的main函数，
//然后通过一系列调用，会继续走到该函数执行activity的启动
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
}
}
try {
// APP冷启动，所对应的进程不存在，发送消息给zygote进程，通知zygote fork APP子进程
final Message msg = PooledLambda.obtainMessage(
ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
mService.mH.sendMessage(msg);
}
}
由于zygote进程fork完APP子进程以后经过一系列调用，最终还是会走到这里，所以继续跟踪分析realStartActivityLocked函数，
关于zygote fork APP进程以及APP进程启动以后如何调用到realStartActivityLocked放在第四节继续跟踪
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc, boolean andResume, boolean checkConfig) throws RemoteException {
// Create activity launch transaction.
final ClientTransaction clientTransaction = ClientTransaction.obtain(proc.getThread(), r.appToken);
final DisplayContent dc = r.getDisplay().mDisplayContent;
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent), System.identityHashCode(r), r.info,
mergedConfiguration.getGlobalConfiguration(), mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(), r.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);
}
// mService.getLifecycleManager()返回ClientLifecycleManager对象，ClientLifecycleManager.scheduleTransaction()函数会执行
//参数的schedule()函数，也就是说这里执行了clientTransaction.schedule()函数，那我们继续追踪ClientTransaction类
ClientTransaction public void schedule() throws RemoteException {
//mClient对象即ActivityThread$ApplicationThread的Binder通信代理，
//这里即通过IPC回调到了App进程执行ActivityThread$ApplicationThread.scheduleTransaction()函数
mClient.scheduleTransaction(this);
}
ActivityThread$ApplicationThread public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
//这里调用了ActivityThread父类ClientTransactionHandler.scheduleTransaction(),继续追踪ClientTransactionHandler
ClientTransactionHandler void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
//这里会调用ActivityThread$H.handleMessage()
ActivityThread$H public void handleMessage(Message msg) {
switch (msg.what) {
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
break;
}
}
//这里调用了TransactionExecutor的execute函数，继续分析TransactionExecutor类
TransactionExecutor public void execute(ClientTransaction transaction) {
executeCallbacks(transaction);
executeLifecycleState(transaction);
}
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
//这里的item即步骤9中realStartActivityLocked函数中添加的LaunchActivityItem对象，这里会调用activity的onCreate
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
if (postExecutionState != UNDEFINED && r != null) {
//这里会调用activity的onStart的函数
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}
}
}
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
//这里的lifecycleItem即步骤9中realStartActivityLocked函数中添加的ResumeActivityItem对象，这里会调用activity的onResume
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
LaunchActivityItem public void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) {
ActivityClientRecord r = new ActivityClientRecord(....);
//这里的client即ActivityThread
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}
ActivityThread public Activity handleLaunchActivity(ActivityClientRecord r, PendingTransactionActions pendingActions, Intent customIntent) {
final Activity a = performLaunchActivity(r, customIntent);
return a;
}
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
Activity activity = null;
java.lang.ClassLoader cl = appContext.getClassLoader();
//新建Activity对象
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
....
if (activity != null) {
activity.attach(.....);
.....
int theme = r.activityInfo.getThemeResource();
activity.setTheme(theme);
.....
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
......
return activity;
}
Instrumentation public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
String pkg = intent != null && intent.getComponent() != null? intent.getComponent().getPackageName() : null;
return getFactory(pkg).instantiateActivity(cl, className, intent);
}
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
Activity final void performCreate(Bundle icicle, PersistableBundle persistentState) {
dispatchActivityPreCreated(icicle);
mCanEnterPictureInPicture = true;
restoreHasCurrentPermissionRequest(icicle);
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
}
//至此，启动activity结束，onStart和onResume方法同样是通过Instrumentation调用，调用方式与create类似
这里从第三节的步骤9中ActivityStackSupervisor.startSpecificActivityLocked()开始
ActivityStackSupervisor void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) {
final WindowProcessController wpc = mService.getProcessController(r.processName, r.info.applicationInfo.uid);
if (wpc != null && wpc.hasThread()) { //目标activity所在进程已经启动直接启动activity
try {
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
}
}
try {
// Post message to start process to avoid possible deadlock of calling into AMS with the
// APP初期启动，所对应的进程不存在，发送消息给zygote进程，通知zygote创建APP运行进程
final Message msg = PooledLambda.obtainMessage(
ActivityManagerInternal::startProcess, mService.mAmInternal, r.processName,
r.info.applicationInfo, knownToBeDead, "activity", r.intent.getComponent());
mService.mH.sendMessage(msg);
}
}
//ActivityManagerInternal::startProcess是个抽象方法，具体实现类在ActivityManagerService$LocalService.startProcess()
ActivityManagerService$LocalService @Override
public void startProcess(String processName, ApplicationInfo info, boolean knownToBeDead, String hostingType, ComponentName hostingName) {
synchronized (ActivityManagerService.this) {
startProcessLocked(processName, info, knownToBeDead, 0 /* intentFlags */,
new HostingRecord(hostingType, hostingName),
false /* allowWhileBooting */, false /* isolated */,
true /* keepIfLarge */);
}
}
final ProcessRecord startProcessLocked(......) {
return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
hostingRecord, allowWhileBooting, isolated, 0 /* isolatedUid */, keepIfLarge,
null /* ABI override */, null /* entryPoint */, null /* entryPointArgs */,
null /* crashHandler */);
}
ProcessList //startProcessLocked 01
boolean startProcessLocked(ProcessRecord app, HostingRecord hostingRecord, boolean disableHiddenApiChecks, boolean mountExtStorageFull, String abiOverride) {
return startProcessLocked(hostingRecord, entryPoint, app, uid, gids, runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet, invokeWith, startTime);
}
//startProcessLocked02
boolean startProcessLocked(HostingRecord hostingRecord,
String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
final Process.ProcessStartResult startResult = startProcess(hostingRecord,
entryPoint, app,
uid, gids, runtimeFlags, mountExternal, seInfo, requiredAbi, instructionSet,
invokeWith, startTime);
}
private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith, app.info.packageName,
new String[] {PROC_START_SEQ_IDENT + app.startSeq});
}
Process public static ProcessStartResult start(......) {
return ZYGOTE_PROCESS.start(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, packageName,
/*useUsapPool=*/ true, zygoteArgs);
}
ZygoteProcess public final Process.ProcessStartResult start(.....) {
return startViaZygote(processClass, niceName, uid, gid, gids,
runtimeFlags, mountExternal, targetSdkVersion, seInfo,
abi, instructionSet, appDataDir, invokeWith, /*startChildZygote=*/ false,
packageName, useUsapPool, zygoteArgs);
}
private Process.ProcessStartResult startViaZygote(......) throws ZygoteStartFailedEx {
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), useUsapPool, argsForZygote);
}
private Process.ProcessStartResult zygoteSendArgsAndGetResult(ZygoteState zygoteState, boolean useUsapPool, @NonNull ArrayList<String> args) throws ZygoteStartFailedEx {
return attemptUsapSendArgsAndGetResult(zygoteState, msgStr);
//这里会通过socket向zygote进程发送启动APP子进程的消息
}
ZygoteInit public static void main(String argv[]) {
caller = zygoteServer.runSelectLoop(abiList);
if (caller != null) {
caller.run();
}
}
//使zygote进入循环模式，接收c端数据并处理
ZygoteServer
Runnable runSelectLoop(String abiList) {
ZygoteConnection connection = peers.get(pollIndex);
final Runnable command = connection.processOneCommand(this);
}
//接收C端数据
ZygoteConnection Runnable processOneCommand(ZygoteServer zygoteServer) {
//创建指定APP子进程
pid = Zygote.forkAndSpecialize(parsedArgs.mUid, parsedArgs.mGid, parsedArgs.mGids,
parsedArgs.mRuntimeFlags, rlimits, parsedArgs.mMountExternal, parsedArgs.mSeInfo,
parsedArgs.mNiceName, fdsToClose, fdsToIgnore, parsedArgs.mStartChildZygote,
parsedArgs.mInstructionSet, parsedArgs.mAppDataDir, parsedArgs.mTargetSdkVersion);
try {
if (pid == 0) {
return handleChildProc(parsedArgs, descriptors, childPipeFd, parsedArgs.mStartChildZygote);
} else {
// In the parent. A pid < 0 indicates a failure and will be handled in
handleParentProc(pid, descriptors, serverPipeFd);
return null;
}
}
}
private Runnable handleChildProc(ZygoteArguments parsedArgs, FileDescriptor[] descriptors, FileDescriptor pipeFd, boolean isZygote) {
if (!isZygote) {
return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion, parsedArgs.mRemainingArgs, null /* classLoader */);
} else {
return ZygoteInit.childZygoteInit(parsedArgs.mTargetSdkVersion, parsedArgs.mRemainingArgs, null /* classLoader */);
}
}
ZygoteInit public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit();
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
RuntimeInit protected static Runnable applicationInit(int targetSdkVersion, String[] argv,ClassLoader classLoader) {
// Remaining arguments are passed to the start class's static main
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
protected static Runnable findStaticMain(String className, String[] argv, ClassLoader classLoader) {
Class<?> cl;
try {
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {}
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });
}
return new MethodAndArgsCaller(m, argv);
}
RuntimeInit$MethodAndArgsCaller public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs });
}
}
//这里通过反射调用ActivityThread的main()函数
ActivityThread public static void main(String[] args) {
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
}
private void attach(boolean system, long startSeq) {
final IActivityManager mgr = ActivityManager.getService();
mgr.attachApplication(mAppThread, startSeq);
}
ActivityManagerService public final void attachApplication(IApplicationThread thread, long startSeq) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}
private final boolean attachApplicationLocked(IApplicationThread thread, int pid, int callingUid, long startSeq) {
......
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
.......
return true;
}
ActivityTaskManagerService$LocalService public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
synchronized (mGlobalLockWithoutBoost) {
return mRootActivityContainer.attachApplication(wpc);
}
}
RootActivityContainer boolean attachApplication(WindowProcessController app) throws RemoteException {
final String processName = app.mName;
boolean didSomething = false;
for (int displayNdx = mActivityDisplays.size() - 1; displayNdx >= 0; --displayNdx) {
final ActivityDisplay display = mActivityDisplays.get(displayNdx);
final ActivityStack stack = display.getFocusedStack();
if (stack != null) {
stack.getAllRunningVisibleActivitiesLocked(mTmpActivityList);
final ActivityRecord top = stack.topRunningActivityLocked();
final int size = mTmpActivityList.size();
for (int i = 0; i < size; i++) {
final ActivityRecord activity = mTmpActivityList.get(i);
if (activity.app == null && app.mUid == activity.info.applicationInfo.uid && processName.equals(activity.processName)) {
try {
if (mStackSupervisor.realStartActivityLocked(activity, app, top == activity /* andResume */, true /* checkConfig */)) {
didSomething = true;
}
}
}
}
}
}
return didSomething;
}
//这里就回到了第二节步骤9中的realStartActivityLocked，继续执行启动activity
617
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
