- ActivityManagerService中的startProcessLocked()方法
创建新进程的消息进入到AMS的startProcessLocked()中，然后直接传入到ProcessList中的startProcessLocked()方法中
- 首先调用ProcessList的startProcessLocked方法来启动进程，需要传入进程名、应用程序信息、是否已知进程已经死亡、意图标志、宿主记录、Zygote策略标志、是否允许在系统启动时启动进程、是否隔离进程、是否保留大进程等参数；
- 然后返回一个ProcessRecord对象，这个对象代表了新启动的进程。
final ProcessRecord startProcessLocked(String processName,
ApplicationInfo info, boolean knownToBeDead, int intentFlags,
HostingRecord hostingRecord, int zygotePolicyFlags, boolean allowWhileBooting,
boolean isolated, boolean keepIfLarge) {
return mProcessList.startProcessLocked(processName, info, knownToBeDead, intentFlags,
hostingRecord, zygotePolicyFlags, allowWhileBooting, isolated, 0 /* isolatedUid */,
keepIfLarge, null /* ABI override */, null /* entryPoint */,
null /* entryPointArgs */, null /* crashHandler */);
}
- ProcessList中的startProcessLocked()方法
ProcessList内部会创建一个AppZygote对象，然后孵化出新的进程；
该方法接收14个创建进程的参数，包括进程名、应用程序信息、是否已知为死亡状态、意图标志、宿主记录、Zygote策略标志、是否允许在系统启动时运行、是否隔离、隔离UID、是否保持大进程、ABI覆盖、入口点、入口点参数和崩溃处理程序。
首先检查是否需要创建新的进程。如果不需要创建新进程，它会检查进程是否已经存在并且处于活动状态。如果进程已经存在并且处于活动状态，它会将应用程序信息添加到进程中并返回该进程。如果进程已经存在但处于非活动状态，它会杀死该进程并创建一个新的进程记录。
如果需要创建新进程，它会创建一个新的进程记录，并将应用程序信息添加到该进程中。然后，它会检查系统是否准备好运行新进程。如果系统尚未准备好运行新进程，它会将进程置于等待状态。最后，它会调用startProcessLocked()方法来启动新进程，并根据启动结果返回相应的进程记录或null。
final ProcessRecord startProcessLocked(String processName, ApplicationInfo info,
boolean knownToBeDead, int intentFlags, HostingRecord hostingRecord,
int zygotePolicyFlags, boolean allowWhileBooting, boolean isolated, int isolatedUid,
boolean keepIfLarge, String abiOverride, String entryPoint, String[] entryPointArgs,
Runnable crashHandler) {
long startTime = SystemClock.uptimeMillis();
ProcessRecord app;
if (!isolated) {
app = getProcessRecordLocked(processName, info.uid, keepIfLarge);
checkSlow(startTime, "startProcess: after getProcessRecord");
if ((intentFlags & Intent.FLAG_FROM_BACKGROUND) != 0) {
if (mService.mAppErrors.isBadProcessLocked(info)) {
if (DEBUG_PROCESSES) Slog.v(TAG, "Bad process: " + info.uid
+ "/" + info.processName);
return null;
}
} else {
if (DEBUG_PROCESSES) Slog.v(TAG, "Clearing bad process: " + info.uid
+ "/" + info.processName);
mService.mAppErrors.resetProcessCrashTimeLocked(info);
if (mService.mAppErrors.isBadProcessLocked(info)) {
EventLog.writeEvent(EventLogTags.AM_PROC_GOOD,
UserHandle.getUserId(info.uid), info.uid,
info.processName);
mService.mAppErrors.clearBadProcessLocked(info);
if (app != null) {
app.bad = false;
}
}
}
} else {
app = null;
}
if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "startProcess: name=" + processName
+ " app=" + app + " knownToBeDead=" + knownToBeDead
+ " thread=" + (app != null ? app.thread : null)
+ " pid=" + (app != null ? app.pid : -1));
ProcessRecord precedence = null;
if (app != null && app.pid > 0) {
if ((!knownToBeDead && !app.killed) || app.thread == null) {
if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "App already running: " + app);
app.addPackage(info.packageName, info.longVersionCode, mService.mProcessStats);
checkSlow(startTime, "startProcess: done, added package to proc");
return app;
}
if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES, "App died: " + app);
checkSlow(startTime, "startProcess: bad proc running, killing");
ProcessList.killProcessGroup(app.uid, app.pid);
checkSlow(startTime, "startProcess: done killing old proc");
Slog.wtf(TAG_PROCESSES, app.toString() + " is attached to a previous process");
precedence = app;
app = null;
}
if (app == null) {
checkSlow(startTime, "startProcess: creating new process record");
app = newProcessRecordLocked(info, processName, isolated, isolatedUid, hostingRecord);
if (app == null) {
Slog.w(TAG, "Failed making new process record for "
+ processName + "/" + info.uid + " isolated=" + isolated);
return null;
}
app.crashHandler = crashHandler;
app.isolatedEntryPoint = entryPoint;
app.isolatedEntryPointArgs = entryPointArgs;
if (precedence != null) {
app.mPrecedence = precedence;
precedence.mSuccessor = app;
}
checkSlow(startTime, "startProcess: done creating new process record");
} else {
app.addPackage(info.packageName, info.longVersionCode, mService.mProcessStats);
checkSlow(startTime, "startProcess: added package to existing proc");
}
if (!mService.mProcessesReady
&& !mService.isAllowedWhileBooting(info)
&& !allowWhileBooting) {
if (!mService.mProcessesOnHold.contains(app)) {
mService.mProcessesOnHold.add(app);
}
if (DEBUG_PROCESSES) Slog.v(TAG_PROCESSES,
"System not ready, putting on hold: " + app);
checkSlow(startTime, "startProcess: returning with proc on hold");
return app;
}
checkSlow(startTime, "startProcess: stepping in to startProcess");
final boolean success =
startProcessLocked(app, hostingRecord, zygotePolicyFlags, abiOverride);
checkSlow(startTime, "startProcess: done starting proc!");
return success ? app : null;
}
- ProcessList中的startProcessLocked()方法
启动新进程的过程：
- 上面一个ProcessList中的startProcessLocked()方法接收了14个参数，进行了一些操作之后调用startProcessLocked()方法传递了4个参数进去来启动新进程；
- 接收4个参数的startProcessLocked()方法直接 return startProcessLocked()方法，增加了一些参数默认值，跳转到了接收7个参数的startProcessLocked()方法；
- 接收7个参数的startProcessLocked()方法又进行了一些处理，最后还是返回一个startProcessLocked()方法，并传入13个参数；
接收13个参数的startProcessLocked()方法：
- 首先设置进程记录的一些属性，如禁用的兼容性更改、启动参数和使用包装器，将进程记录添加到待处理启动列表中；
- 根据系统配置，可以异步启动进程或同步启动进程，如果异步启动进程，它会将进程启动消息发布到处理程序中，并返回true；如果选择同步启动进程，它会尝试startProcess启动进程，并在成功时处理进程启动结果，否则会强制停止应用程序并返回false；
boolean startProcessLocked(HostingRecord hostingRecord, String entryPoint, ProcessRecord app,
int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
app.pendingStart = true;
app.killedByAm = false;
app.removed = false;
app.killed = false;
if (app.startSeq != 0) {
Slog.wtf(TAG, "startProcessLocked processName:" + app.processName
+ " with non-zero startSeq:" + app.startSeq);
}
if (app.pid != 0) {
Slog.wtf(TAG, "startProcessLocked processName:" + app.processName
+ " with non-zero pid:" + app.pid);
}
app.mDisabledCompatChanges = null;
if (mPlatformCompat != null) {
app.mDisabledCompatChanges = mPlatformCompat.getDisabledChanges(app.info);
}
final long startSeq = app.startSeq = ++mProcStartSeqCounter;
app.setStartParams(uid, hostingRecord, seInfo, startTime);
app.setUsingWrapper(invokeWith != null
|| Zygote.getWrapProperty(app.processName) != null);
mPendingStarts.put(startSeq, app);
if (mService.mConstants.FLAG_PROCESS_START_ASYNC) {
if (DEBUG_PROCESSES) Slog.i(TAG_PROCESSES,
"Posting procStart msg for " + app.toShortString());
mService.mProcStartHandler.post(() -> handleProcessStart(
app, entryPoint, gids, runtimeFlags, zygotePolicyFlags, mountExternal,
requiredAbi, instructionSet, invokeWith, startSeq));
return true;
} else {
try {
final Process.ProcessStartResult startResult = startProcess(hostingRecord,
entryPoint, app,
uid, gids, runtimeFlags, zygotePolicyFlags, mountExternal, seInfo,
requiredAbi, instructionSet, invokeWith, startTime);
handleProcessStartedLocked(app, startResult.pid, startResult.usingWrapper,
startSeq, false);
} catch (RuntimeException e) {
Slog.e(ActivityManagerService.TAG, "Failure starting process "
+ app.processName, e);
app.pendingStart = false;
mService.forceStopPackageLocked(app.info.packageName, UserHandle.getAppId(app.uid),
false, false, true, false, false, app.userId, "start failure");
}
return app.pid > 0;
}
}
- ProcessList中的startProcess()方法
ProcessList中的startProcess()方法的作用是启动一个新的进程；
- 检查是否需要使用WebView Zygote或App Zygote来启动新进程。
- 如果需要，为新进程创建一个App Zygote实例。
- 根据不同的条件，调用Process类的start方法来启动新进程。
- 返回一个ProcessStartResult对象，表示新进程的启动结果。
private Process.ProcessStartResult startProcess(HostingRecord hostingRecord, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int zygotePolicyFlags,
int mountExternal, String seInfo, String requiredAbi, String instructionSet,
String invokeWith, long startTime) {
try {
...
final Process.ProcessStartResult startResult;
if (hostingRecord.usesWebviewZygote()) {
startResult = startWebView(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null, app.info.packageName, app.mDisabledCompatChanges,
new String[]{PROC_START_SEQ_IDENT + app.startSeq});
} else if (hostingRecord.usesAppZygote()) {
final AppZygote appZygote = createAppZygoteForProcessIfNeeded(app);
// We can't isolate app data and storage data as parent zygote already did that.
startResult = appZygote.getProcess().start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null, app.info.packageName,
/*zygotePolicyFlags=*/ ZYGOTE_POLICY_FLAG_EMPTY, isTopApp,
app.mDisabledCompatChanges, pkgDataInfoMap, whitelistedAppDataInfoMap,
false, false,
new String[]{PROC_START_SEQ_IDENT + app.startSeq});
} else {
...
}
}
}
从系统服务回到Activity线程中
- ActivityThread中的main()方法
ActivityThread的主函数main()是Android应用程序的入口点，负责初始化和启动应用程序，会处理创建Looper对象以启动消息循环、注册ActivityManager回调等；
- 在应用程序启动时，系统会调用ActivityThread.main()方法创建一个ActivityThread实例，并调用其attach()方法将该实例与当前应用程序关联；
- 调用ActivityManagerService的startActivity()方法来启动应用程序的主Activity，并通过Instrumentation类来调用Application对象的onCreate()方法和主Activity的onCreate()方法完成应用进程的启动；
- 开始跟踪ActivityManager的启动过程。
- 安装选择性系统调用拦截。
- 关闭CloseGuard，因为它可能会产生很多不必要的日志。
- 初始化当前用户的环境。
- 确保TrustedCertificateStore在正确的位置查找CA证书。
- 调用每个进程的主要模块初始化。
- 设置进程参数。
- 准备主线程的Looper。
- 从命令行中查找PROC_START_SEQ_IDENT的值，如果提供了该值，它将以"seq=114"的格式出现。
- 创建一个新的ActivityThread实例，并将其附加到主线程。
- 如果sMainThreadHandler为null，则将其设置为新创建的ActivityThread的Handler。
- 如果需要，启用消息日志记录。
- 结束跟踪ActivityManager的启动过程。
- 进入主线程的Looper循环。
- 如果主线程循环意外退出，则抛出一个运行时异常。
其中主要步骤是：
- Looper.prepareMainLooper()初始化looper；
- new ActivityThread()创建一个新的ActivityThread实例，thread.attach将其附加到主线程上。
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
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
// Call per-process mainline module initialization.
initializeMainlineModules();
Process.setArgV0("<pre-initialized>");
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()));
}
}
}
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
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.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
- ActivityThread中的attach()方法
ActivityThread的attach()方法主要负责向系统服务AMS注册目标Activity对应的进程，并传递IApplicationThreadBinder对象以便于系统能够对本进程进行调度和管理；
- 设置当前ActivityThread为系统线程或者应用程序线程(ActivityThread.main()方法传参设置当前ActivityThread非系统线程)；
- 如果当前线程不是系统线程，那么会调用ActivityManager的attachApplication()方法将应用程序绑定到AMS；
- 如果当前线程是系统线程，那么会创建一个Instrumentation对象，并初始化它，然后创建一个应用程序上下文，并实例化一个应用程序对象，最后调用应用程序对象的onCreate方法；
- 注册一个配置改变的回调函数，当配置发生改变时，会通知所有的视图层次结构；
- 添加一个垃圾回收监视器，当Dalvik虚拟机使用的内存超过其最大内存的75%时，会尝试释放一些活动来节省内存；
- attachApplication()传入的mAppThread类型是ApplicationThread，是IApplicationThread的Binder接口本地实现类，用来接收AMS等其他进程的信息；
- mgr.attachApplication(mAppThread, startSeq)是一次IPC过程，会调用AMS服务中对应的方法；
private void attach(boolean system, long startSeq) {
...
if (!system) {
...
final IActivityManager mgr = ActivityManager.getService();
try {
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
...
}else{
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);
}
}
...
- ActivityManagerService中的attachApplication()方法
attachApplication()方法作用是为应用创建必要的环境，如创建进程状态记录、分配进程ID等，并将应用程序绑定到AMS；
- 检查传入的IApplicationThread对象是否为null，如果为null则抛出SecurityException异常；
- 获取调用进程的PID和UID；
- 清除调用进程的身份标识，以便在后续操作中不受调用进程的影响；
- 调用attachApplicationLocked方法，将应用程序绑定到AMS；
- 恢复调用进程的身份标识；
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()方法
通过attachApplicationLocked()方法负责创建和管理应用的全局状态，还确保了应用进程与系统服务之间的正确通信，AMS能够为新启动的应用进程创建必要的记录和环境，从而能够对应用进行有效的管理和调度。
- 注册进程死亡回调：attachApplicationLocked()方法内部注册新创建的进程的死亡回调，创建一个AppDeathRecipient对象并将其与ActivityThread的Binder对象关联，这样做可以确保当应用程序的进程意外终止时，AMS能够及时得知并做出相应处理；
- 启动Application：调用ActivityThread的bindApplication()方法来启动应用程序的Application对象，Application对象代表了应用程序的全局状态，并且是很多应用级操作的起点；
private boolean attachApplicationLocked(@NonNull IApplicationThread thread,
int pid, int callingUid, long startSeq) {
ProcessRecord app;
...
if (app.isolatedEntryPoint != null) {
// This is an isolated process which should just call an entry point instead of
// being bound to an application.
thread.runIsolatedEntryPoint(app.isolatedEntryPoint, app.isolatedEntryPointArgs);
} else if (instr2 != null) {
thread.bindApplication(processName, appInfo, providerList,
instr2.mClass,
profilerInfo, instr2.mArguments,
instr2.mWatcher,
instr2.mUiAutomationConnection, testMode,
mBinderTransactionTrackingEnabled, enableTrackAllocation,
isRestrictedBackupMode || !normalMode, app.isPersistent(),
new Configuration(app.getWindowProcessController().getConfiguration()),
app.compat, getCommonServicesLocked(app.isolated),
mCoreSettingsObserver.getCoreSettingsLocked(),
buildSerial, autofillOptions, contentCaptureOptions,
app.mDisabledCompatChanges);
} else {
thread.bindApplication(processName, appInfo, providerList, 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,
app.mDisabledCompatChanges);
}
...
- ActivityThread的bindApplication()方法
ActivityThread的bindApplication()方法负责将应用程序的 Application 对象与操作系统进行绑定，并完成一系列的初始化工作；
- bindApplication接收到来自AMS的绑定信息，主要是processName和ApplicationInfo；
- 最后给主线程Handler H 发送送一条信息，进程接收到的信息交由H处理；
public final void bindApplication(String processName, ApplicationInfo appInfo,
ProviderInfoList providerList, ComponentName instrumentationName,
ProfilerInfo profilerInfo, Bundle instrumentationArgs,
IInstrumentationWatcher instrumentationWatcher,
IUiAutomationConnection instrumentationUiConnection, int debugMode,
boolean enableBinderTracking, boolean trackAllocation,
boolean isRestrictedBackupMode, boolean persistent, Configuration config,
CompatibilityInfo compatInfo, Map services, Bundle coreSettings,
String buildSerial, AutofillOptions autofillOptions,
ContentCaptureOptions contentCaptureOptions, long[] disabledCompatChanges) {
...
setCoreSettings(coreSettings);\
AppBindData data = new AppBindData();
data.processName = processName;
data.appInfo = appInfo;
data.providers = providerList.getList();
...
sendMessage(H.BIND_APPLICATION, data);
- ActivityThread中的handleMessage()方法
主线程H接收bindApplication发送的BIND_APPLICATION消息，在handleMessage()方法中处理应用程序绑定；
- 调用Trace.traceBegin()方法开始跟踪，传入的参数为Trace.TRACE_TAG_ACTIVITY_MANAGER和"bindApplication"，用于标识跟踪的标签和操作；
- 从msg对象中获取AppBindData类型的数据，并将其赋值给data变量；
- 调用handleBindApplication(data)方法处理应用程序绑定；
- 调用Trace.traceEnd()方法结束跟踪；
class H extends Handler {
...
public void handleMessage(Message msg) {
if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));
switch (msg.what) {
case BIND_APPLICATION:
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");
AppBindData data = (AppBindData)msg.obj;
handleBindApplication(data);
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
break;
...
- ActivityThread中的handleBindApplication()方法
handleBindApplication()方法用来处理应用程序绑定，该方法初始化了Android的上下文环境，同时还初始化了Application，并且回调了Application的onCreat()方法。其中关键代码行：
- 从AppBindData对象中获取应用程序的包名和类名；
- 根据包名和类名创建一个新的应用程序实例，并将其赋值给mInitialApplication变量；
- 调用installContentProviders()方法安装应用程序的内容提供者。
- 调用mInstrumentation.callApplicationOnCreate()方法调用应用程序的onCreate()方法；
- 调用scheduleGcIdler()方法安排垃圾回收器运行；
private void handleBindApplication(AppBindData data) {
...
Process.setArgV0(data.processName);
...
VMRuntime.setProcessPackageName(data.appInfo.packageName);
...
final ContextImpl instrContext = ContextImpl.createAppContext(this, pi,
appContext.getOpPackageName());
try {
final ClassLoader cl = instrContext.getClassLoader();
mInstrumentation = (Instrumentation)
cl.loadClass(data.instrumentationName.getClassName()).newInstance();
} catch (Exception e) {
...
}
final ComponentName component = new ComponentName(ii.packageName, ii.name);
mInstrumentation.init(this, instrContext, appContext, component,
data.instrumentationWatcher, data.instrumentationUiAutomationConnection);
...
Application app;
...
try {
app = data.info.makeApplication(data.restrictedBackupMode, null);
app.setAutofillOptions(data.autofillOptions);
app.setContentCaptureOptions(data.contentCaptureOptions);
mInitialApplication = app;
if (!data.restrictedBackupMode) {
if (!ArrayUtils.isEmpty(data.providers)) {
installContentProviders(app, data.providers);
}
}
try {
mInstrumentation.onCreate(data.instrumentationArgs);
}
catch (Exception e) {
...
}
try {
mInstrumentation.callApplicationOnCreate(app);
} catch (Exception e) {
...
}
- RootWindowContainer中的startActivityForAttachedApplicationIfNeeded()方法
在执行完bindApplication之后，流程会继续在主线程中运行，回到AMS的attachApplicationLocked()方法中继续往下执行，调用ATMS中的attachApplication()方法，然后调用到RootWindowContainer中的attachApplication()方法，再走到RootWindowContainer的startActivityForAttachedApplicationIfNeeded()方法中找到与此进程相关联的Activity，并打开此Activity；
- 首先检查ActivityRecord (目标Activity在AMS中的数据结构)；
- 调用mStackSupervisor.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 (mStackSupervisor.realStartActivityLocked(r, app, top == r /*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;
}
- ActivityStackSupervisor中的realStartActivityLocked()方法
ActivityStackSupervisor中的realStartActivityLocked()方法在ActivityStackSupervisor中的startSpecificActivity()中也有调用，① startSpecificActivity()方法中如果目标Activity的进程已经启动就会走到realStartActivityLocked()中启动目标Activity，② 而目标Activity的进程没有启动的情况，通过AMS创建了新的进程启动，同样走到realStartActivityLocked()中启动目标Activity；
realStartActivityLocked() 方法在 Activity 的启动过程中处理 Activity 的创建、生命周期的管理，处理与任务和堆栈相关的逻辑，进行必要的配置检查，确保 Activity 能够正确无误地启动；
- 调用r.startFreezingScreenLocked(proc, 0)暂停屏幕冻结。
- 调用r.startLaunchTickingLocked()启动计时器以收集关于慢应用程序的信息。
- 设置进程r.setProcess(proc)。
- 如果需要恢复Activity，确保Activity允许恢复r.canResumeByCompat()。
- 通知未知的可见性启动关键锁过渡r.notifyUnknownVisibilityLaunchedForKeyguardTransition()。
- 检查配置，如果需要，确保Activity的可见性和配置r.ensureVisibilityAndConfig()。
- 根据新的Activity顺序重新评估屏幕方向。
- 更新Home进程。
- 通知包使用情况mService.getPackageManagerInternalLocked().notifyPackageUse()。
- 设置Activity为非休眠状态r.setSleeping(false)。
- 获取Activity的兼容性信息r.compat = mService.compatibilityInfoForPackageLocked(r.info.applicationInfo)。
- 创建一个新的合并配置MergedConfiguration。
- 记录过大的交易日志logIfTransactionTooLarge(r.intent, r.getSavedState())。
- 创建Activity启动事务ClientTransaction。
- 设置期望的最终状态，根据andResume的值选择ResumeActivityItem或PauseActivityItem。
- 调度事务mService.getLifecycleManager()。
- 检查标志和mService.mHasHeavyWeightFeature是否为真，如果满足，说明这个进程可能是一个"heavy-weight process"。
- 检查了proc.mName是否等于proc.mInfo.packageName，确保只有主进程可以运行在.apk文件中的Activity，因为只有Activity才会被认为是"heavy-weight"。
- 检查mService.mHeavyWeightProcess是否已经存在且不等于当前进程proc，如果是表示在启动一个新的"heavy-weight process"的时候已经有一个正在运行的"heavy-weight process"，打印警告日志。
- 调用setHeavyWeightProcess()设置当前的Activity记录r作为"heavy-weight process"。
- 将r.launchFailed设置为false，表示启动失败的状态已经被清除，如果需要恢复且系统已经准备好恢复，调用minimalResumeActivityLocked来恢复这个Activity，否则将这个Activity的状态设置为PAUSED，并执行一个应用程序过渡。
- 调用onStartActivity更新进程的状态。
- 如果当前的栈是顶部显示的焦点栈，它将启动一个新的版本设置屏幕，因为在启动初始Activity之后启动这个设置屏幕，可以让它在后台初始化自己，这样当切换回它时速度更快。
- 如果这个Activity属于一个应用，将更新与这个应用绑定的任何可能关心其客户端是否有活动的服务。
- 返回true表示Activity已经成功启动。
realStartActivityLocked()方法找到与进程相关联的Activity，这里的ClientTransaction具备IPC的能力，通过内部的IApplicationThread Binder接口，会把自己作为参数传递给对应要操作的进程。本次的事务处理，ClientTransaction添加了一个LaunchActivityItem，说明要显示Activity的意图，打开目标Activity。
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
boolean andResume, boolean checkConfig) throws RemoteException {
...
final DisplayContent dc = r.getDisplay().mDisplayContent;
clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
System.identityHashCode(r), r.info,
// TODO: Have this take the merged configuration instead of separate global
// and override configs.
mergedConfiguration.getGlobalConfiguration(),
mergedConfiguration.getOverrideConfiguration(), r.compat,
r.launchedFromPackage, task.voiceInteractor, proc.getReportedProcState(),
r.getSavedState(), r.getPersistentSavedState(), results, newIntents,
dc.isNextTransitionForward(), proc.createProfilerInfoIfNeeded(),
r.assistToken, r.createFixedRotationAdjustmentsIfNeeded()));
...
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
- ActivityThread中的ApplicationThread 类
应用进程会收到ClientTransaction的方法回调；
ApplicationThread 类在 ActivityThread 中的作用是作为与系统其他部分通信的桥梁，处理应用的生命周期事件，并在UI线程上协调操作，以及参与应用的启动过程；
- 作为Binder通信的端点：ApplicationThread 是一个 Binder 服务端点，用于与系统的其他部分进行通信，这种通信机制允许跨进程调用，从而使得系统能够对应用的生命周期事件进行调度和管理。
- 处理应用程序的生命周期事件：ApplicationThread 通过 scheduleTransaction 方法接收来自AMS的指令，包括启动、暂停或销毁 Activity 等生命周期事件，ActivityThread 就能够响应这些事件并做出相应的处理。
- 协调UI线程的操作： ActivityThread 是运行在主线程上的，ApplicationThread 类负责确保所有与UI相关的操作都在正确的线程上执行。
- 参与应用的启动过程：在应用启动时，ActivityThread 的 main 方法会被调用，而 ApplicationThread 则参与到这一过程中，例如在 startActivityForResult 方法中调用 Instrumentation 的 execStartActivity 方法时，会涉及到 mMainThread，即 ActivityThread 的一个实例。
private class ApplicationThread extends IApplicationThread.Stub {
...
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
ActivityThread.this.scheduleTransaction(transaction);
}
...
}
...
private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
Message msg = Message.obtain();
msg.what = what;
msg.obj = obj;
msg.arg1 = arg1;
msg.arg2 = arg2;
if (async) {
msg.setAsynchronous(true);
}
mH.sendMessage(msg);
}
- TransactionExecutor的executeCallbacks类
在接收到scheduleTransaction的回调之后，还是会把消息给到ActivityThread的H处理，H会把ClientTransaction这个消息给到TransactionExecutor处理；
TransactionExecutor的作用是确保客户端事务（如启动、暂停或销毁 Activity）能够按照正确的顺序和时机被执行；
- 执行回调：TransactionExecutor 通过其 execute 方法来执行事务，首先会执行所有的回调（callbacks），这些回调通常是与生命周期事件相关的操作，比如 onCreate、onPause 等。
- 管理生命周期：在执行完回调之后，TransactionExecutor 会管理 Activity 的生命周期，确保 Activity 在不同的生命周期阶段执行相应的逻辑。
- 清理操作：最后，TransactionExecutor 会清理 mPendingActions，可能涉及到移除已经处理过或者不再需要的操作项。
executeCallbacks 方法在 TransactionExecutor 类中的作用是执行所有挂起的回调（Callbacks），会遍历 mPendingActions 列表，包含了所有待执行的操作（通常是与 Activity 生命周期相关的操作，如 onPause()、onResume() 等），executeCallbacks 方法会依次执行这些操作，并从列表中移除已执行的操作。
- 启动 Activity：当一个新 Activity 被启动时，与之相关的回调会被添加到 mPendingActions 中，并在适当的时候由 executeCallbacks 方法执行。
- 恢复 Activity：当一个暂停的 Activity 被恢复时，与之相关的回调也会通过 executeCallbacks 方法执行。
- 销毁 Activity：当一个 Activity 被销毁时，清理操作也会通过 executeCallbacks 方法来执行。
TransactionExecutor会去执行ClientTransactionItem 内部的逻辑；
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
...
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);
}
item.execute(mTransactionHandler, token, mPendingActions);
item.postExecute(mTransactionHandler, token, mPendingActions);
...
- LaunchActivityItem类
LaunchActivityItem类的是用于启动 Activity 的一个内部类，作用是作为消息对象来启动 Activity。 在 Android 的应用程序框架中，ActivityThread 负责管理应用程序进程中主线程的执行，而 LaunchActivityItem 则是它处理的消息之一。当系统需要启动一个新的 Activity 时，AMS会创建 LaunchActivityItem 并将其发送给目标应用的 ActivityThread，ActivityThread会调用 LaunchActivityItem 的 execute() 方法来实际启动 Activity。
LaunchActivityItem中的execute方法的作用是执行一个Activity的启动操作；
- 通过调用Trace.traceBegin方法开始跟踪Activity的启动过程；
- 创建一个ActivityClientRecord对象r，该对象包含了启动Activity所需的各种信息，如Intent、标识符、配置等；
- 调用client.handleLaunchActivity方法来处理Activity的启动，传入r、pendingActions和null作为参数；
- 通过调用Trace.traceEnd方法结束跟踪。
execute中的client参数就是ActivityThread，ActivityThread实现了ClientTransactionHandler，这里就调用到了ActivityThread的handleLaunchActivity方法，同时把Activity的相关信息封装成了ActivityClientRecord 数据结构作为参数传递；
public class LaunchActivityItem extends ClientTransactionItem {
...
@Override
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");
ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,
mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,
mPendingResults, mPendingNewIntents, mIsForward,
mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);
}
...
- ActivityThread中的handleLaunchActivity()方法
该方法主要功能是处理启动Activity的操作：
- 首先，调用unscheduleGcIdler()方法取消垃圾回收的调度。
- 设置mSomeActivitiesChanged为true，表示有活动发生了变化。
- 如果r.profilerInfo不为空，则设置Profiler并开始分析。
- 确保运行的是最新的配置，如果需要的话预加载硬件渲染器。
- 初始化WindowManagerGlobal。
- 提示GraphicsEnvironment一个进程上的活动正在启动。
- 调用performLaunchActivity方法执行实际的启动操作，并将返回的Activity对象赋值给变量a。
- 如果a不为空，则进行以下操作：
创建一个新的Configuration对象，并将其赋值给r.createdConfig。
报告尺寸配置信息。
如果r.activity未完成且pendingActions不为空，则设置pendingActions的旧状态、恢复实例状态和调用onPostCreate标志。 - 如果a为空，则表示有错误发生，通知ActivityManager停止当前进程。
- 最后，返回Activity对象a。
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();
}
// Make sure we are running with the most recent config.
handleConfigurationChanged(null, null);
if (localLOGV) Slog.v(
TAG, "Handling launch of " + r);
// Initialize before creating the activity
if (!ThreadedRenderer.sRendererDisabled
&& (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(mConfiguration);
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.
try {
ActivityTaskManager.getService()
.finishActivity(r.token, Activity.RESULT_CANCELED, null,
Activity.DONT_FINISH_TASK_WITH_ACTIVITY);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
return a;
}
- ActivityThread的performLaunchActivity()方法
performLaunchActivity方法执行实际的启动Activity操作，负责启动一个 Activity，并返回该 Activity 的实例；
- 首先会调用Activity的onCreate方法来创建Activity实例；
- 根据传入的Intent对象，可能会进行一些额外的处理，例如启动其他Activity、发送广播等；
- 将创建的Activity实例返回给调用者。
- 获取 Activity 信息：从传入的 ActivityClientRecord 对象中获取 Activity 的信息，包括包名、组件名等。
- 创建 Activity 实例：通过反射机制，使用 Instrumentation的newActivity方法创建 Activity 的实例。
- 准备 Activity 上下文：创建一个应用程序上下文（ContextImpl）用于 Activity 的运行环境。
- 初始化 Activity：调用 makeApplication() 方法创建一个应用程序实例，并将 Activity 与应用程序关联起来。
- 设置 Activity 属性：根据 Activity 的属性和配置，设置 Activity 的主题、窗口模式等。
- 调用 Activity 生命周期方法：调用 callActivityOnCreate() 方法，执行 Activity 的 onCreate() 方法。
- 处理异常：如果在启动过程中发生异常，会通过 Instrumentation 的 onException() 方法进行处理。
- 返回 Activity 实例：最后，返回创建好的 Activity 实例。
performLaunchActivity方法只是执行启动Activity的操作，具体的生命周期管理、消息传递等功能是由ActivityThread类的其他方法来完成的。
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
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 appContext = createBaseContextForActivity(r);
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
// AppComponentFactory利用反射生成Activity
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) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
try {
Application app = r.packageInfo.makeApplication(false, mInstrumentation);
if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
if (localLOGV) Slog.v(
TAG, r + ": app=" + app
+ ", appName=" + app.getPackageName()
+ ", pkg=" + r.packageInfo.getPackageName()
+ ", comp=" + r.intent.getComponent().toShortString()
+ ", dir=" + r.packageInfo.getAppDir());
if (activity != null) {
CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
Configuration config = new Configuration(mCompatConfiguration);
if (r.overrideConfig != null) {
config.updateFrom(r.overrideConfig);
}
if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
+ r.activityInfo.name + " with config " + config);
Window window = null;
if (r.mPendingRemoveWindow != null && r.mPreserveWindow) {
window = r.mPendingRemoveWindow;
r.mPendingRemoveWindow = null;
r.mPendingRemoveWindowManager = null;
}
// Activity resources must be initialized with the same loaders as the
// application context.
appContext.getResources().addLoaders(
app.getResources().getLoaders().toArray(new ResourcesLoader[0]));
appContext.setOuterContext(activity);
// activity关联相关的信息，包括创建PhoneWindow
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;
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
// 回调Activity的OnCreate回调方法
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;
mLastReportedWindowingMode.put(activity.getActivityToken(),
config.windowConfiguration.getWindowingMode());
}
r.setState(ON_CREATE);
// updatePendingActivityConfiguration() reads from mActivities to update
// ActivityClientRecord which runs in a different thread. Protect modifications to
// mActivities to avoid race.
synchronized (mResourcesManager) {
mActivities.put(r.token, r);
}
} catch (SuperNotCalledException e) {
throw e;
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to start activity " + component
+ ": " + e.toString(), e);
}
}
return activity;
}
在回调了Activity的OnCreate方法之后，目标Activity就创建完成了。
Activity创建过程总结
- 当某个Activity要跳转到另一个Activity时，会发起startActivity，走到Activity中的startActivity()方法中，startActivity()方法主要作用是移除当前活动的恢复能力，暂停当前活动，并将恢复能力添加到目标Activity的Intent意图中，然后走到Activity的startActivityForResult()方法中；
- Activity中的startActivityForResult()方法的作用是在当前Activity中启动一个新的Activity，当新的Activity结束后会通过ActivityThread.sendActivityResult()方法将活动启动结果发送给启动新活动的父活动，startActivityForResult()方法中启动新Activity的操作会走到Instrumentation中的execStartActivity()方法；
- Instrumentation中的execStartActivity()启动新的Activity有两种情况，① 当系统存在活动监视器，且忽略匹配特殊意图时，新的Activity会通过ActivityMonitor的onStartActivity()方法启动；② 其他情况都是通过调用ActivityTaskManagerService中的startActivityAsUser()方法来启动新的Activity的；
- 到这里，启动新Activity的流程就从Activity中走到了系统服务器中。ActivityTaskManagerService中的startActivityAsUser()方法主要作用是以特定用户身份启动一个新的Activity，startActivityAsUser()方法会接收13个参数，中间进行一些处理，方法最后会通过ActivityStartController的obtainStarter()方法创建一个活动启动器Starter对象，通过链式调用来设置Intent意图等参数，最后调用ActivityStarter的execute()方法执行Activity的启动操作；
- ActivityStarter是一个控制器，负责解释解释如何在特定的时间和方式下启动一个Activity，ActivityStarter中的execute()作为外部接口，触发整个启动过程，而新Activity的具体的启动逻辑和记录创建会走到ActivityStarter中的executeRequest()方法中执行；
- ActivityStarter中的executeRequest()方法主要作用是处理启动Activity请求，创建Activity对应的ActivityRecord（目标Activity在AMS中的数据结构），将记录存储在任务Task中，然后调用ActivityStarter中的startActivityUnchecked()方法来启动新的Activity；
- ActivityStarter中的startActivityUnchecked()方法主要处理与客户端相关的逻辑，处理启动Activity的前期准备工作(传递参数、处理生命周期)，新的Activity启动与系统服务进程的交互会走到ActivityStarter中的startActivityInner()方法中进行；
- ActivityStarter中的startActivityInner()方法处理了启动Activity所需的各种参数和逻辑，包括任务栈管理、权限检查、URI权限授予、任务记录等，新启动的Activity的Task和Activity进栈处理会走到ActivityStack中的startActivityLocked()方法中，新的Activity的启动则会调用RootWindowContainer中的resumeFocusedStacksTopActivities()方法；
- ActivityStack中的startActivityLocked()方法的作用主要是负责将待启动的Activity对应的ActivityRecord对象入栈，，确保新Activity按照正确的顺序被添加到任务栈中，以便用户可以通过按返回键来导航Activity历史记录；
- RootWindowContainer中的resumeFocusedStacksTopActivities()方法的作用是恢复焦点栈顶部的Activity，会调用ActivityStack中的resumeTopActivityUncheckedLocked()方法将当前处于焦点状态的Activity恢复到栈顶，成为用户界面可见和可交互的状态；
- ActivityStack中的resumeTopActivityUncheckedLocked()方法会恢复栈顶的Activity实例，使其进入活动状态，会调用resumeTopActivityInnerLocked()方法来恢复栈顶的Activity，并做一些恢复后的处理操作；
- ActivityStack中的resumeTopActivityInnerLocked()方法的作用是恢复栈顶的Activity实例，使目标Activity进入活动状态，并确保其可见性，其中调用startPausingLocked() 方法对当前运行的 Activity（发起者 Activity）触发 Pause 动作，并执行 startSpecificActivity()进一步处理目标 Activity 的启动和恢复过程；
- ActivityStackSupervisor中的startSpecificActivity()方法主要用来启动或恢复目标Activity实例，如果目标Activity的进程已经启动，调用realStartActivityLocked() 方法来恢复该 Activity，否则调用ATMS的startProcessAsync异步地启动目标Activity；
- ActivityTaskManagerService中的startProcessAsync()方法的作用是给AMS发送一条创建新进程的消息，创建目标Activity对应的进程，发送的消息包含启动进程所需要的所有信息；
- 创建新进程的消息从ATMS发送到AMS中，被ActivityManagerService中的startProcessLocked()方法接收，直接传入ProcessList中的startProcessLocked()方法中；
- ProcessList中的startProcessLocked()方法对传入的14个参数进行一系列处理，最后根据系统配置，可以同步或异步启动线程，同步启动线程会调用ProcessList中的startProcess()方法来启动一个新进程；
- ProcessList中的startProcess()方法会创建一个AppZygote对象，孵化出新的进程，然后调用AppZygote.Process的start方法来启动新进程，新Activity对应的进程的创建和启动完成，接下来就是应用进程启动之后的操作，流程走到了ActivityThread中；
- 应用程序启动时，系统会调用ActivityThread中的主函数main()来创建ActivityThread实例，并调用attach()方法将该实例与当前应用程序关联，然后调用AMS中的startActivity()方法启动应用程序的主Activity，这个流程又会走到ATMS的startActvityAsUser()方法中，与前面的流程一样，不过会走目标Activity对应的进程已存在的情况了；
- ActivityThread中的attach()方法的作用是想AMS注册目标Activity对应的进程，会调用ActivityManager的attachApplication方法将应用程序绑定到AMS，并传递IApplicationThreadBinder对象以便于系统能够对本进程进行调度和管理；
- ActivityManagerService中的attachApplication()方法的作用是为应用创建必要的环境，如创建进程状态记录、分配进程ID等，并调用AMS的attachApplicationLocked()方法将应用程序绑定到AMS中；
- ActivityManagerService中的attachApplicationLocked()方法负责创建和管理应用的全局状态，确保应用进程与系统服务之间的正确通信，该方法会创建一个AppDeathRecipient对象并将其与ActivityThread的Binder对象关联来注册进程死亡回调，确保当应用程序的进程意外终止时，AMS能够及时得知并做出相应处理，除此之外还调用了ActivityThread的bindApplication()方法来启动应用程序的Application对象，以此开启应用级操作；
- ActivityThread中的bindApplication()方法负责将应用程序的 Application 对象与操作系统进行绑定，并完成一系列的初始化工作，接收来在AMS的绑定信息，经过一些处理后给主线程Handler H 发送送一条信息，进程接收到的信息交由H处理，在ActivityThread中的handleMessage()方法中进行消息处理；
- ActivityThread中的handleMessage()方法主要用于处理应用程序绑定和方法跟踪处理，处理应用程序绑定会调用ActivityThread中的handleBindApplication()方法进行对应操作；
- ActivityThread中的handleBindApplication()方法处理应用程序绑定，初始化Android的上下文环境和Application，并回调了Application的onCreate()方法；handleBindApplication()方法之后，流程会继续在主线程中运行，回到ActivityManagerService中的attachApplicationLocked()方法中，往下调用ATMS中的attachApplication()方法，之后会继续调用到ActivityStackSupervisor中的realStartActivityLocked()方法来启动Activity；
- ActivityStackSupervisor中的realStartActivityLocked()方法在 Activity 的启动过程中处理 Activity 的创建、生命周期的管理，处理与任务和堆栈相关的逻辑，进行必要的配置检查，确保 Activity 能够正确无误地启动，其中创建了Activity启动事务ClientTransaction，用来处理Activity启动、停止和销毁等事务的类，ClientTransaction的CallBack中传入了LaunchActivityItem；
- 应用程序收到Activity启动事务ClientTransaction的方法回调后会走到ActivityThread中的ApplicationThread 类处理应用的生命周期事件，在UI线程上协调操作，以及参与应用的启动过程， scheduleTransaction接收到回调之后，会把消息给到ActivityThread的H处理，而H会把ClientTransaction这个消息给到TransactionExecutor中的executeCallbacks ()方法处理；
- TransactionExecutor中的executeCallbacks()方法的作用是执行所有挂起的回调（Callbacks），遍历 mPendingActions包含所有待执行的操作（如 onPause()、onResume() 等）的列表，executeCallbacks 方法会依次执行这些操作，并从列表中移除已执行的操作。
- ActivityStackSupervisor中的realStartActivityLocked()方法中创建的Activity启动事务ClientTransaction的CallBack参数中传入了LaunchActivityItem，LaunchActivityItem作为启动Activity的消息对象发送到目标对应的ActivityThread中，通过调用 LaunchActivityItem 中的 execute() 方法来实际启动 Activity，而execute()主要是通过调用ActivityThread中的handleLaunchActivity()方法来处理Activity的启动；
- ActivityThread中的handleLaunchActivity()方法的作用是处理启动Activity的操作，做一些调用其生命周期方法以及处理布局和显示的操作，Activity实际的启动操作会调用ActivityThread中的performLaunchActivity方法执行；
- ActivityThread中的performLaunchActivity方法通过ActivityClientRecord 对象获取目标Activity的信息，通过反射机制创建Activity实例，然后做一些准备Activity的上下文、初始化Activty、调用Activity生命周期等操作，最后将创建好的Activity实例返回显示。
