Android(安卓)9.0——ActivityManagerService代码分析
16lz
2021-01-26
1、AMS初始化
9.0的代码google同样做了一些改变，但是大体的流程与8.0接近。
ActivityManagerService同样通过SystemServer启动（Zygote孵化），我们看一下实现。首先定位SystemServer的主线程的方法：
public static void main(String[] args) { new SystemServer().run();}我们看一下run方法执行了什么：
private void run() {// 省略代码，主要是一些系统参数的初始化try { traceBeginAndSlog("StartServices"); startBootstrapServices(); // Ams启动的类 startCoreServices(); // 一些核心服务，包含了应用使用信息管理类UsageStatsService和电池统计服务BatteryService startOtherServices(); // 其他服务，包含了流量统计服务NetworkStatsService，窗口管理服务WindowManagerService，通话服务TelephonyRegistry，存储服务IStorageManager等 SystemServerInitThreadPool.shutdown(); } catch (Throwable ex) { Slog.e("System", "******************************************"); Slog.e("System", "************ Failure starting system services", ex); throw ex; } finally { traceEnd(); }}看一下AMS 启动的方法：
private void startBootstrapServices() { mActivityManagerService = mSystemServiceManager.startService( ActivityManagerService.Lifecycle.class).getService(); mActivityManagerService.setSystemServiceManager(mSystemServiceManager); mActivityManagerService.setInstaller(installer); // 省略其他的服务，PowerManagerService、DisplayManagerService、InstallService、UserManageService等重要服务。}可以看到这个start的service是取得AMS的内部类，我们看一下内部类的书写：
public static final class Lifecycle extends SystemService { private final ActivityManagerService mService; public Lifecycle(Context context) { super(context); mService = new ActivityManagerService(context); } @Override public void onStart() { mService.start(); } public ActivityManagerService getService() { return mService; // 当前真实的服务类 }}所以这个Lifecycle只是ActivityManagerService的适配器，适配成了SystemService。
所以实际上就是通过SystemServiceManager创建服务嘛，那我们再看一下SystemServiceManager的源码：
public <T extends SystemService> T startService(Class<T> serviceClass) { try { final String name = serviceClass.getName(); final T service; try { Constructor<T> constructor = serviceClass.getConstructor(Context.class); service = constructor.newInstance(mContext); } catch (InstantiationException ex) { } catch (IllegalAccessException ex) { } catch (NoSuchMethodException ex) { } catch (InvocationTargetException ex) { } startService(service); return service; } finally { }}public void startService(@NonNull final SystemService service) { mServices.add(service); long time = SystemClock.elapsedRealtime(); try { service.onStart(); } catch (RuntimeException ex) { }}实际上的实现很简单，就是一个反射调用，获取到定义的SystemService，然后调用其onStart()方法，上面的代码我们也看到，实际这里我们就回到ActivityManagerService（以下简称AMS）的start方法，首先我们先看一下构造函数：
public ActivityManagerService(Context systemContext) { mProcStartHandlerThread = new ServiceThread(TAG + ":procStart", THREAD_PRIORITY_FOREGROUND, false /* allowIo */); mProcStartHandlerThread.start(); mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper()); // 前台广播队列 mFgBroadcastQueue = new BroadcastQueue(this, mHandler, "foreground", BROADCAST_FG_TIMEOUT, false); // 后台广播队列 mBgBroadcastQueue = new BroadcastQueue(this, mHandler, "background", BROADCAST_BG_TIMEOUT, true); mBroadcastQueues[0] = mFgBroadcastQueue; mBroadcastQueues[1] = mBgBroadcastQueue; // Service的记录集合 mServices = new ActiveServices(this); // ContentProvider的记录集合 mProviderMap = new ProviderMap(this); // 进程状态记录 mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats")); // 创建ActivityStackSupervisor mStackSupervisor = createStackSupervisor(); mStackSupervisor.onConfigurationChanged(mTempConfig); // 启动Activity的辅助类ActivityStartController mActivityStartController = new ActivityStartController(this); // 获取关机前已经有的最近任务 mRecentTasks = createRecentTasks(); mStackSupervisor.setRecentTasks(mRecentTasks); // Activity的生命周期管理 mLifecycleManager = new ClientLifecycleManager(); try { // 设置当前进程的adj，也就是LowMemory killer会根据adj进行内存优化，关闭应用。 updateOomAdjLocked();}所以构造器主要就是构造一些辅助类，初始化一些配置。我们再看一下start方法。removeAllProcessGroups();mProcessCpuThread.start();try { mProcessCpuInitLatch.await(); // 这边是一个阻塞，阻塞任何一个想获取mProcessCpuTracker的主线程操作，必须等待AMS先初始化} catch (InterruptedException e) { Thread.currentThread().interrupt();}}
实际就是执行了ProcessCpuThread线程的方法：```cppmProcessCpuThread = new Thread("CpuTracker") { @Override public void run() { synchronized (mProcessCpuTracker) { mProcessCpuInitLatch.countDown();// 计数器，也就是上面提到的阻塞。所以主线程必须等待，这里执行完。 mProcessCpuTracker.init(); } while (true) { try { try { synchronized(this) { final long now = SystemClock.uptimeMillis(); long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now; long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now; if (nextWriteDelay < nextCpuDelay) { nextCpuDelay = nextWriteDelay; } if (nextCpuDelay > 0) { mProcessCpuMutexFree.set(true); this.wait(nextCpuDelay); } } } catch (InterruptedException e) { } updateCpuStatsNow(); // 启动CPU的监测 } catch (Exception e) { } } } };那实际上AMS进行start()的时候，主要就是初始化CPU和进程的监测。这个跟我们本次AMS的流程影响不大。
2、startActivity的流程
实际整个Activity启动的过程，是由上层启动App的进程，传递给AMS所在进程，再由AMS，去打开被启动Activity所在进程，并进行通讯的。所以我们可以称上层启动的app为ClientA，上层被启动app称为ClientB（如果被启动Activity与启动方为同进程的话，也要走AMS，这里我们同样也叫ClientB）。AMS称为server进行分析。我们看一下ClientA代码（以startActivity(Intent intent)为例）：
@Override public void startActivity(Intent intent) { this.startActivity(intent, null); } @Override public void startActivity(Intent intent, @Nullable Bundle options) { if (options != null) { startActivityForResult(intent, -1, options); // 实际都会走到startActivityForResult中 } else { startActivityForResult(intent, -1); } } public void startActivityForResult(@RequiresPermission Intent intent, int requestCode, @Nullable Bundle options) { if (mParent == null) { // 基本为此逻辑，无父Activity的情况 options = transferSpringboardActivityOptions(options); Instrumentation.ActivityResult ar = mInstrumentation.execStartActivity( this, mMainThread.getApplicationThread(), mToken, this, intent, requestCode, options); } else { // 有父Activity的逻辑，这个父Activity主要用在LocalActivityManager中，用于复用layout的，但是我们知道framgment也可以做到，后来被弃用了。 if (options != null) { mParent.startActivityFromChild(this, intent, requestCode, options); } else { mParent.startActivityFromChild(this, intent, requestCode); } } }我们再看Instrumentation的逻辑：
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); } if (· != null) { synchronized (mSync) { final int N = mActivityMonitors.size(); // 遍历ActivityMonitor for (int i=0; i<N; i++) { final ActivityMonitor am = mActivityMonitors.get(i); ActivityResult result = null; // 实际当前ActivityMonitor是否阻塞启动onStartActivity。这个ActivityMonitor实际就是用来测试用的，所以会有阻塞的场景，大多数情况，都是true if (am.ignoreMatchingSpecificIntents()) { result = am.onStartActivity(intent); } } } } // 真正的启动逻辑 try { intent.migrateExtraStreamToClipData(); intent.prepareToLeaveProcess(who); 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) { } return null; }我们看一下上层ActivityManager的相关实现：
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 在上层的binderproxy。既然获取到了AMS的proxy，我们看一下server层的AMS的实现吧：
@Overridepublic 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());}// 实际调用的就是 startActivityAsUser,也就是增加一个用户id。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) { enforceNotIsolatedCaller("startActivity"); // 实际代码写在启动辅助类ActivityStartController中 userId = mActivityStartController.checkTargetUser(userId, validateIncomingUser, Binder.getCallingPid(), Binder.getCallingUid(), "startActivityAsUser"); 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) .execute(); }这个ActivityStartController实际就是获取8.0之前使用的ActivityStarter（google重构代码还是很有决心的）我们看一下实现：
int execute() { try { // 因为调用了setMayWait(userId)，mayWait就是true if (mRequest.mayWait) { 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 { return startActivity(mRequest.caller, mRequest.intent, mRequest.ephemeralIntent, mRequest.resolvedType, mRequest.activityInfo, mRequest.resolveInfo, mRequest.voiceSession, mRequest.voiceInteractor, mRequest.resultTo, mRequest.resultWho, mRequest.requestCode, mRequest.callingPid, mRequest.callingUid, mRequest.callingPackage, mRequest.realCallingPid, mRequest.realCallingUid, mRequest.startFlags, mRequest.activityOptions, mRequest.ignoreTargetSecurity, mRequest.componentSpecified, mRequest.outActivity, mRequest.inTask, mRequest.reason, mRequest.allowPendingRemoteAnimationRegistryLookup); } } finally { onExecutionComplete(); }}看一下主要实现startActivityMayWait：
private 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, SafeActivityOptions options, boolean ignoreTargetSecurity, int userId, TaskRecord inTask, String reason, boolean allowPendingRemoteAnimationRegistryLookup) { if (intent != null && intent.hasFileDescriptors()) { throw new IllegalArgumentException("File descriptors passed in Intent"); } mSupervisor.getActivityMetricsLogger().notifyActivityLaunching(); boolean componentSpecified = intent.getComponent() != null; final int realCallingPid = Binder.getCallingPid(); final int realCallingUid = Binder.getCallingUid(); int callingPid; // 获取调用者进程id if (callingUid >= 0) { callingPid = -1; } else if (caller == null) { callingPid = realCallingPid; callingUid = realCallingUid; } else { callingPid = callingUid = -1; } ResolveInfo rInfo = mSupervisor.resolveIntent(intent, resolvedType, userId , 0 , computeResolveFilterUid( callingUid, realCallingUid, mRequest.filterCallingUid)); // 生成ActivityInfo信息 ActivityInfo aInfo = mSupervisor.resolveActivity(intent, rInfo, startFlags, profilerInfo); // 最终调用到startActivity final ActivityRecord[] outRecord = new ActivityRecord[1]; 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); Binder.restoreCallingIdentity(origId); return res; } }再看一下startActivity实现
private int startActivity(IApplicationThread caller, Intent intent, Intent ephemeralIntent, String resolvedType, ActivityInfo aInfo, ResolveInfo rInfo, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, IBinder resultTo, String resultWho, int requestCode, int callingPid, int callingUid, String callingPackage, int realCallingPid, int realCallingUid, int startFlags, SafeActivityOptions options, boolean ignoreTargetSecurity, boolean componentSpecified, ActivityRecord[] outActivity, TaskRecord inTask, boolean allowPendingRemoteAnimationRegistryLookup) { ProcessRecord callerApp = null; if (caller != null) { callerApp = mService.getRecordForAppLocked(caller); if (callerApp != null) { callingPid = callerApp.pid; callingUid = callerApp.info.uid; } else { Slog.w(TAG, "Unable to find app for caller " + caller + " (pid=" + callingPid + ") when starting: " + intent.toString()); err = ActivityManager.START_PERMISSION_DENIED; } } ActivityRecord sourceRecord = null; ActivityRecord resultRecord = null; if (resultTo != null) { sourceRecord = mSupervisor.isInAnyStackLocked(resultTo); if (DEBUG_RESULTS) Slog.v(TAG_RESULTS, "Will send result to " + resultTo + " " + sourceRecord); if (sourceRecord != null) { if (requestCode >= 0 && !sourceRecord.finishing) { resultRecord = sourceRecord; } } } // 处理一些flag的逻辑 final int launchFlags = intent.getFlags(); // FLAG_ACTIVITY_FORWARD_RESULT如果有这个flag，表示要串行传递，比如A到B到C，C的result要设为A，这个flag就表示这个意思，这里是具体实现 if ((launchFlags & Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 && sourceRecord != null) { resultRecord = sourceRecord.resultTo; if (resultRecord != null && !resultRecord.isInStackLocked()) { resultRecord = null; } resultWho = sourceRecord.resultWho; requestCode = sourceRecord.requestCode; sourceRecord.resultTo = null; if (resultRecord != null) { resultRecord.removeResultsLocked(sourceRecord, resultWho, requestCode); } if (sourceRecord.launchedFromUid == callingUid) { } } final ActivityStack resultStack = resultRecord == null ? null : resultRecord.getStack(); // 检查启动activity的权限 boolean abort = !mSupervisor.checkStartAnyActivityPermission(intent, aInfo, resultWho, requestCode, callingPid, callingUid, callingPackage, ignoreTargetSecurity, inTask != null, callerApp, resultRecord, resultStack); abort |= !mService.mIntentFirewall.checkStartActivity(intent, callingUid, callingPid, resolvedType, aInfo.applicationInfo); if (mService.mController != null) { try { abort |= !mService.mController.activityStarting(watchIntent, aInfo.applicationInfo.packageName); } catch (RemoteException e) { mService.mController = null; } } // Interceptor逻辑，由于android存在一些界面可以阻止startActivity的操作，这个Interceptor即用来阻止启动的。 mInterceptor.setStates(userId, realCallingPid, realCallingUid, startFlags, callingPackage); if (mInterceptor.intercept(intent, rInfo, aInfo, resolvedType, inTask, callingPid, callingUid, checkedOptions)) { intent = mInterceptor.mIntent; rInfo = mInterceptor.mRInfo; aInfo = mInterceptor.mAInfo; resolvedType = mInterceptor.mResolvedType; inTask = mInterceptor.mInTask; callingPid = mInterceptor.mCallingPid; callingUid = mInterceptor.mCallingUid; checkedOptions = mInterceptor.mActivityOptions; } // launch app是否具备权限，查看activity 缩略图，这里如果全局不支持，那会给ActivityInfo加一个相应的flag。 if (mService.mPermissionReviewRequired && aInfo != null) { if (mService.getPackageManagerInternalLocked().isPermissionsReviewRequired( aInfo.packageName, userId)) { IIntentSender target = mService.getIntentSenderLocked( ActivityManager.INTENT_SENDER_ACTIVITY, callingPackage, callingUid, userId, null, null, 0, new Intent[]{intent}, new String[]{resolvedType}, PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_ONE_SHOT, null); final int flags = intent.getFlags(); Intent newIntent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS); newIntent.setFlags(flags | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); newIntent.putExtra(Intent.EXTRA_PACKAGE_NAME, aInfo.packageName); newIntent.putExtra(Intent.EXTRA_INTENT, new IntentSender(target)); 。。。 } } ActivityRecord r = new ActivityRecord(mService, callerApp, callingPid, callingUid, callingPackage, intent, resolvedType, aInfo, mService.getGlobalConfiguration(), resultRecord, resultWho, requestCode, componentSpecified, voiceSession != null, mSupervisor, checkedOptions, sourceRecord);// 走到下面的逻辑 return startActivity(r, sourceRecord, voiceSession, voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask, outActivity); } private int startActivity(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask, ActivityRecord[] outActivity) { int result = START_CANCELED; try { mService.mWindowManager.deferSurfaceLayout(); // 实际执行startActivityUnchecked result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor, startFlags, doResume, options, inTask, outActivity); } finally { mStartActivity.getStack(); if (!ActivityManager.isStartResultSuccessful(result) && stack != null) { stack.finishActivityLocked(mStartActivity, RESULT_CANCELED, null /* intentResultData */, "startActivity", true /* oomAdj */); } mService.mWindowManager.continueSurfaceLayout(); } return result; }我们接着网下看：
private int startActivityUnchecked(final ActivityRecord r, ActivityRecord sourceRecord, IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor, int startFlags, boolean doResume, ActivityOptions options, TaskRecord inTask, ActivityRecord[] outActivity) { mIntent.setFlags(mLaunchFlags); ActivityRecord reusedActivity = getReusableIntentActivity(); // 设置Activity的窗口类型 int preferredWindowingMode = WINDOWING_MODE_UNDEFINED; int preferredLaunchDisplayId = DEFAULT_DISPLAY; if (mOptions != null) { preferredWindowingMode = mOptions.getLaunchWindowingMode(); preferredLaunchDisplayId = mOptions.getLaunchDisplayId(); } if (!mLaunchParams.isEmpty()) { if (mLaunchParams.hasPreferredDisplay()) { preferredLaunchDisplayId = mLaunchParams.mPreferredDisplayId; } if (mLaunchParams.hasWindowingMode()) { preferredWindowingMode = mLaunchParams.mWindowingMode; } } // 如果当前activity已存在的情况，要根据flag的设置，决定Activity的栈中表现 if (reusedActivity != null) { if ((mLaunchFlags & FLAG_ACTIVITY_CLEAR_TOP) != 0 || isDocumentLaunchesIntoExisting(mLaunchFlags) || isLaunchModeOneOf(LAUNCH_SINGLE_INSTANCE, LAUNCH_SINGLE_TASK)) { final TaskRecord task = reusedActivity.getTask(); if (reusedActivity.getTask() == null) { reusedActivity.setTask(task); } } } boolean newTask = false; final TaskRecord taskToAffiliate = (mLaunchTaskBehind && mSourceRecord != null) ? mSourceRecord.getTask() : null; // 判断当前是否需要为Activity新建栈，或者使用原有栈 int result = START_SUCCESS; if (mStartActivity.resultTo == null && mInTask == null && !mAddingToTask && (mLaunchFlags & FLAG_ACTIVITY_NEW_TASK) != 0) { newTask = true; result = setTaskFromReuseOrCreateNewTask(taskToAffiliate, topStack); } else if (mSourceRecord != null) { result = setTaskFromSourceRecord(); } else if (mInTask != null) { result = setTaskFromInTask(); } else { setTaskToCurrentTopOrCreateNewTask(); } // 获取权限 mService.grantUriPermissionFromIntentLocked(mCallingUid, mStartActivity.packageName, mIntent, mStartActivity.getUriPermissionsLocked(), mStartActivity.userId); mService.grantEphemeralAccessLocked(mStartActivity.userId, mIntent, mStartActivity.appInfo.uid, UserHandle.getAppId(mCallingUid)); mTargetStack.mLastPausedActivity = null; mSupervisor.sendPowerHintForLaunchStartIfNeeded(false /* forceSend */, mStartActivity); // 启动源码所在 mTargetStack.startActivityLocked(mStartActivity, topFocused, newTask, mKeepCurTransition, mOptions); // 如果可以显示，则进入到上层显示的过程。 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 { if (mTargetStack.isFocusable() && !mSupervisor.isFocusedStack(mTargetStack)) { mTargetStack.moveToFront("startActivityUnchecked"); }// 上层显示代码流程 mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity, mOptions); } } else if (mStartActivity != null) { mSupervisor.mRecentTasks.add(mStartActivity.getTask()); } mSupervisor.updateUserStackLocked(mStartActivity.userId, mTargetStack); mSupervisor.handleNonResizableTaskIfNeeded(mStartActivity.getTask(), preferredWindowingMode, preferredLaunchDisplayId, mTargetStack); return START_SUCCESS; }先看一下ActivityStack的startActivityLocked代码：
void startActivityLocked(ActivityRecord r, ActivityRecord focusedTopActivity, boolean newTask, boolean keepCurTransition, ActivityOptions options) { // 获取当前设置的栈TaskRecode TaskRecord rTask = r.getTask(); final int taskId = rTask.taskId; // 如果不是后台的TaskRecord或者是新的Task，则将Task移到最前面 if (!r.mLaunchTaskBehind && (taskForIdLocked(taskId) == null || newTask)) { insertTaskAtTop(rTask, r); } TaskRecord task = null; final TaskRecord activityTask = r.getTask(); task = activityTask; // 设置当前栈顶元素 task.setFrontOfTask(); // 如果满足要求，表示Activity建立新的窗口 if (!isHomeOrRecentsStack() || numActivities() > 0) { if ((r.intent.getFlags() & Intent.FLAG_ACTIVITY_NO_ANIMATION) != 0) { mWindowManager.prepareAppTransition(TRANSIT_NONE, keepCurTransition); mStackSupervisor.mNoAnimActivities.add(r); } else { int transit = TRANSIT_ACTIVITY_OPEN; if (newTask) { if (r.mLaunchTaskBehind) { transit = TRANSIT_TASK_OPEN_BEHIND; } else { if (canEnterPipOnTaskSwitch(focusedTopActivity, null /* toFrontTask */, r, options)) { focusedTopActivity.supportsEnterPipOnTaskSwitch = true; } transit = TRANSIT_TASK_OPEN; } } mWindowManager.prepareAppTransition(transit, keepCurTransition); mStackSupervisor.mNoAnimActivities.remove(r); } } }我们再看一下显示的过程，由于ActivityStack里面将我们的Task栈移到了顶端，并且变成了focus的stack，于是我们执行ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法，这个主体实现如下：
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) { final ActivityRecord next = topRunningActivityLocked(true /* focusableOnly */); mStackSupervisor.cancelInitializingActivities(); if (!hasRunningActivity) { // There are no activities left in the stack, let's look somewhere else. return resumeTopActivityInNextFocusableStack(prev, options, "noMoreActivities"); } next.delayedResume = false; if (shouldSleepOrShutDownActivities() && mLastPausedActivity == next && mStackSupervisor.allPausedActivitiesComplete()) { executeAppTransition(options); if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Going to sleep and all paused"); if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked(); return false; } // Make sure that the user who owns this activity is started. If not, // we will just leave it as is because someone should be bringing // another user's activities to the top of the stack. if (!mService.mUserController.hasStartedUserState(next.userId)) { Slog.w(TAG, "Skipping resume of top activity " + next + ": user " + next.userId + " is stopped"); if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked(); return false; } mStackSupervisor.mStoppingActivities.remove(next); mStackSupervisor.mGoingToSleepActivities.remove(next); next.sleeping = false; mStackSupervisor.mActivitiesWaitingForVisibleActivity.remove(next); mStackSupervisor.setLaunchSource(next.info.applicationInfo.uid); boolean lastResumedCanPip = false; ActivityRecord lastResumed = null; boolean pausing = mStackSupervisor.pauseBackStacks(userLeaving, next, false); // 如果发现当前界面Activity仍然在显示，首先先pause之前的activity if (mResumedActivity != null) { if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Pausing " + mResumedActivity); pausing |= startPausingLocked(userLeaving, false, next, false); } if (pausing && !resumeWhilePausing) { if (DEBUG_SWITCH || DEBUG_STATES) Slog.v(TAG_STATES, "resumeTopActivityLocked: Skip resume: need to start pausing"); if (next.app != null && next.app.thread != null) { mService.updateLruProcessLocked(next.app, true, null); } if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked(); if (lastResumed != null) { lastResumed.setWillCloseOrEnterPip(true); } return true; } else if (mResumedActivity == next && next.isState(RESUMED) && mStackSupervisor.allResumedActivitiesComplete()) { executeAppTransition(options); if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Top activity resumed (dontWaitForPause) " + next); if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked(); return true; } boolean anim = true; ActivityStack lastStack = mStackSupervisor.getLastStack(); // 如果这个即将启动的activity已经生成了，则进行resume的流程 if (next.app != null && next.app.thread != null) { final boolean lastActivityTranslucent = lastStack != null && (lastStack.inMultiWindowMode() || (lastStack.mLastPausedActivity != null && !lastStack.mLastPausedActivity.fullscreen)); synchronized(mWindowManager.getWindowManagerLock()) { try { final ClientTransaction transaction = ClientTransaction.obtain(next.app.thread, next.appToken); // Deliver all pending results. ArrayList<ResultInfo> a = next.results; if (a != null) { final int N = a.size(); if (!next.finishing && N > 0) { if (DEBUG_RESULTS) Slog.v(TAG_RESULTS, "Delivering results to " + next + ": " + a); transaction.addCallback(ActivityResultItem.obtain(a)); } } if (next.newIntents != null) { transaction.addCallback(NewIntentItem.obtain(next.newIntents, false /* andPause */)); } // Well the app will no longer be stopped. // Clear app token stopped state in window manager if needed. next.notifyAppResumed(next.stopped); EventLog.writeEvent(EventLogTags.AM_RESUME_ACTIVITY, next.userId, System.identityHashCode(next), next.getTask().taskId, next.shortComponentName); next.sleeping = false; mService.getAppWarningsLocked().onResumeActivity(next); mService.showAskCompatModeDialogLocked(next); next.app.pendingUiClean = true; next.app.forceProcessStateUpTo(mService.mTopProcessState); next.clearOptionsLocked(); transaction.setLifecycleStateRequest( ResumeActivityItem.obtain(next.app.repProcState, mService.isNextTransitionForward())); mService.getLifecycleManager().scheduleTransaction(transaction); if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Resumed " + next); } catch (Exception e) { } } } else { // 否则进入到启动activity的流程 if (!next.hasBeenLaunched) { next.hasBeenLaunched = true; } else { if (SHOW_APP_STARTING_PREVIEW) { next.showStartingWindow(null /* prev */, false /* newTask */, false /* taskSwich */); } if (DEBUG_SWITCH) Slog.v(TAG_SWITCH, "Restarting: " + next); } if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Restarting " + next); // 这里为主要实现 mStackSupervisor.startSpecificActivityLocked(next, true, true); } if (DEBUG_STACK) mStackSupervisor.validateTopActivitiesLocked(); return true;}我们看一下startSpecificActivityLocked，也就是真正启动activity的实现，这个会走到：
void startSpecificActivityLocked(ActivityRecord r, boolean andResume, boolean checkConfig) { ProcessRecord app = mService.getProcessRecordLocked(r.processName, r.info.applicationInfo.uid, true); getLaunchTimeTracker().setLaunchTime(r); if (app != null && app.thread != null) { try { if ((r.info.flags&ActivityInfo.FLAG_MULTIPROCESS) == 0 || !"android".equals(r.info.packageName)) { app.addPackage(r.info.packageName, r.info.applicationInfo.longVersionCode, mService.mProcessStats); } // 真正启动acitivity的代码 realStartActivityLocked(r, app, andResume, checkConfig); return; } catch (RemoteException e) { } } // 如果进程为创建，则先创建进程 mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0, "activity", r.intent.getComponent(), false, false, true); }我们再看realStartActivityLocked主体实现：
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, boolean andResume, boolean checkConfig) throws RemoteException { try { app.hasShownUi = true; app.pendingUiClean = true; app.forceProcessStateUpTo(mService.mTopProcessState); final MergedConfiguration mergedConfiguration = new MergedConfiguration( mService.getGlobalConfiguration(), r.getMergedOverrideConfiguration()); r.setLastReportedConfiguration(mergedConfiguration); logIfTransactionTooLarge(r.intent, r.icicle); final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread, r.appToken); //增加一个LaunchActivityItem的launch操作；这些操作会放到队列之中。 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()); } else { lifecycleItem = PauseActivityItem.obtain(); } // 设置他的期望状态，这个会和初始状态，形成一个状态链 clientTransaction.setLifecycleStateRequest(lifecycleItem); //这里是将操作传给client侧的实现 mService.getLifecycleManager().scheduleTransaction(clientTransaction); } catch (RemoteException e) { } return true; }scheduleTransaction实际操作是
public void schedule() throws RemoteException { mClient.scheduleTransaction(this);}其中mClient就是上层传递过来的IApplicationThread回调，此时我们回到上层代码，上层代码最终会调用到ClientTransactionHandler的：
void scheduleTransaction(ClientTransaction transaction) { transaction.preExecute(this); sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);}通过handler消息的处理，我们看到ActivityThread中主体代码实现:
final ClientTransaction transaction = (ClientTransaction) msg.obj;mTransactionExecutor.execute(transaction);if (isSystem()) { transaction.recycle();}这段实现，我们看一下TransactionExecutor的excute方法：
public void execute(ClientTransaction transaction) { final IBinder token = transaction.getActivityToken(); executeCallbacks(transaction); executeLifecycleState(transaction); mPendingActions.clear(); log("End resolving transaction"); }实际上就是执行executeCallbacks：
public void executeCallbacks(ClientTransaction transaction) { item.execute(mTransactionHandler, token, mPendingActions); item.postExecute(mTransactionHandler, token, mPendingActions); }也就是执行我们对应定义的transaction的execute和postExecute方法，我们看一下LaunchActivityItem的实现，实际上就是
@Overridepublic void execute(ClientTransactionHandler client, IBinder token, PendingTransactionActions pendingActions) { ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo, mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState, mPendingResults, mPendingNewIntents, mIsForward, mProfilerInfo, client); client.handleLaunchActivity(r, pendingActions, null /* customIntent */);}又调用回了handleLaunchActivity方法，也就是android8.0之前直接调用的接口，所以9.0 只不过增加了一个队列，实际的实现并没有变化。我们看一下其实现：
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) { if (r.isPersistable()) { mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState); } else { mInstrumentation.callActivityOnCreate(activity, r.state); }}callActivityOnCreate代码实际上就是在执行Activity的onCreate回调了。
我们再看一下上面提到的executeLifecycleState方法，这个实际上是计算期望状态和初始状态整个过程的方法，我们看一下实现:
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();// 这个就是我们的期望状态，前面设置过为ResumeActivityItem。
if (lifecycleItem == null) {
return;
}
log("Resolving lifecycle state: " + lifecycleItem);
final IBinder token = transaction.getActivityToken(); final ActivityClientRecord r = mTransactionHandler.getActivityClient(token); // 这里面就是一个计算到最终状态的过程 cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */); // 执行到达最终状态需要完成的action lifecycleItem.execute(mTransactionHandler, token, mPendingActions); lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);}OK，到此完结。
更多相关文章
- Android(安卓)Handler 教程
- 利用 Android(安卓)Systrace 做performance 分析
- 《第一行代码》第十二章引用toolbar出错，从android升级到androidx
- Android类参考---Fragment（四）
- Android(安卓)SurfaceFlinger中的工作线程：threadLoop()
- (翻译) Can I Use this Intent?
- Android(安卓)Service使用方法
- [置顶] android fragment hidenChanged方法分析
- Android的Parcel机制