一起养成写作习惯！这是我参与「掘金日新计划 · 4 月更文挑战」的第2天
Android Activity---launcher启动流程（一 Zyzote篇）--（Android 12.0）
Android Activity---launcher启动流程（二 launcher）--（Android 12.0）
Android Activity---launcher启动流程（三 普通activity启动篇）--（Android 12.0）
文章太长：总共分为三篇文章，请按顺序阅读
3.4、承接上面3.2.18我们知道进程的创建流程，后面就是我们的activity的启动流程了ActivityThread main()开始
3.4.1、ActivityThread的main方法
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
// Install selective syscall interception
// 安装选择性的系统调用拦截
AndroidOs.install();
// CloseGuard defaults to true and can be quite spammy. We
// disable it here, but selectively enable it later (via
// StrictMode) on debug builds, but using DropBox, not logs.
CloseGuard.setEnabled(false);
Environment.initForCurrentUser();
// Make sure TrustedCertificateStore looks in the right place for CA certificates
//确保TrustedCertificateStore在正确的位置查找CA证书
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
// Call per-process mainline module initialization.
initializeMainlineModules();
Process.setArgV0("<pre-initialized>");
//--------------------------------------//准备主线程的Looper
Looper.prepareMainLooper();
// Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
// It will be in the format "seq=114"
long startSeq = 0;
if (args != null) {
for (int i = args.length - 1; i >= 0; --i) {
if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
startSeq = Long.parseLong(
args[i].substring(PROC_START_SEQ_IDENT.length()));
}
}
}
//----------------------------------------------1.这里实例化ActivityThread，也就实例化了上面的mH，就是handler。
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
//2.----------------------------------获取handler
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// //主线程looper开启 一直循环，如果退出，说明程序关闭
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
attach方法：
说明：thread.attach(false, startSeq) 传入false，if条件成立,看下面代码中的几个注释点:关键为注释 3
private void attach(boolean system, long startSeq) {
sCurrentActivityThread = this;
mConfigurationController = new ConfigurationController(this);
mSystemThread = system;
if (!system) {
android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",
UserHandle.myUserId());
//----------------------1. 应用进程启动，走该流程
RuntimeInit.setApplicationObject(mAppThread.asBinder());
//------------------------2.获取AMS的本地代理类
final IActivityManager mgr = ActivityManager.getService();
try {
//------------------------------3.通过Binder调用AMS的attachApplication方法
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
// Watch for getting close to heap limit.
BinderInternal.addGcWatcher(new Runnable() {
@Override public void run() {
if (!mSomeActivitiesChanged) {
return;
}
Runtime runtime = Runtime.getRuntime();
long dalvikMax = runtime.maxMemory();
long dalvikUsed = runtime.totalMemory() - runtime.freeMemory();
if (dalvikUsed > ((3*dalvikMax)/4)) {
if (DEBUG_MEMORY_TRIM) Slog.d(TAG, "Dalvik max=" + (dalvikMax/1024)
+ " total=" + (runtime.totalMemory()/1024)
+ " used=" + (dalvikUsed/1024));
mSomeActivitiesChanged = false;
try {
ActivityTaskManager.getService().releaseSomeActivities(mAppThread);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
});
} else {
//---------------------------4.通过system_server启动ActivityThread对象
// Don't set application object here -- if the system crashes,
// we can't display an alert, we just want to die die die.
android.ddm.DdmHandleAppName.setAppName("system_process",
UserHandle.myUserId());
try {
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate Application():" + e.toString(), e);
}
}
//------------------------5.为 ViewRootImpl 设置配置更新回调， 当系统资源配置（如：系统字体）发生变化时，通知系统配置发生变
ViewRootImpl.ConfigChangedCallback configChangedCallback = (Configuration globalConfig) -> {
synchronized (mResourcesManager) {
// TODO (b/135719017): Temporary log for debugging IME service.
if (Build.IS_DEBUGGABLE && mHasImeComponent) {
Log.d(TAG, "ViewRootImpl.ConfigChangedCallback for IME, "
+ "config=" + globalConfig);
}
// We need to apply this change to the resources immediately, because upon returning
// the view hierarchy will be informed about it.
if (mResourcesManager.applyConfigurationToResources(globalConfig,
null /* compat */,
mInitialApplication.getResources().getDisplayAdjustments())) {
mConfigurationController.updateLocaleListFromAppContext(
mInitialApplication.getApplicationContext());
// This actually changed the resources! Tell everyone about it.
final Configuration updatedConfig =
mConfigurationController.updatePendingConfiguration(globalConfig);
if (updatedConfig != null) {
sendMessage(H.CONFIGURATION_CHANGED, globalConfig);
mPendingConfiguration = updatedConfig;
}
}
}
};
ViewRootImpl.addConfigCallback(configChangedCallback);
}
上面注释2处：看到IBinder这个标志，这里你应该明白了：这里是获取一个跨进程的服务。获取的什么服务呢？是ActivityManagerService 继承 IActivityManager.Stub，所以 mgr 对象 是ActivityManagerService
public static IActivityManager getService() {
return IActivityManagerSingleton.get();
}
private static final Singleton<IActivityManager> IActivityManagerSingleton =
new Singleton<IActivityManager>() {
@Override
protected IActivityManager create() {
// 最终返回的是 AMS 对象对应的 IBinder 对象（实际为 BinderProxy 对象，属于 Java 对象）
final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
// IActivityManager.Stub.asInterface(b) 返回 AMS 在客户端进程的代理对象（实际是把 BinderProxy 对象转为 IActivityManager.Stub.Proxy 这个代理对象，因为 IActivityManager.Stub.Proxy 是 IActivityManager 的子类，所以可以返回 IActivityManager）
final IActivityManager am = IActivityManager.Stub.asInterface(b);
return am;
}
};
3.4.2、ActivityManagerService的attachApplication方法
@Override
public final void attachApplication(IApplicationThread thread, long startSeq) {
if (thread == null) {
throw new SecurityException("Invalid application interface");
}
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);//看下面
Binder.restoreCallingIdentity(origId);
}
}
ActivityManagerService的attachApplicationLocked
...
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
...
private final boolean attachApplicationLocked(IApplicationThread thread, int pid, int callingUid, long startSeq) {
final ActiveInstrumentation instr2 = app.getActiveInstrumentation();
...
//通过instr2来判断当前进程是否在活动
if (instr2 != null) {
//1、进程已经在运行
thread.bindApplication(....)
}else{
//1、IPC操作，创建绑定Application,首次启动的时候
thread.bindApplication(processName, appInfo, providers, null, profilerInfo,
null, null, null, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.isPersistent(),
new Configuration(app.getWindowProcessController().getConfiguration()),
app.compat, getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, autofillOptions, contentCaptureOptions);
}
...
// 2、赋值IApplicationThread
app.makeActive(thread, mProcessStats);
...
// See if the top visible activity is waiting to run in this process...
if (normalMode) {
try {
//3、通过ATMS启动 根activity
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
} catch (Exception e) {
Slog.wtf(TAG, "Exception thrown launching activities in " + app, e);
badApp = true;
}
}
...
}
AMS的attachApplicationLocked方法主要三件事：
- 调用IApplicationThread的bindApplication方法，IPC操作，创建绑定Application；
- 通过makeActive方法赋值IApplicationThread，即验证了上面的猜测（创建进程后赋值）；
- 通过ATMS启动 根activity
先看attachApplicationLocked 代码段中的 注释1处的bindApplication方法：
ApplicationThread是ActivityThread的内部类，负责与ActivityManagerService通讯
thread的具体实现为ApplicationThread类
IApplicationThread的bindApplication方法实现是客户端的ApplicationThread的bindApplication方法，它又使用H转移到了ActivityThread的handleBindApplication方法（从Binder线程池转移到主线程），看下handleBindApplication方法：
//handle转移
public final void bindApplication(...) {
....
sendMessage(H.BIND_APPLICATION, data);
}
//具体
private void handleBindApplication(AppBindData data) {
// Register the UI Thread as a sensitive thread to the runtime.
VMRuntime.registerSensitiveThread();
...
// send up app name; do this *before* waiting for debugger
Process.setArgV0(data.processName);
android.ddm.DdmHandleAppName.setAppName(data.processName,
data.appInfo.packageName,
UserHandle.myUserId());
VMRuntime.setProcessPackageName(data.appInfo.packageName);
// 将数据目录路径传递给ART。这用于缓存信息，应该在加载任何应用程序代码之前设置。
VMRuntime.setProcessDataDirectory(data.appInfo.dataDir);
if (mProfiler.profileFd != null) {
mProfiler.startProfiling();
}
//如果应用程序是蜂巢MR1或更早，切换它的AsyncTask实现使用池执行器。通常，我们使用序列化执行器作为默认值。这必须在主线程中发生，所以主循环被正确设置。
if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {
AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
//让util。*数组类在针对Pie或更早的应用中保持“未定义
UtilConfig.setThrowExceptionForUpperArrayOutOfBounds(
data.appInfo.targetSdkVersion >= Build.VERSION_CODES.Q);
Message.updateCheckRecycle(data.appInfo.targetSdkVersion);
//将targetSdkVersion提供给UI渲染模块，它可以
//在没有访问appInfo的情况下需要它
android.graphics.Compatibility.setTargetSdkVersion(data.appInfo.targetSdkVersion);
/*
* 在生成新进程之前，请将时区重置为系统时区。
*这需要做，因为系统时区可能已经改变后
*这个过程的生成。如果不这样做，这个过程将是不正确的
*系统时区。
*/
TimeZone.setDefault(null);
/*
* 设置LocaleList。一旦我们创建了App Context，这可能会改变
*/
LocaleList.setDefault(data.config.getLocales());
if (Typeface.ENABLE_LAZY_TYPEFACE_INITIALIZATION) {
try {
Typeface.setSystemFontMap(data.mSerializedSystemFontMap);
} catch (IOException | ErrnoException e) {
Slog.e(TAG, "Failed to parse serialized system font map");
Typeface.loadPreinstalledSystemFontMap();
}
}
synchronized (mResourcesManager) {
/*
* 更新预加载的系统配置，可能不反映配置更改。可以安全地假设在AppBindData中传递的配置对象是最新的
*/
mResourcesManager.applyConfigurationToResources(data.config, data.compatInfo);
mCurDefaultDisplayDpi = data.config.densityDpi;
// 这将调用mResourcesManager，所以将它保持在synchronized块中。
mConfigurationController.applyCompatConfiguration();
}
data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
if (agent != null) {
handleAttachAgent(agent, data.info);
}
/**
* Switch this process to density compatibility mode if needed.
--如果需要，将此过程切换到密度兼容模式。
*/
if ((data.appInfo.flags&ApplicationInfo.FLAG_SUPPORTS_SCREEN_DENSITIES)
== 0) {
mDensityCompatMode = true;
Bitmap.setDefaultDensity(DisplayMetrics.DENSITY_DEFAULT);
}
mConfigurationController.updateDefaultDensity(data.config.densityDpi);
// mCoreSettings is only updated from the main thread, while this function is only called
// from main thread as well, so no need to lock here.
final String use24HourSetting = mCoreSettings.getString(Settings.System.TIME_12_24);
Boolean is24Hr = null;
if (use24HourSetting != null) {
is24Hr = "24".equals(use24HourSetting) ? Boolean.TRUE : Boolean.FALSE;
}
// null : use locale default for 12/24 hour formatting,
// false : use 12 hour format,
// true : use 24 hour format.
DateFormat.set24HourTimePref(is24Hr);
updateDebugViewAttributeState();
StrictMode.initThreadDefaults(data.appInfo);
StrictMode.initVmDefaults(data.appInfo);
if (data.debugMode != ApplicationThreadConstants.DEBUG_OFF) {
// XXX should have option to change the port.
Debug.changeDebugPort(8100);
if (data.debugMode == ApplicationThreadConstants.DEBUG_WAIT) {
Slog.w(TAG, "Application " + data.info.getPackageName()
+ " is waiting for the debugger on port 8100...");
IActivityManager mgr = ActivityManager.getService();
try {
mgr.showWaitingForDebugger(mAppThread, true);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
Debug.waitForDebugger();
try {
mgr.showWaitingForDebugger(mAppThread, false);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
} else {
Slog.w(TAG, "Application " + data.info.getPackageName()
+ " can be debugged on port 8100...");
}
}
// Allow binder tracing, and application-generated systrace messages if we're profileable.
boolean isAppDebuggable = (data.appInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
boolean isAppProfileable = isAppDebuggable || data.appInfo.isProfileable();
Trace.setAppTracingAllowed(isAppProfileable);
if ((isAppProfileable || Build.IS_DEBUGGABLE) && data.enableBinderTracking) {
Binder.enableTracing();
}
// Initialize heap profiling.
if (isAppProfileable || Build.IS_DEBUGGABLE) {
nInitZygoteChildHeapProfiling();
}
// Allow renderer debugging features if we're debuggable.
HardwareRenderer.setDebuggingEnabled(isAppDebuggable || Build.IS_DEBUGGABLE);
HardwareRenderer.setPackageName(data.appInfo.packageName);
// Pass the current context to HardwareRenderer
HardwareRenderer.setContextForInit(getSystemContext());
// Instrumentation info affects the class loader, so load it before
// setting up the app context.
final InstrumentationInfo ii;
if (data.instrumentationName != null) {
ii = prepareInstrumentation(data);
} else {
ii = null;
}
final ContextImpl appContext = ContextImpl.createAppContext(this, data.info);
mConfigurationController.updateLocaleListFromAppContext(appContext);
// Initialize the default http proxy in this process.
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Setup proxies");
try {
// In pre-boot mode (doing initial launch to collect password), not all system is up.
// This includes the connectivity service, so trying to obtain ConnectivityManager at
// that point would return null. Check whether the ConnectivityService is available, and
// avoid crashing with a NullPointerException if it is not.
final IBinder b = ServiceManager.getService(Context.CONNECTIVITY_SERVICE);
if (b != null) {
final ConnectivityManager cm =
appContext.getSystemService(ConnectivityManager.class);
Proxy.setHttpProxyConfiguration(cm.getDefaultProxy());
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
}
if (!Process.isIsolated()) {
final int oldMask = StrictMode.allowThreadDiskWritesMask();
try {
setupGraphicsSupport(appContext);
} finally {
StrictMode.setThreadPolicyMask(oldMask);
}
} else {
HardwareRenderer.setIsolatedProcess(true);
}
// Install the Network Security Config Provider. This must happen before the application
// code is loaded to prevent issues with instances of TLS objects being created before
// the provider is installed.
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "NetworkSecurityConfigProvider.install");
NetworkSecurityConfigProvider.install(appContext);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
// Continue loading instrumentation.
if (ii != null) {
initInstrumentation(ii, data, appContext);
} else {
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
}
if ((data.appInfo.flags&ApplicationInfo.FLAG_LARGE_HEAP) != 0) {
dalvik.system.VMRuntime.getRuntime().clearGrowthLimit();
} else {
// Small heap, clamp to the current growth limit and let the heap release
// pages after the growth limit to the non growth limit capacity. b/18387825
dalvik.system.VMRuntime.getRuntime().clampGrowthLimit();
}
// Allow disk access during application and provider setup. This could
// block processing ordered broadcasts, but later processing would
// probably end up doing the same disk access.
Application app;
final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
final StrictMode.ThreadPolicy writesAllowedPolicy = StrictMode.getThreadPolicy();
try {
// If the app is being launched for full backup or restore, bring it up in
// a restricted environment with the base application class.
app = data.info.makeApplication(data.restrictedBackupMode, null);
// Propagate autofill compat state
app.setAutofillOptions(data.autofillOptions);
// Propagate Content Capture options
app.setContentCaptureOptions(data.contentCaptureOptions);
sendMessage(H.SET_CONTENT_CAPTURE_OPTIONS_CALLBACK, data.appInfo.packageName);
mInitialApplication = app;
final boolean updateHttpProxy;
synchronized (this) {
updateHttpProxy = mUpdateHttpProxyOnBind;
// This synchronized block ensures that any subsequent call to updateHttpProxy()
// will see a non-null mInitialApplication.
}
if (updateHttpProxy) {
ActivityThread.updateHttpProxy(app);
}
// don't bring up providers in restricted mode; they may depend on the
// app's custom Application class
if (!data.restrictedBackupMode) {
if (!ArrayUtils.isEmpty(data.providers)) {
installContentProviders(app, data.providers);
}
}
// Do this after providers, since instrumentation tests generally start their
// test thread at this point, and we don't want that racing.
try {
mInstrumentation.onCreate(data.instrumentationArgs);
}
catch (Exception e) {
throw new RuntimeException(
"Exception thrown in onCreate() of "
+ data.instrumentationName + ": " + e.toString(), e);
}
try {
mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
if (!mInstrumentation.onException(app, e)) {
throw new RuntimeException(
"Unable to create application " + app.getClass().getName()
+ ": " + e.toString(), e);
}
}
} finally {
// If the app targets < O-MR1, or doesn't change the thread policy
// during startup, clobber the policy to maintain behavior of b/36951662
if (data.appInfo.targetSdkVersion < Build.VERSION_CODES.O_MR1
|| StrictMode.getThreadPolicy().equals(writesAllowedPolicy)) {
StrictMode.setThreadPolicy(savedPolicy);
}
}
// Preload fonts resources
FontsContract.setApplicationContextForResources(appContext);
if (!Process.isIsolated()) {
try {
final ApplicationInfo info =
getPackageManager().getApplicationInfo(
data.appInfo.packageName,
PackageManager.GET_META_DATA /*flags*/,
UserHandle.myUserId());
if (info.metaData != null) {
final int preloadedFontsResource = info.metaData.getInt(
ApplicationInfo.METADATA_PRELOADED_FONTS, 0);
if (preloadedFontsResource != 0) {
data.info.getResources().preloadFonts(preloadedFontsResource);
}
}
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
以上太长缩短给如下：
private void handleBindApplication(AppBindData data) {
...
final LoadedApk pi = getPackageInfo(instrApp, data.compatInfo,
appContext.getClassLoader(), false, true, false);
final ContextImpl instrContext = ContextImpl.createAppContext(this, pi,
appContext.getOpPackageName());
try {
//创建Instrumentation
final ClassLoader cl = instrContext.getClassLoader();
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
}
...
final ComponentName component = new ComponentName(ii.packageName, ii.name);
mInstrumentation.init(this, instrContext, appContext, component,
data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
...
//创建Application
app = data.info.makeApplication(data.restrictedBackupMode, null);
...
mInitialApplication = app;
try {
mInstrumentation.onCreate(data.instrumentationArgs);
}
...
try {
//内部调用Application的onCreate方法
mInstrumentation.callApplicationOnCreate(app);
}
...
}
这一段主要是做一些应用系统初始化的东西如时区啊：
主要就是创建Application，并且调用生命周期onCreate方法。你会发现在前面介绍的ActivityThread的performLaunchActivity方法中，也有同样的操作，只不过会先判断Application是否已存在。也就是说，正常情况下Application的初始化是在handleBindApplication方法中的，并且是创建进程后调用的。performLaunchActivity中只是做了一个检测，异常情况Application不存在时才会创建。
这里注意一点，创建Application后，内部会attach方法，attach内部会调用attachBaseContext方法，attachBaseContext方法是我们能接触到的一个方法，接着才是onCreate方法。
在看attachApplicationLocked 代码段中的 注释2处的makeActive方法：
看到使用mWindowProcessController.setThread(thread)确实完成了IApplicationThread的赋值。这样就可以依据IApplicationThread是否为空判断进程是否存在了。
public void makeActive(IApplicationThread _thread, ProcessStatsService tracker) {
mProfile.onProcessActive(thread, tracker);
thread = _thread;
mWindowProcessController.setThread(thread);
}
3.4.3、ActivityTaskManagerService中内部类LocalService类中的attachApplication（）方法
说明：上面attachApplicationLocked 代码段中的注释3处 mAtmInternal的对象为 ActivityTaskManagerInternal，它的取值在LocalServices.getService(ActivityTaskManagerInternal.class)
LocalServices为一个单例内部维护了一个集合，那就查找在哪给 LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);赋值 ActivityTaskManagerInternal添加了对象，发现是在ActivityTaskManagerService中mInternal=LocalService()，而LocalService 为ActivityTaskManagerService的内部类
ActivityTaskManagerService类：
@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
public ActivityTaskManagerService(Context context) {
...
mInternal = new LocalService();
...
}
private void start() {
LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}
LocalService类：
@HotPath(caller = HotPath.PROCESS_CHANGE)
@Override
public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
synchronized (mGlobalLockWithoutBoost) {
if (Trace.isTagEnabled(TRACE_TAG_WINDOW_MANAGER)) {
Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, "attachApplication:" + wpc.mName);
}
try {
return mRootWindowContainer.attachApplication(wpc);
} finally {
Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
}
}
}
3.4.4、RootWindowContainer中的attachApplication方法
**说明：**遍历activity栈，此时理论上应该只有一个根activity，然后调用PooledLambda.obtainFunction方法中的参数执行 startActivityForAttachedApplicationIfNeeded方法，看到这里我们知道了，这里就开始走上面分析过的流程了，即使用ClientTransaction会跨进程交给客户端
boolean attachApplication(WindowProcessController app) throws RemoteException {
boolean didSomething = false;
for (int displayNdx = getChildCount() - 1; displayNdx >= 0; --displayNdx) {
mTmpRemoteException = null;
mTmpBoolean = false; // Set to true if an activity was started.
final DisplayContent display = getChildAt(displayNdx);
display.forAllRootTasks(rootTask -> {
if (mTmpRemoteException != null) {
return;
}
if (rootTask.getVisibility(null /*starting*/) == TASK_VISIBILITY_INVISIBLE) {
return;
}
final PooledFunction c = PooledLambda.obtainFunction(
RootWindowContainer::startActivityForAttachedApplicationIfNeeded, this,
PooledLambda.__(ActivityRecord.class), app,
rootTask.topRunningActivity());
rootTask.forAllActivities(c);
c.recycle();
});
if (mTmpRemoteException != null) {
throw mTmpRemoteException;
}
didSomething |= mTmpBoolean;
}
if (!didSomething) {
ensureActivitiesVisible(null, 0, false /* preserve_windows */);
}
return didSomething;
}
RootWindowContainer中的startActivityForAttachedApplicationIfNeeded方法
此时理论上应该只有一个根activity，然后调用mTaskSupervisor.realStartActivityLocked方法
private boolean startActivityForAttachedApplicationIfNeeded(ActivityRecord r,
WindowProcessController app, ActivityRecord top) {
if (r.finishing || !r.okToShowLocked() || !r.visibleIgnoringKeyguard || r.app != null
|| app.mUid != r.info.applicationInfo.uid || !app.mName.equals(r.processName)) {
return false;
}
try {
if (mTaskSupervisor.realStartActivityLocked(r, app,
top == r && r.isFocusable() /*andResume*/, true /*checkConfig*/)) {
mTmpBoolean = true;
}
} catch (RemoteException e) {
Slog.w(TAG, "Exception in new application when starting activity "
+ top.intent.getComponent().flattenToShortString(), e);
mTmpRemoteException = e;
return true;
}
return false;
}
3.4.5、ActivityTaskSupervisor中的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 boolean isTransitionForward = r.isTransitionForward();
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.getSavedState(), r.getPersistentSavedState(), results, newIntents,
r.takeOptions(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
r.getLaunchedFromBubble()));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
// Schedule transaction.，关键步骤
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
return true;
}
中间有段代码如上，通过 ClientTransaction.obtain( proc.getThread(), r.appToken)获取了clientTransaction，其中参数proc.getThread()是IApplicationThread，就是前面提到的ApplicationThread在系统进程的代理。
ClientTransaction是包含一系列的待客户端处理的事务的容器，客户端接收后取出事务并执行。
接着看，使用clientTransaction.addCallback添加了LaunchActivityItem实例：
private List<ClientTransactionItem> mActivityCallbacks;
public void addCallback(ClientTransactionItem activityCallback) {
if (mActivityCallbacks == null) {
mActivityCallbacks = new ArrayList<>();
}
mActivityCallbacks.add(activityCallback);
}
LaunchActivityItem的obtain（）方法
/** Obtain an instance initialized with provided params. */
public static LaunchActivityItem obtain(Intent intent, int ident, ActivityInfo info,
Configuration curConfig, Configuration overrideConfig, CompatibilityInfo compatInfo,
String referrer, IVoiceInteractor voiceInteractor, int procState, Bundle state,
PersistableBundle persistentState, List<ResultInfo> pendingResults,
List<ReferrerIntent> pendingNewIntents, ActivityOptions activityOptions,
boolean isForward, ProfilerInfo profilerInfo, IBinder assistToken,
IActivityClientController activityClientController,
FixedRotationAdjustments fixedRotationAdjustments, IBinder shareableActivityToken,
boolean launchedFromBubble) {
LaunchActivityItem instance = ObjectPool.obtain(LaunchActivityItem.class);
if (instance == null) {
instance = new LaunchActivityItem();
}
setValues(instance, intent, ident, info, curConfig, overrideConfig, compatInfo, referrer,
voiceInteractor, procState, state, persistentState, pendingResults,
pendingNewIntents, activityOptions, isForward, profilerInfo, assistToken,
activityClientController, fixedRotationAdjustments, shareableActivityToken,
launchedFromBubble);
return instance;
}
new了一个LaunchActivityItem然后设置各种值。我们从名字就能看出，它就是用来启动activity的。它是怎么发挥作用的呢？接着看：
回到realStartActivityLocked方法，接着调用了ActivityTaskSupervisor类中realStartActivityLocked方法 中的mService.getLifecycleManager().scheduleTransaction(clientTransaction)，mService是ActivityTaskManagerService，getLifecycleManager()方法获取的是ClientLifecycleManager实例，它的scheduleTransaction方法如下：
3.4.6、ClientLifecycleManager中scheduleTransaction方法
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
transaction.recycle();
}
}
就是调用ClientTransaction的schedule方法，那就看看：
mClient的对象是IApplicationThread，看到这个我们就眼熟了前面也提到过他这里可以知道通过aidl接口 ，转移到了ApplicationThread类中，实现与ActivityThread的通信
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
启动Activity的操作从客户端 跨进程 转移到 ATMS，ATMS通过ActivityStarter、ActivityStack、ActivityStackSupervisor 对 Activity任务、activity栈、Activity记录 管理后，又用过跨进程把正在启动过程又转移到了客户端。
3.4.7、回到ActivityThread下的ApplicationThread类中的scheduleTransaction方法（1）
说明：查找 ActivityThread中的scheduleTransaction(transaction);方法没找到，在父类ClientTransactionHandler中找到
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);//父类ClientTransactionHandler中
}
3.4.7、ClientTransactionHandler类中的scheduleTransaction方法（2）
说明： sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);回到ActivityThread
void scheduleTransaction(ClientTransaction transaction) {
transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
3.4.7、ActivityThread类中的sendMessage方法（3）
**说明：**使用一个mH对象，它是一个名叫 “H ”的Handle类
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
if (DEBUG_MESSAGES) {
Slog.v(TAG,
"SCHEDULE " + what + " " + mH.codeToString(what) + ": " + arg1 + " / " + obj);
}
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
3.4.8、ActivityThread类中的sendMessage方法
**说明：**从3.4.7（2）、可知handleMessage走的是 case EXECUTE_TRANSACTION:选项
class H extends Handler {
...
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
...
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
//---------------------1.下一步看这里
mTransactionExecutor.execute(transaction);
if (isSystem()) {
// Client transactions inside system process are recycled on the client side
// instead of ClientLifecycleManager to avoid being cleared before this
// message is handled.
transaction.recycle();
}
// TODO(lifecycler): Recycle locally scheduled transactions.
break;
...
}
Object obj = msg.obj;
if (obj instanceof SomeArgs) {
((SomeArgs) obj).recycle();
}
if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));
}
...
}
3.4.9、TransactionExecutor的execute
**
解决事务。首先，所有回调将按照它们在列表中出现的顺序执行。如果回调需要特定的执行前或执行后状态，客户端将相应地转换。然后客户端将循环到最终的生命周期状态(如果提供的话)。否则，它将保持在初始状态或回调所需的最后一个状态。
**
public void execute(ClientTransaction transaction) {
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");
final IBinder token = transaction.getActivityToken();
if (token != null) {
final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =
mTransactionHandler.getActivitiesToBeDestroyed();
final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);
if (destroyItem != null) {
if (transaction.getLifecycleStateRequest() == destroyItem) {
// It is going to execute the transaction that will destroy activity with the
// token, so the corresponding to-be-destroyed record can be removed.
activitiesToBeDestroyed.remove(token);
}
if (mTransactionHandler.getActivityClient(token) == null) {
// The activity has not been created but has been requested to destroy, so all
// transactions for the token are just like being cancelled.
Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
+ transactionToString(transaction, mTransactionHandler));
return;
}
}
}
if (DEBUG_RESOLVER) Slog.d(TAG, transactionToString(transaction, mTransactionHandler));
//1.----------------activit活动遍历
executeCallbacks(transaction);
//2.----------------activit活动的生命周期状况监测，处于哪个过程如：oncreate，onresume
executeLifecycleState(transaction);
mPendingActions.clear();
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}
TransactionExecutor的 executeCallbacks方法
**说明：**遍历callbacks，调用ClientTransactionItem的execute方法，而我们这里要关注的是ClientTransactionItem的子类LaunchActivityItem，看下它的execute方法：至于为什么是LaunchActivityItem 前面在 3.4.5步骤中将他加入到callback中去的
**
循环回调请求的所有状态，并在适当的时间执行它们。
**
@VisibleForTesting
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
if (callbacks == null || callbacks.isEmpty()) {
// No callbacks to execute, return early.
return;
}
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callbacks in transaction");
final IBinder token = transaction.getActivityToken();
ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
// In case when post-execution state of the last callback matches the final state requested
// for the activity in this transaction, we won't do the last transition here and do it when
// moving to final state instead (because it may contain additional parameters from server).
final ActivityLifecycleItem finalStateRequest = transaction.getLifecycleStateRequest();
final int finalState = finalStateRequest != null ? finalStateRequest.getTargetState()
: UNDEFINED;
// Index of the last callback that requests some post-execution state.
final int lastCallbackRequestingState = lastCallbackRequestingState(transaction);
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Resolving callback: " + item);
final int postExecutionState = item.getPostExecutionState();
final int closestPreExecutionState = mHelper.getClosestPreExecutionState(r,
item.getPostExecutionState());
if (closestPreExecutionState != UNDEFINED) {
cycleToPath(r, closestPreExecutionState, transaction);
}
//--------------------------------------------------------1.遍历callbacks，调用ClientTransactionItem的execute方法，而我们这里要关注的是ClientTransactionItem的子类LaunchActivityItem，看下它的execute方法：
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
if (r == null) {
// Launch activity request will create an activity record.
r = mTransactionHandler.getActivityClient(token);
}
if (postExecutionState != UNDEFINED && r != null) {
// Skip the very last transition and perform it by explicit state request instead.
final boolean shouldExcludeLastTransition =
i == lastCallbackRequestingState && finalState == postExecutionState;
cycleToPath(r, postExecutionState, shouldExcludeLastTransition, transaction);
}
}
}
3.4.10、LaunchActivityItem中的execute方法
说明：里面调用了client.handleLaunchActivity方法，client是ClientTransactionHandler的实例，是在TransactionExecutor构造方法传入的，TransactionExecutor创建是在ActivityThread中：
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = client.getLaunchingActivity(token);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
3.4.11、ActivityThread中的handleLaunchActivity方法
**说明：**下面关键点在于performLaunchActivity方法
@Override
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
// If we are getting ready to gc after going to the background, well
// we are back active so skip it.
unscheduleGcIdler();
mSomeActivitiesChanged = true;
if (r.profilerInfo != null) {
mProfiler.setProfiler(r.profilerInfo);
mProfiler.startProfiling();
}
if (r.mPendingFixedRotationAdjustments != null) {
// The rotation adjustments must be applied before handling configuration, so process
// level display metrics can be adjusted.
overrideApplicationDisplayAdjustments(r.token, adjustments ->
adjustments.setFixedRotationAdjustments(r.mPendingFixedRotationAdjustments));
}
// Make sure we are running with the most recent config.
mConfigurationController.handleConfigurationChanged(null, null);
if (localLOGV) Slog.v(
TAG, "Handling launch of " + r);
// Initialize before creating the activity
if (ThreadedRenderer.sRendererEnabled
&& (r.activityInfo.flags & ActivityInfo.FLAG_HARDWARE_ACCELERATED) != 0) {
HardwareRenderer.preload();
}
WindowManagerGlobal.initialize();
// Hint the GraphicsEnvironment that an activity is launching on the process.
GraphicsEnvironment.hintActivityLaunch();
final Activity a = performLaunchActivity(r, customIntent);
if (a != null) {
r.createdConfig = new Configuration(mConfigurationController.getConfiguration());
reportSizeConfigurations(r);
if (!r.activity.mFinished && pendingActions != null) {
pendingActions.setOldState(r.state);
pendingActions.setRestoreInstanceState(true);
pendingActions.setCallOnPostCreate(true);
}
} else {
// If there was an error, for any reason, tell the activity manager to stop us.
ActivityClient.getInstance().finishActivity(r.token, Activity.RESULT_CANCELED,
null /* resultData */, Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
}
return a;
}
3.4.12、ActivityThread中的performLaunchActivity方法
/** activity 启动的核心实现. */
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//1、从ActivityClientRecord获取待启动的Activity的组件信息
ActivityInfo aInfo = r.activityInfo;
if (r.packageInfo == null) {
r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
Context.CONTEXT_INCLUDE_CODE);
}
ComponentName component = r.intent.getComponent();
if (component == null) {
component = r.intent.resolveActivity(
mInitialApplication.getPackageManager());
r.intent.setComponent(component);
}
if (r.activityInfo.targetActivity != null) {
component = new ComponentName(r.activityInfo.packageName,
r.activityInfo.targetActivity);
}
//创建ContextImpl对象
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
//2、创建activity实例
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
..
}
try {
//3、创建Application对象（如果没有的话）
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
...
if (activity != null) {
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
appContext.setOuterContext(activity);
//4、attach方法为activity关联上下文环境
activity.attach(appContext, this, getInstrumentation(), r.token,
r.ident, app, r.intent, r.activityInfo, title, r.parent,
r.embeddedID, r.lastNonConfigurationInstances, config,
r.referrer, r.voiceInteractor, window, r.configCallback,
r.assistToken);
if (customIntent != null) {
activity.mIntent = customIntent;
}
r.lastNonConfigurationInstances = null;
checkAndBlockForNetworkAccess();
activity.mStartedActivity = false;
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
activity.mCalled = false;
//5、调用生命周期onCreate
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
if (!activity.mCalled) {
throw new SuperNotCalledException(
"Activity " + r.intent.getComponent().toShortString() +
" did not call through to super.onCreate()");
}
r.activity = activity;
}
r.setState(ON_CREATE);
synchronized (mResourcesManager) {
mActivities.put(r.token, r);
}
}
...
return activity;
}
- 从ActivityClientRecord获取待启动的Activity的组件信息
- 通过mInstrumentation.newActivity方法使用类加载器创建activity实例
- 通过LoadedApk的makeApplication方法创建Application对象，内部也是通过mInstrumentation使用类加载器，创建后就调用了instrumentation.callApplicationOnCreate方法，也就是Application的onCreate方法。
- 创建ContextImpl对象并通过activity.attach方法对重要数据初始化，关联了Context的具体实现ContextImpl，attach方法内部还完成了window创建，这样Window接收到外部事件后就能传递给Activity了。
- 调用Activity的onCreate方法，是通过 mInstrumentation.callActivityOnCreate方法完成。
到这里Activity的onCreate方法执行完，那么onStart、onResume呢？
上面看到LaunchActivityItem，是用来启动Activity的，也就是走到Activity的onCreate，那么是不是有 "XXXActivityItem"呢? 有的：
- LaunchActivityItem 远程App端的onCreate生命周期事务
- ResumeActivityItem 远程App端的onResume生命周期事务
- PauseActivityItem 远程App端的onPause生命周期事务
- StopActivityItem 远程App端的onStop生命周期事务
- DestroyActivityItem 远程App端onDestroy生命周期事务
另外梳理过程中涉及的几个类：
- ClientTransaction 客户端事务控制者
- ClientLifecycleManager 客户端的生命周期事务控制者
- TransactionExecutor 远程通信事务执行者
那么我们再来看看ResumeActivityItem吧。
我们再来重新看看在ActivityStackSupervisor的realStartActivityLocked方法：
3.4.13、上面执行完Activity的onCreate方法执行完，那么onStart、onResume呢？，我们看 ActivityStackSupervisor的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 boolean isTransitionForward = r.isTransitionForward();
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.getSavedState(), r.getPersistentSavedState(), results, newIntents,
r.takeOptions(), isTransitionForward,
proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
r.getLaunchedFromBubble()));
// Set desired final state.
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
//-------------------------------------1.看这里初始化resume的参数
lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
} else {
lifecycleItem = PauseActivityItem.obtain();
}
//-------------------------------------2.设置activity的生命周期状态
clientTransaction.setLifecycleStateRequest(lifecycleItem);
//-------------------------------------3.走 3.4.5~3.4.9的流程
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
return true;
}
说明：看注释3 后面的步骤就是重复上面 3.4.5~3.4.9的流程
3.4.14、TransactionExecutor的execute，前面我们关注 executeCallbacks，onResume流程现在看executeLifecycleState
**
解决事务。首先，所有回调将按照它们在列表中出现的顺序执行。如果回调需要特定的执行前或执行后状态，客户端将相应地转换。然后客户端将循环到最终的生命周期状态(如果提供的话)。否则，它将保持在初始状态或回调所需的最后一个状态。
**
public void execute(ClientTransaction transaction) {
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "Start resolving transaction");
final IBinder token = transaction.getActivityToken();
if (token != null) {
final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =
mTransactionHandler.getActivitiesToBeDestroyed();
final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);
if (destroyItem != null) {
if (transaction.getLifecycleStateRequest() == destroyItem) {
// It is going to execute the transaction that will destroy activity with the
// token, so the corresponding to-be-destroyed record can be removed.
activitiesToBeDestroyed.remove(token);
}
if (mTransactionHandler.getActivityClient(token) == null) {
// The activity has not been created but has been requested to destroy, so all
// transactions for the token are just like being cancelled.
Slog.w(TAG, tId(transaction) + "Skip pre-destroyed transaction:\n"
+ transactionToString(transaction, mTransactionHandler));
return;
}
}
}
if (DEBUG_RESOLVER) Slog.d(TAG, transactionToString(transaction, mTransactionHandler));
//1.----------------activit活动遍历
executeCallbacks(transaction);
//2.----------------activit活动的生命周期状况监测，处于哪个过程如：oncreate，onresume
executeLifecycleState(transaction);
mPendingActions.clear();
if (DEBUG_RESOLVER) Slog.d(TAG, tId(transaction) + "End resolving transaction");
}
3.4.15、ActivityLifecycleItem的execute方法，lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
说明：lifecycleItem在上面3.4.13处的注释1处传入的是ResumeActivityItem，所以执行ResumeActivityItem的execute方法
private void executeLifecycleState(ClientTransaction transaction) {
final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
if (lifecycleItem == null) {
// No lifecycle request, return early.
return;
}
final IBinder token = transaction.getActivityToken();
final ActivityClientRecord r = mTransactionHandler.getActivityClient(token);
if (DEBUG_RESOLVER) {
Slog.d(TAG, tId(transaction) + "Resolving lifecycle state: "
+ lifecycleItem + " for activity: "
+ getShortActivityName(token, mTransactionHandler));
}
if (r == null) {
// Ignore requests for non-existent client records for now.
return;
}
// Cycle to the state right before the final requested state.
cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);
// Execute the final transition with proper parameters.
//-----------------------------------------1.使用适当的参数执行最后的转换。,走这里
lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}
3.4.16、ResumeActivityItem中的 execute方法
说明：参考3.4.10，里面调用了client.handleResumeActivity方法，client是ClientTransactionHandler的实例，是在TransactionExecutor构造方法传入的，TransactionExecutor创建是在ActivityThread中：
@Override
public void execute(ClientTransactionHandler client, ActivityClientRecord r,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityResume");
client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
"RESUME_ACTIVITY");
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
3.4.17、ActivityThread中的handleResumeActivity方法
@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
String reason) {
...
//---------------------------------------1. performResumeActivity内部会走onStart、onResume
final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);
if (r == null) {
// We didn't actually resume the activity, so skipping any follow-up actions.
return;
}
...
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (r.mPreserveWindow) {
a.mWindowAdded = true;
r.mPreserveWindow = false;
ViewRootImpl impl = decor.getViewRootImpl();
if (impl != null) {
impl.notifyChildRebuilt();
}
}
...
if (!r.activity.mFinished && willBeVisible && r.activity.mDecor != null && !r.hideForNow) {
if (r.newConfig != null) {
performConfigurationChangedForActivity(r, r.newConfig);
if (DEBUG_CONFIGURATION) {
Slog.v(TAG, "Resuming activity " + r.activityInfo.name + " with newConfig "
+ r.activity.mCurrentConfig);
}
r.newConfig = null;
}
if (localLOGV) Slog.v(TAG, "Resuming " + r + " with isForward=" + isForward);
WindowManager.LayoutParams l = r.window.getAttributes();
if ((l.softInputMode
& WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
!= forwardBit) {
l.softInputMode = (l.softInputMode
& (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
| forwardBit;
if (r.activity.mVisibleFromClient) {
ViewManager wm = a.getWindowManager();
View decor = r.window.getDecorView();
wm.updateViewLayout(decor, l);
}
}
r.activity.mVisibleFromServer = true;
mNumVisibleActivities++;
if (r.activity.mVisibleFromClient) {
//---------------------------------2.添加window、设置可见
r.activity.makeVisible();
}
}
r.nextIdle = mNewActivities;
mNewActivities = r;
if (localLOGV) Slog.v(TAG, "Scheduling idle handler for " + r);
Looper.myQueue().addIdleHandler(new Idler());
}
handleResumeActivity主要做了以下事情：
- 调用生命周期：通过performResumeActivity方法，内部调用生命周期onStart、onResume方法
- 设置视图可见：通过activity.makeVisible方法，添加window、设置可见。（所以视图的真正可见是在onResume方法之后）
先来看第一点，生命周期的调用。即performResumeActivity方法：
public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,
String reason) {
final ActivityClientRecord r = mActivities.get(token);
...
try {
...
r.activity.performResume(r.startsNotResumed, reason);
...
}
...
return r;
}
复制代码
3.4.18、调用了activity.performResume方法：
final void performResume(boolean followedByPause, String reason) {
dispatchActivityPreResumed();
//内部会走onStart
performRestart(true /* start */, reason);
...
// 走onResume
mInstrumentation.callActivityOnResume(this);
...
//这里是走fragment的onResume
mFragments.dispatchResume();
mFragments.execPendingActions();
...
}
复制代码
先调用了performRestart()，performRestart()又会调用performStart()，performStart()内部调用了mInstrumentation.callActivityOnStart(this)，也就是**Activity的onStart()**方法了。
然后是mInstrumentation.callActivityOnResume，也就是**Activity的onResume()**方法了。到这里启动后的生命周期走完了。
再看3.4.17中的第二点，设置视图可见。即activity.makeVisible()方法：
//Activity
void makeVisible() {
if (!mWindowAdded) {
ViewManager wm = getWindowManager();
wm.addView(mDecor, getWindow().getAttributes());
mWindowAdded = true;
}
mDecor.setVisibility(View.VISIBLE);
}
复制代码
这里把activity的顶级布局mDecor通过windowManager.addView()方法，把视图添加到window，并设置mDecor可见。到这里视图是真正可见了。值得注意的是，视图的真正可见是在onResume方法之后的。
另外一点，Activity视图渲染到Window后，会设置window焦点变化，先走到DecorView的onWindowFocusChanged方法，最后是到Activity的onWindowFocusChanged方法，表示首帧绘制完成，此时Activity可交互。
好了，到这里就是真正创建完成并且可见了。
3.4.19、总结Activity onCreate、onResume调用链如下（上述3.4.1~3.4.18流程如下）**
1.-----ActivityThread的main方法--attach()方法中的mgr.attachApplication(mAppThread, startSeq)方法到达ActivityManagerServic-》 见3.4.1
2.-----ActivityManagerServic的attachApplication方法--
attachApplicationLocked方法（该方法做了- 调用IApplicationThread的bindApplication方法，IPC操作，创建绑定Application；
- 通过makeActive方法赋值IApplicationThread，即验证了上面的猜测（创建进程后赋值）；
- 通过ATMS启动 **根activity**）-- mAtmInternal.attachApplication(app.getWindowProcessController())方法-》 见3.4.2（attachApplicationLocked中的三个步骤）
3.-----ActivityTaskManagerService中内部类LocalService类中的attachApplication（）方法-》 见3.4.3
4.-----RootWindowContainer中的attachApplication方法--**RootWindowContainer中的startActivityForAttachedApplicationIfNeeded方法**--RootWindowContainer中的startActivityForAttachedApplicationIfNeeded方法-》 见3.4.4
5.-----ActivityTaskSupervisor中的realStartActivityLocked方法-mService.getLifecycleManager().scheduleTransaction(clientTransaction)-》见3.4.5
6.-----ClientLifecycleManager中scheduleTransaction方法-》见3.4.6
7.-----ActivityThread下的ApplicationThread类中的scheduleTransaction方法-》见3.4.7（1）
8.-----ClientTransactionHandler类中的scheduleTransaction方法（2）-》见3.4.7（2）
9.-----ActivityThread类中的sendMessage方法（3）-》见3.4.7（3）
10.-----ActivityThread类中的sendMessage方法-》见3.4.8
11.-----TransactionExecutor的execute--TransactionExecutor的 executeCallbacks方法-》见3.4.9
12.-----3.4.10、LaunchActivityItem中的execute方法-》见3.4.10
13.-----ActivityThread中的handleLaunchActivity方法-》见3.4.11
14.-----ActivityThread中的performLaunchActivity方法中的 mInstrumentation.callActivityOnCreate方法 到这里onCreate过程结束-》见3.4.12
15.-----onStart、onResume呢？，我们看 ActivityStackSupervisor的realStartActivityLocked方法：-》见3.4.13
16.-----重复上面 3.4.5~3.4.9的流程后走的 TransactionExecutor的execute，前面我们关注 executeCallbacks，onResume流程现在看executeLifecycleState-》见3.4.14
17.-----ActivityLifecycleItem的execute方法，lifecycleItem.execute(mTransactionHandler, token, mPendingActions);-》见3.4.15
18.----ResumeActivityItem中的 execute方法-》见3.4.16
19.----ActivityThread中的handleResumeActivity方法-》见3.4.17
20.----调用了activity.performResume方法：-》见3.4.18
3.5、launcher启动流程总结如下：
3.5.1、应用进程创建调用链如下（上述流程3.2.1~3.2.8流程如下）
1.-----SystemService的main（）--run（）--startOtherServices（）-》
2.-----ActivityManagerService的systemReady(）方法的startHomeOnAllDisplays方法（实际是[ActivityTaskManagerService.java] startHomeOnAllDisplays()）-》 见3.2.2
3.-----ActivityManagerService的systemReady(）方法的startHomeOnAllDisplays方法-》 见3.2.2
4.-----RootWindowContainer中的 startHomeOnAllDisplays()--startHomeOnDisplay--startHomeOnTaskDisplayArea-》 见3.2.3
5.-----ActivityStartController中的startHomeActivity中的 obtainStarter(..). execute()方法-》见3.2.4
6.----- ActivityStarter中的 execute()--executeRequest--startActivityUnchecked--startActivityInner--recycleTask--resumeTargetRootTaskIfNeeded（）方法 -》见3.2.5
7.----- RootWindowContainer 中的resumeFocusedTasksTopActivities -》见3.2.6
8.----- com.android.server.wm.Task下的resumeTopActivityInnerLocked-》 见3.2.7
9.----- ActivityTaskSupervisor中的startSpecificActivity -》见3.2.8（1）
10.----- ActivityTaskManagerService中的startProcessAsync -》见3.2.8（2）
3.5.2、创建调用链如下（上述3.2.9~3.2.11流程如下）
1.-----ActivityManagerService的startProcessLocked-》
2.-----ProcessList的startProcessLocked-》
3.-----重载startProcessLocked-》
4.-----ProcessList的startProcess-》
5.-----hostingRecord.usesAppZygote()条件语句中的start方法-》
6.-----AppZygote中的getProcess方法的ChildZygoteProcess类的父类ZygoteProcess中的start()方法中的的 startViaZygote（）方法-》 见下面3.2.10解释1：
7.-----ZygoteProcess中的zygoteSendArgsAndGetResult（）方法-》 见下面3.2.10解释2：------该方法的参数方法openZygoteSocketIfNeeded(abi) -》见下面 3.2.10解释2：
8.-----ZygoteProcess中的attemptZygoteSendArgsAndGetResult-》见下面3.2.11
3.5.3、fork应用进程创建调用链如下（上述3.2.11~3.2.17流程如下）**
1.-----ZygoteInit的main方法-》 见3.2.12
2.-----ZygoteServer的runSelectLoop方法-》 见3.2.13
3.-----ZygoteConnection的processCommand方法--handleChildProc方法-》 见3.2.14-到见3.2.15
4.-----RuntimeInit的applicationInit方法--applicationInit-- findStaticMain方法-》 见3.2.16
5.-----MethodAndArgsCaller的run方法-》见3.2.17，他就是 ActivityThread main()方法
3.5.4、总结Activity onCreate、onResume调用链如下（上述3.4.1~3.4.18流程如下）**
1.-----ActivityThread的main方法--attach()方法中的mgr.attachApplication(mAppThread, startSeq)方法到达ActivityManagerServic-》 见3.4.1
2.-----ActivityManagerServic的attachApplication方法--
attachApplicationLocked方法（该方法做了- 调用IApplicationThread的bindApplication方法，IPC操作，创建绑定Application；
- 通过makeActive方法赋值IApplicationThread，即验证了上面的猜测（创建进程后赋值）；
- 通过ATMS启动 **根activity**）-- mAtmInternal.attachApplication(app.getWindowProcessController())方法-》 见3.4.2（attachApplicationLocked中的三个步骤）
3.-----ActivityTaskManagerService中内部类LocalService类中的attachApplication（）方法-》 见3.4.3
4.-----RootWindowContainer中的attachApplication方法--**RootWindowContainer中的startActivityForAttachedApplicationIfNeeded方法**--RootWindowContainer中的startActivityForAttachedApplicationIfNeeded方法-》 见3.4.4
5.-----ActivityTaskSupervisor中的realStartActivityLocked方法-mService.getLifecycleManager().scheduleTransaction(clientTransaction)-》见3.4.5
6.-----ClientLifecycleManager中scheduleTransaction方法-》见3.4.6
7.-----ActivityThread下的ApplicationThread类中的scheduleTransaction方法-》见3.4.7（1）
8.-----ClientTransactionHandler类中的scheduleTransaction方法（2）-》见3.4.7（2）
9.-----ActivityThread类中的sendMessage方法（3）-》见3.4.7（3）
10.-----ActivityThread类中的sendMessage方法-》见3.4.8
11.-----TransactionExecutor的execute--TransactionExecutor的 executeCallbacks方法-》见3.4.9
12.-----3.4.10、LaunchActivityItem中的execute方法-》见3.4.10
13.-----ActivityThread中的handleLaunchActivity方法-》见3.4.11
14.-----ActivityThread中的performLaunchActivity方法中的 mInstrumentation.callActivityOnCreate方法 到这里onCreate过程结束-》见3.4.12
15.-----onStart、onResume呢？，我们看 ActivityStackSupervisor的realStartActivityLocked方法：-》见3.4.13
16.-----重复上面 3.4.5~3.4.9的流程后走的 TransactionExecutor的execute，前面我们关注 executeCallbacks，onResume流程现在看executeLifecycleState-》见3.4.14
17.-----ActivityLifecycleItem的execute方法，lifecycleItem.execute(mTransactionHandler, token, mPendingActions);-》见3.4.15
18.----ResumeActivityItem中的 execute方法-》见3.4.16
19.----ActivityThread中的handleResumeActivity方法-》见3.4.17
20.----调用了activity.performResume方法：-》见3.4.18
