Android从开机到APP启动流程——基于Android9.0
一、 Zygote进程启动流程
二、 System Server启动流程
三、 ActivityManagerService启动流程
四、 Launcher App (Home Activity)启动流程
五、 Zygote fork()子进程，子进程入口为ActivityThread.main()
六、 Activity的启动流程（从ActivityThread到Activity）
从开机到APP启动流程宏观流程
一、 Zygote进程启动流程
Zygote进程是所有应用程序的鼻祖。 SystemServer以及其他所有 Dalivik虚拟机进程都是由 Zygote进程通过调用系统函数fork()而来。
Zygote 由 app_process 启动，app_process 映射为 app_main.cpp。
Zygote进程在 Android中属于C/S模型，Zygote进程作为 Server服务端，接收其它进程作为客户端向它发出的 “fork” 请求。Zygote进程接收到这个请求后，就调用系统函数fork()孵化出一个新的进程。所有由 fork创建的应用程序进程和 SystemServer进程都将获得一个 JVM实例拷贝。
fork()函数调用一次，将会返回两次。
两次返回分别属于原进程和新进程。
fork()采用copy-on-write机制，有些累如果不做改变，甚至都不用复制，子进程和父进程可以共享这部分数据，从而省去不少内存的占用（图片来自gityuan）
0. Zygote启动流程图
从开机到 Zygote进程启动，途径了内核态与用户态，在用户态中，从 native层调用到了 Java层。最后在AndroidRuntime.cpp # strat()注册 JNI方法完成后，通过反射调用ZygoteInit.java # main() 正式地进入到 Zygote进程。
1. 执行init.rc文件
Linux内核启动后，通过解析 init.rc文件，会启动 Zygote相关的服务，从而启动 Zygote进程。
在/system/core/rootdir目录中有四个 zygote相关的服务脚本。
其中 init.zygote64.rc 支持64位的zygote，其 Android初始化语言为：
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
class main
socket zygote stream 660 root system
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
writepid /dev/cpuset/foreground/tasks
其中 /system/bin/app_process64 映射的执行文件为 /frameworks/base/cmds/app_process/app_main.cpp
2. app_main.cpp # main()
说明
app_main.cpp 的任务是根据 zygote的脚本的参数进行解析，在解析到有 --zygote 字符后，决定执行 AndroidRuntime.cpp#start()方法。
源码
public static void main(String argv[]) {
//创建ZygoteServer
ZygoteServer zygoteServer = new ZygoteServer();
//...
//用于fork()后的进程执行最后的通过反射执行的main()方法
final Runnable caller;
//register handlers for DDM(Dalvik Debug Monitor) messages
//用于debug的handler
RuntimeInit.enableDdms();
//配置，如是否打开SystemServer，socketName是什么，是否开启LazyPreload等
// 注册Server端的Socket，用于接收消息
zygoteServer.registerServerSocketFromEnv(socketName);
if (!enableLazyPreload) {
// 预加载类和资源
preload(bootTimingsTraceLog);
}
//开启gc
gcAndFinalize();
if (startSystemServer) {
// fork一个SystemServer进程
Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
if (r != null) {
//fork出来的System Server的r不为空，会进入该方法
//通过执行run()进入System Server的main()方法
r.run();
return;
}
}
// 等待AMS请求
caller = zygoteServer.runSelectLoop(abiList);
//最后关闭socket
zygoteServer.closeServerSocket();
}
if (caller != null) {
//fork出来的App进程将会进入该方法
//通过执行run()进入ActivityThread的main()方法
caller.run();
}
}
二、 System Server启动流程
Zygote是所有应用的鼻祖。SystemServer和其他应用进程都是由 Zygote通过“孵化 fork”而来。``ZygoteInit.java#main()`` 中第一个 fork的进程就是 SystemServer，在手机中其进程名为 system_server。
system_server 进程承载着整个 framework层的核心服务，例如创建 AMS（ActivityManagerService）。PKMS（PackageManagerService）等。这些服务以不同的线程方式存在于 system_server这个进程中。
0. SystemServer 启动流程图
SystemServer进程由 Zygote进程通过系统函数fork()而来，它管理着整个 framework层，在打开Looper循环接收消息前，做好一切准备工作，并且启动引导服务、核心服务、其他各种服务。 SystemService是一个进程，所有的 Service服务都以线程的方式运行在其中。
1. ZygoteInit.java # main()
说明
ZygoteInit.java # main()是 Zygote进程的入口，它的主要任务是启动 SystemServer以及开启循环接受 socket传来的创建子进程的消息。
SystemServer进程的创建，需要在 Zygote进程中，通过ZygoteInit.java # forkSystemServer()来孵化一个 SystemServer进程。孵化出来的 SystemServer进程与 Zygote进程运行到if(r!=null)的执行过程是不同的。SystemServer将会进入判断体，通过r.run()来执行SystemServer.java # main(),而 Zygote进程将会跳出判断体，继续执行后续代码。
源码
public static void main(String argv[]){
//...
if (startSystemServer) {
// fork一个SystemServer进程出来
Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
if (r != null) {
//fork出来的System Server进行到这里，r不为null
//r.run将会执行SystemServer.java#main()
r.run();
return;
}
}
//Zygote进程将会跳出if，继续运行后续代码
//...
}
2. ZygoteInit.java # forkSystemServer()
说明
ZygoteInit.java#main() 中通过 ZygoteInit.java#forkSystemServer() 方法孵化出一个 SystemServer进程。在这个方法内，通过 Zygote.java#forkSystemServer() 的Zygote.java#nativeForkSystemServer() 来真正孵化一个 SystemServer进程出来。
源码
private static Runnable forkSystemServer(String abiList, String socketName,
ZygoteServer zygoteServer) {
try {
//...
/* Request to fork the system server process */
//通过 Zygote.forkSystemServer的native方法来fork一个System Server进程出来。
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.runtimeFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
//pid=0表示fork成功，子进程正在执行
//pid=-1fork失败
//pid>0返回的是子进程的实际pid，表示父进程正在执行
/* For child process */
if (pid == 0) {
//pid==0说明fork成功，进入该方法，当前是 System Server进程
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
//接下去就是SystemServer进程，不再需要socket通信
zygoteServer.closeServerSocket();
//处理System Server后续的执行内容。
//通过反射把SystemServer.java的main()方法暴露出去使用
return handleSystemServerProcess(parsedArgs);
}
//pid!=0说明当前是Zygote进程，返回null，ZygoteInit.main()将会继续往下执行。
return null;
}
3. ZygoteInit.java # handleSystemServerProcess()
说明
运行到这个方法，说明该段代码运行在由 Zygote孵化出来的 SystemServer进程中，该方法的任务主要是对 dex进行优化操作，并且通过ZygoteInit.java#zygoteInit()方法使用反射包装将SystemServer.java#main()方法暴露出去
源码
private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
if (systemServerClasspath != null) {
//进行dex优化操作
performSystemServerDexOpt(systemServerClasspath);
//...
ClassLoader cl = null;
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
Thread.currentThread().setContextClassLoader(cl);
return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
}
4. ZygoteInit.java # zygoteInit()
说明
ZygoteInit.java#handleSystemServerProcess() 调用该方法，在通过 RuntimeInit.java#applicationInit() 来返回一个反射SystemServer.java#main() 的Runnable。
源码
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams();
RuntimeInit.commonInit();
ZygoteInit.nativeZygoteInit();
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
5. RuntimeInit.java # applicationInit()
说明
RuntimeInit.java#applicationInit()通过RuntimeInit.java#findStaticMain()来返回一个MethodAndArgsCaller。
源码
//RuntimeInit.java # applicationInit()
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {
//...
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
//RuntimeInit.java # findStaticMain()
//找到SystemServer的main()方法并返回回去
protected static Runnable findStaticMain(String className, String[] argv,
ClassLoader classLoader) {
//拿到SystemService.class
Class<?> cl = Class.forName(className, true, classLoader);
//拿到main()方法
Method m = cl.getMethod("main", new Class[] { String[].class });
//...
return new MethodAndArgsCaller(m, argv);
}
static class MethodAndArgsCaller implements Runnable {
//想要调用的方法
private final Method mMethod;
//调用方法时需要传入的参数
private final String[] mArgs;
//构造方法，传入SystemServer的main()方法与需要的参数
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
//调用run方法，可以反射调用SystemServer的main()方法
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs });
} catch (Exception ex) {
//...
}
}
}
6. SystemServer.java # main()
说明
Zygote孵化出的 SystemServer进程，通过调用 r.run()方法进入到SystemServer.java # main() ，这是 SystemServer进程真正的入口。它开始了 SystemServer的生命历程。它调用了 SystemServer.java # run() 进行一些配置后，就开始了三大主要任务：
- 启动引导服务，如AMS，PMS等
- 启动核心服务
- 启动其他服务
源码
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
try {
//一些系统设置
//...
// 准备Looper（在这个线程中）
Looper.prepareMainLooper();
// 加载动态库
System.loadLibrary("android_servers");
// 创建系统context
createSystemContext();
// 创建系统SystemServiceManager
mSystemServiceManager = new SystemServiceManager(mSystemContext);
//...
} finally {
traceEnd(); // InitBeforeStartServices
}
//启动服务
try {
traceBeginAndSlog("StartServices");
// 启动引导服务。如AMS，PMS等，进去看
startBootstrapServices();
// 启动核心服务
startCoreServices();
// 启动其他服务
startOtherServices();
//停止线程池
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
//...
} finally {
//...
}
//为当前的虚拟机初始化VmPolicy
StrictMode.initVmDefaults(null);
//...
//死循环执行
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
7. SystemServer.java # startBootstrapServices()
说明
该方法用于启动系统 Boot引导级别的服务，例如 AMS（ActivityManagerService）、PowerManagerService、PackageManagerService（PKMS/PMS）等服务。
源码
private void startBootstrapServices() {
//启动watchdog
//尽早启动watchdog，如果在早起启动时发生死锁，我们可以让system_server
//崩溃，从而进行详细分析
final Watchdog watchdog = Watchdog.getInstance();
watchdog.start();
//...
//阻塞等待installd完成启动
Installer installer = mSystemServiceManager.startService(Installer.class);
//启动ATM
ActivityTaskManagerService atm = mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService();
//启动服务AMS
mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
//启动服务PowerManagerService，并初始化power management
mPowerManagerService = mSystemServiceManager.startService(
PowerManagerService.class);
mActivityManagerService.initPowerManagement();
//启动recovery system，以防需要重新启动
mSystemServiceManager.startService(RecoverySystemService.class);
//启动服务LightsService
//管理led和显示背光，所以我们需要它来打开显示
mSystemServiceManager.startService(LightsService.class);
//启动服务DisplayManagerService
//显示管理器需要在包管理器之前提供显示指标
mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
// Boot Phases: Phase100: 在初始化package manager之前，需要默认的显示.
mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
//启动服务PackageManagerService(PKMS/PMS)
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
//启动服务UserManagerService，新建目录/data/user/
mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
//为系统进程设置应用程序实例并开始。
//设置AMS
mActivityManagerService.setSystemProcess();
//使用一个ActivityManager实例完成watchdog设置并监听重启，
//只有在ActivityManagerService作为一个系统进程正确启动后才能这样做
watchdog.init(mSystemContext, mActivityManagerService);
//传感器服务需要访问包管理器服务、app ops服务和权限服务，
//因此我们在它们之后启动它。
//在单独的线程中启动传感器服务。在使用它之前应该检查完成情况。
mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
TimingsTraceLog traceLog = new TimingsTraceLog(
SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.
TRACE_TAG_SYSTEM_SERVER);
traceLog.traceBegin(START_SENSOR_SERVICE);
startSensorService(); //启动传感器服务
traceLog.traceEnd();
}, START_SENSOR_SERVICE);
}
8. SystemServer.java # startCoreServices()
说明
启动核心服务，例如BatteryService,UsageStatsService,WebViewUpdateService,GpuService等等。
源码
private void startCoreServices() {
//启动服务BatteryService，用于统计电池电量，需要LightService.
mSystemServiceManager.startService(BatteryService.class);
//启动服务UsageStatsService，用于统计应用使用情况
mSystemServiceManager.startService(UsageStatsService.class);
mActivityManagerService.setUsageStatsManager(
LocalServices.getService(UsageStatsManagerInternal.class));
//启动服务WebViewUpdateService
//跟踪可更新的WebView是否处于就绪状态，并监视更新安装
if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
}
//启动CachedDeviceStateService，跟踪和缓存设备状态
mSystemServiceManager.startService(CachedDeviceStateService.class);
//启动BinderCallsStatsService, 跟踪在绑定器调用中花费的cpu时间
mSystemServiceManager.startService(BinderCallsStatsService.LifeCycle.class);
//启动LooperStatsService，跟踪处理程序中处理消息所花费的时间。
mSystemServiceManager.startService(LooperStatsService.Lifecycle.class);
//启动RollbackManagerService，管理apk回滚
mSystemServiceManager.startService(RollbackManagerService.class);
//启动BugreportManagerService，捕获bugreports的服务
mSystemServiceManager.startService(BugreportManagerService.class);
//启动GpuService，为GPU和GPU驱动程序提供服务。
mSystemServiceManager.startService(GpuService.class);
}
9. SystemServer.java # startOtherServices
说明
启动其他的服务。
源码
private void startOtherServices() {
...
//启动TelecomLoaderService，通话相关核心服务
mSystemServiceManager.startService(TelecomLoaderService.class);
//Phase480:在接收到此启动阶段后，服务可以获得锁设置数据
mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
//Phase500:在接收到这个启动阶段之后，服务可以安全地调用核心系统服务，
//如PowerManager或PackageManager。
mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
mActivityManagerService.systemReady(() -> {
//Phase550:在接收到此引导阶段后，服务可以广播意图。
mSystemServiceManager.startBootPhase(
SystemService.PHASE_ACTIVITY_MANAGER_READY);
//Phase600:在接收到这个启动阶段后，服务可以启动/绑定到第三方应用程序。
//此时，应用程序将能够对服务进行绑定调用。
mSystemServiceManager.startBootPhase(
SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
}
}
三、 ActivityManagerService启动流程
ActivityManagerService服务由SystemServer进程在 startBootstrapServices()方法中启动，在AMS正式启动之前，SystemServer需要做几件事：
- 初始化SystemContext，AMS的上下文将与SystemServer的保持一致
- 创建SystemServiceManager对象，用来启动后续的服务
- 启动三种服务（引导服务，核心服务，其他服务）
- 在引导服务中启动AMS服务
- 在其他服务中完成AMS的最后工作，即 systemReady
0. ActivityManagerService启动流程示意图
1. SystemServer.java # createSystemContext();
说明
在这个方法中，初始化了SystemContext，即SystemServer的上下文
源码
private void createSystemContext() {
//创建ActivityThread对象。并调用该对象的attach方法
ActivityThread activityThread = ActivityThread.systemMain();
//获取system context
mSystemContext = activityThread.getSystemContext();
//设置系统主题
mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
//获取systemUI context
final Context systemUiContext = activityThread.getSystemUiContext();
//设置systemUI主题
systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}
2. ActivityThread 对象创建与attach()方法
说明
ActivityThread拥有自己的looper以及handler，它可以代表事件处理线程。在attach()方法中主要就是创建了Instrumentation、Application和Context，
Instrumentation是Android中的一个工具类，它优先于应用中其他类被初始化，系统先创建它，再通过它来创建其他组件。
源码
public final class ActivityThread extends ClientTransactionHandler {
...
//定义了AMS与应用通信的接口，拿到ApplicationThread的对象
final ApplicationThread mAppThread = new ApplicationThread();
//拥有自己的looper，说明ActivityThread确实可以代表事件处理线程
final Looper mLooper = Looper.myLooper();
//H继承Handler，ActivityThread中大量事件处理依赖此Handler
final H mH = new H();
//用于保存该进程的ActivityRecord
final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
//用于保存进程中的Service
final ArrayMap<IBinder, Service> mServices = new ArrayMap<>();
用于保存进程中的Application
final ArrayList<Application> mAllApplications
= new ArrayList<Application>();
//构造函数
@UnsupportedAppUsage
ActivityThread() {
mResourcesManager = ResourcesManager.getInstance();
}
private void attach(boolean system, long startSeq) {
mSystemThread = system;
//传入的system为0
if (!system) {
//应用进程的处理流程
...
} else {
//系统进程的处理流程，该情况只在SystemServer中处理
//创建ActivityThread中的重要成员：Instrumentation、 Application 和 Context
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
//创建系统的Context
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
//调用LoadedApk的makeApplication函数
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
}
}
}
3。 SystemServer.java # startBootstrapServices();
说明
SystemServer创建好系统上下文后，会创建一个SystemServerManager对象，其主要用于管理 SystemService 的创建、启动等生命周期，
ActivityManagerService也由它来创建。创建完成后，通过setSystemProcess()为系统进程设置应用程序实例并开始。
源码
private void startBootstrapServices() {
...
//通过SystemServiceManager来启动AMS服务
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
//为AMS设置SystemServiceManager
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
//为AMS设置安装器
mActivityManagerService.setInstaller(installer);
...
//为系统进程设置应用程序实例并开始
mActivityManagerService.setSystemProcess();
}
4. SystemServiceManager.java # startService()
说明
SystemServiceManager 通过反射创建 SystemService 对象，并且还会将其添加到 mServices中。
- 获取AMS.class
- 实例化AMS
- 将AMS注册到mServices，便于统一管理
- 开启服务
源码
//1. 获取AMS.class
public SystemService startService(String className) {
final Class<SystemService> serviceClass;
try {
//反射获取AMS类
serviceClass = (Class<SystemService>) Class.forName(className);
} catch (ClassNotFoundException ex) {
}
return startService(serviceClass);
}
//2. 实例化AMS对象
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
...
final T service;
try {
//反射实例化AMS
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
} catch (InstantiationException ex) {
。。。
startService(service);
return service;
} finally {
...
}
}
//3. 注册AMS，并开启AMS服务
public void startService(@NonNull final SystemService service) {
// Register it.
mServices.add(service);
try {
service.onStart();
} catch (RuntimeException ex) {
...
}
}
5. 实例化AMS对象
说明
SystemServiceManager 获取到 AMS.class 后，通过反射可以实例化AMS对象出来。ActivityManagerService构造函数初始化主要工作就是初始化一些变量。
在初始化过程中开启了mHandlerThread线程，这就是AMS线程，其中的消息由mHandler来处理。
源码
public ActivityManagerService(Context systemContext) {
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
// AMS运行上下文与SystemServer一致
mContext = systemContext;
// 取出的是ActivityThread的静态变量sCurrentActivityThread（由最近的attach()设置而来）
// mSystemThread就是SystemServer的ActivityTHread
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
// 做一些设置，并运行HandlerThread中的run方法，其中包括但不限于Looper.prepare();
// 在Looper.prepare()中有Looper的全局ThreadLocal，prepare()方法为当前线程设置一个looper()，并加到SThreadLocal中
mHandlerThread = new ServiceThread(TAG,
THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
mHandlerThread.start();
// 处理AMS中的消息
// 为looper设置处理消息的handler
mHandler = new MainHandler(mHandlerThread.getLooper());
// UiHandler对应于Android中的UiThread
mUiHandler = mInjector.getUiHandler(this);
...
// 创建BroadcastQueue 前台广播对象，处理超时时长为10s
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", BROADCAST_FG_TIMEOUT, false);
// 创建BroadcastQueue后台广播对象，处理超时时长为 60s
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", BROADCAST_BG_TIMEOUT, true);
// 在Android10中还会新增分流广播对象
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
// 创建ActiveServices对象，用于管理ServiceRecord对象（管理正在运行的Service)
mServices = new ActiveServices(this);
// 用于管理ContentProciderRecord对象（管理Provider）
mProviderMap = new ProviderMap(this);
...
mProcessCpuThread = new Thread("CpuTracker");//设置cpu监视线程
...
}
6. ActivityManagerService.java # start()
说明
实例化AMS对象后，SystemServiceManager将该服务注册管理，并通过ActivityManagerService.Lifecycle.onStart()方法来间接调用AMS的start()方法，由此启动AMS服务。
在AMS的start()方法中，主要做了：
- 移除所有的进程组
- 启动CPU监控线程
- 在本地服务注册AMS服务
- 如果cpu监控线程初始化出了问题，打断当前线程。
源码
private void start() {
// 溢出所有的进程组
removeAllProcessGroups();
// 启动CPU监控线程
mProcessCpuThread.start();
// 在本地服务注册表中注册服务
LocalServices.addService(ActivityManagerInternal.class, new LocalService());
try {
// 让出锁，等待CPU线程初始化完成，如果初始化出现问题，打断当前线程
mProcessCpuInitLatch.await();
} catch (InterruptedException e) {
...
Thread.currentThread().interrupt();
}
}
7. ActivityManagerService.java # setSystemProcess()
说明
SystemServer在启动引导服务中，开启AMS后，还要通过setSystemProcess()为系统进程设置应用实例，并开始。AMS的setSystemProcess主要由五个功能：
-
注册服务
-
获取ApplicationInfo
-
为ActivityThread安装 system application相关信息
-
为system_server主进程开一个 ProcessRecord来维护进程的相关信息
AMS作为线程，所在的进程就是 system_server进程
-
AMS进程管理
源码
public void setSystemProcess() {
try {
// 1. 注册服务
...
ServiceManager.addService("permission", new PermissionController(this));
...
// 2. 通过解析framework-res.apk里的AndroidManifest.xml获取ApplicationInfo（系统进程的APplicationInfo）
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
// 为SystemThread(即之前实例化的ActivityThread)安装system
// application的相关信息，将framework-res.apk对应的ApplicationInfo安装到LoadedApk中的mApplicationInfo
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
// 为SystemServer主进程开启一个ProcessRecord来管理进程的相关信息
synchronized (this) {
ProcessRecord app = new ProcessRecordLocked(info, info.processName, false, 0);
// 对 ProcessRecord 做一些赋值
app.persistent = true;// 设置进程常驻
app.pid = MY_PID;// 设置当前进程ID为system_server进程ID
app.maxAdj = ProcessList.SYSTEM_ADJ;
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.put(app.pid, app);// 初始化过后，放到mPidsSelfLocked中统一管理
}
...
}
} catch (PackageManager.NameNotFoundException e) {
...
}
}
8. ActivityManagerService.java # systemReady()
说明
SystemServer在启动所有服务过后，就到了AMS的最后工作：systemReady();
AMS的 systemReady() 主要由三个任务：
-
杀死哪些在AMS启动完成前已经存在的，而且不是常驻进程的进程。
（需要注意：Java进程才会向AMS注册，而一般的Native进程不会想AMS注册，所以此处杀死的是一些Java进程）
-
调用传入的Runnable参数，主要是监控native的crash，启动webview，启动SystemUI，以及通知其他服务进行 systemReady,systemRunning等方法。
-
启动 Launcher APP，即 Home Activity，启动结束后，发送 ACTION_BOOT_COMPLETED 广播。
源码
SystemServer.java # startOtherServices()
private void startOtherServices(){
...
mActivityManagerService.systemReady(()->{
});
}
ActivityManagerService.java # systemReady()
public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
traceLog.traceBegin("PhaseActivityManagerReady");
synchronized (this) {
if (mSystemReady) {
// 第一次进入mSystemReady为false，不走该流程
if (goingCallback != null) {
//第二次进来，则运行传入的runnable
goingCallback.run();
}
return;
}
...
// 主要时调用一些关键服务SystemReady相关的函数
// 进行一些等待AMS初始完，才能进行的工作
mUserController.onSystemReady();
mRecentTasks.onSystemReadyLocked();
mAppOpsService.systemReady();
// 最后设置systemReady为true
mSystemReady = true;
}
ArrayList<ProcessRecord> procsToKill = null;
synchronized (mPidsSelfLocked) {
for (int i = mPidsSelfLocked.size() - 1; i >= 0; i--) {
// mPidsSelfLocked中保存着当前正在运行的所有进程的信息
ProcessRecord proc = mPidsSelfLocked.valueAt(i);
// 收集一些不用的进程
if (!isAllowedWhileBooting(proc.info)) {
if (procsToKill == null) {
procsToKill = new ArrayList<ProcessRecord>();
}
procsToKill.add(proc);
}
}
}
// 收集已启动的进程并杀死，除了persistent常驻进程
synchronized (this) {
if (procsToKill != null) {
for (int i = procsToKill.size() - 1; i >= 0; i--) {
ProcessRecord proc = procsToKill.get(i);
removeProcessLocked(proc, true, false, "system update done");
}
}
// 至此系统准备完毕
mProcessesReady = true;
}
// 调用参数传入的runnable对象
if (goingCallback != null)
goingCallback.run();
// 调用所有系统服务的onStartUser接口
mSystemServiceManager.startUser(currentUserId);
// 启动persistent为1的application所在的进程
startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
//----------在这里启动 Home Activity ---------------
// 启动HomeActivity即LauncherActivity
// Android10改为交给ATM管理Activity，此时还是由AMS来开启
startHomeActivityLocked(currentUserId, "systemReady");
// 当启动结束后，发送ACTION_BOOT_COMPLETED广播
...
long ident = Binder.clearCallingIdentity();
try {
//发送广播 ACTION_USER_STARTED
Intent intent = new Intent(Intent.ACTION_USER_STARTED);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
| Intent.FLAG_RECEIVER_FOREGROUND);
intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
broadcastIntentLocked(null, null, intent,
null, null, 0, null, null, null, OP_NONE,
null, false, false, MY_PID, SYSTEM_UID,
currentUserId);
//发送广播 ACTION_USER_STARTING
intent = new Intent(Intent.ACTION_USER_STARTING);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
broadcastIntentLocked(null, null, intent,
null, new IIntentReceiver.Stub() {
@Override
public void performReceive(Intent intent, int resultCode, String data,
Bundle extras, boolean ordered, boolean sticky, int sendingUser)
throws RemoteException {
}
}, 0, null, null,
new String[] { INTERACT_ACROSS_USERS }, OP_NONE,
null, true, false, MY_PID, SYSTEM_UID, UserHandle.USER_ALL);
} catch (Throwable t) {
Slog.wtf(TAG, "Failed sending first user broadcasts", t);
} finally {
Binder.restoreCallingIdentity(ident);
}
}
}
四、 Launcher App (Home Activity)启动流程
AMS（ActivityManagerService）启动的最后一步就是开启 Home Activity。Home Activity就是我们所知的手机桌面，它展示有自定义内容，以及各种APP的图标，通过点击APP的桌面图标，可以打开我们安装好的APP。
0. Launcher APP 启动流程示意图
AMS启动完成的最后一步 systemReady() 中，发起了打开HomeActivity的请求，通过 Socket ，让 Zygote 孵化器进程得知，并由 Zygote 进程孵化出一个 App 进程，并打开 Activity 。
1. ActivityManagerService.java # startHomeActivityLocked()
说明
在 ActivityManagerService.java # systemReady()中，通过该方法启动Home Activity。在Android10.0之后，改为交给ActivityTaskManagerService(ATM)来管理Activity，此时仍然由AMS来开启。
源码
boolean startHomeActivityLocked(int userId, String reason) {
...
mActivityStartController.startHomeActivity(intent, aInfo, myReason);
}
2. ActivityStartController.java # startHomeActivity()
说明
ActivityStartController的该方法主要任务是
- 获取ActivityStarter，
- 做一些设置，
- 调用
ActivityStarter.java # execute()方法进行真正的Home Activity启动逻辑。
源码
void startHomeActivity(Intent intent, ActivityInfo aInfo, String reason) {
// 放到栈顶
mSupervisor.moveHomeStackTaskToTop(reason);
// 1.通过ActivityStarter的工厂模式获取ActivityStarter
// 2.做一些设置
// 3.执行ActivityStarter.execute()，这是真正的启动逻辑
mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
.setOutActivity(tmpOutRecord)
.setCallingUid(0)
.setActivityInfo(aInfo)
.execute();
...
}
3. ActivityStarter.java # execute() ，startActivity() 与 startActivityUnchecked()
说明
ActivityStarter的execute()方法才是真正进入Home Activity启动逻辑的入口，通过多次调用同名函数ActivityStarter.java # startActivity()来进行打开Home Activity前的设置。
源码
int execute(){
try{
if(mRequest.mayWait){
return startActivityMayWait(...);
}else{
return startActivity(...);
}
}finally{
//回调，告知controller，Activity开启完成
onExecutionComplete();
}
}
//逐个调用同名函数startActivity()后，进入到最后一个startActivity()方法
private int startActivity(...){
// 逐步startActivity，进入到这里（主键减少参数传递，并且减少一个方法的代码量
try {
// 演示布局
mService.mWindowManager.deferSurfaceLayout();
// 调用 startActivityUnchecked 一路调用到resumeFocusedStacksTopActivities()
result = startActivityUnchecked(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, outActivity);
} finally {
...
}
...
}
//最后调用到startActivityUnchecked()
private int startActivityUnchecked(...){
//设置、计算一些属性
...
//交给ActivityStackSupervisor来启动
mSupervisor.resumeFocusedStackTopActivityLocked(mTargetStack, mStartActivity,
mOptions);
...
}
4. ActivityStackSupervisor.java # resumeFocusedStackTopActivityLocked()
说明
ActivityStackSupervisor中又进入到ActivityStack
源码
boolean resumeFocusedStackTopActivityLocked(...) {
if (targetStack != null && isFocusedStack(targetStack)) {
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || !r.isState(RESUMED)) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.isState(RESUMED)) {
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
5. ActivityStack.java # resumeTopActivityUncheckedLocked() 、 resumeTopActivityInnerLocked()
说明
ActivityStack又通过ActivityStackSupervisor来通知AMS来启动新进程
源码
boolean resumeTopActivityUncheckedLocked(ActivityRecord prev, ActivityOptions options) {
...
result = resumeTopActivityInnerLocked(prev, options);
...
}
private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOptions options) {
...
// 大致在源码2900行左右
mStackSupervisor.startSpecificActivityLocked(next, true, false);
...
}
6. ActivityStackSupervisor.java # startSpecificActivityLocked()
说明
主要任务是调用 AMS.startProcessLocked() 来通知AMS打开新进程
源码
void startSpecificActivityLocked(ActivityRecord r,
boolean andResume, boolean checkConfig) {
// 判断想要打开的activity的application是否正在运行
ProcessRecord app = mService.getProcessRecordLocked(r.processName,
r.info.applicationInfo.uid, true);
if (app != null && app.thread != null) {
try {
//如果已经打开了
realStartActivityLocked(r, app, andResume, checkConfig);
return;
} catch (RemoteException e) {
...
}
}
//如果没打开，即Home Activity之前不可能打开，就调用AMS的startProcessLocked方法去打开Home Activity即Launcher进程
mService.startProcessLocked(r.processName, r.info.applicationInfo, true, 0,
"activity", r.intent.getComponent(), false, false, true);
}
7. ActivityManagerService.java # startProcessLocked()、startProcess()
说明
AMS依次调用多各同名函数 startProcessLocked(), 最后调用到真正请求打开新进程的方法startProcess()
源码
//这里只看最后一次调用到的startProcessLocked()
private boolean startProcessLocked(...){
...
//为ProcessRecord设置一些参数
...
final ProcessStartResult startResult = startProcess(...);
}
private ProcessStartResult startProcess(String hostingType, String entryPoint,
ProcessRecord app, int uid, int[] gids, int runtimeFlags, int mountExternal,
String seInfo, String requiredAbi, String instructionSet, String invokeWith,
long startTime) {
try {
final ProcessStartResult startResult;
if (hostingType.equals("webview_service")) {
//如果是要启动 webview
startResult = startWebView(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, null,
new String[] { PROC_START_SEQ_IDENT + app.startSeq });
} else {
// 启动应用程序进程
startResult = Process.start(entryPoint,
app.processName, uid, uid, gids, runtimeFlags, mountExternal,
app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
app.info.dataDir, invokeWith,
new String[] { PROC_START_SEQ_IDENT + app.startSeq });
}
...
return startResult;
} finally {
...
}
}
8. ZygoteProcess.java # zygoteSendArgsAndGetResult()
说明
从AMS中调用Process.start()到通过socket发送消息给Zygote进程，通知创建新进程的调用过程如下：
-
Process.java
- start()
-
ZygoteProcess.java
- start()
- startViaZygote()
- zygoteSendArgsAndGetResult()
由startViaZygote()方法对启动应用需要的参数进行拼接，最后进入到zygoteSendArgsAndGetResult()方法
源码
ZygoteProcess.java # startViaZygote() 主要任务是
private Process.ProcessStartResult startViaZygote(...)
throws ZygoteStartFailedEx {
ArrayList<String> argsForZygote = new ArrayList<String>();
// 创建单链表argsForZygote并将应用的启动参数保存在其中
// --runtime-args, --setuid=, --setgid=,
// and --setgroups= must go first
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
...
if (startChildZygote) {
argsForZygote.add("--start-child-zygote");
}
argsForZygote.add(processClass);
if (extraArgs != null) {
for (String arg : extraArgs) {
argsForZygote.add(arg);
}
}
// 将拼接好的参数，交给 zygoteSendArgsAndGetResult() 通过socket发送消息给 Zygote进程。
synchronized (mLock) {
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi), argsForZygote);
}
}
ZygoteProcess.java # zygoteSendArgsAndGetResult() 主要任务是与Zygote进程进行socket通信，告知需要创建子进程，并附带应用启动需要的参数信息。
//主要任务就是鱼Zygote进程进行socket通信
private static Process.ProcessStartResult zygoteSendArgsAndGetResult(
ZygoteState zygoteState, ArrayList<String> args)
throws ZygoteStartFailedEx {
...
final BufferedWriter writer = zygoteState.writer;
final DataInputStream inputStream = zygoteState.inputStream;
writer.write(Integer.toString(args.size()));
writer.newLine();
for (int i = 0; i < sz; i++) {
String arg = args.get(i);
writer.write(arg);
writer.newLine();
}
writer.flush();
...
}
五、 Zygote fork()子进程，子进程入口为ActivityThread.main()
Zygote的启动流程我们之前有讲到过，它最后会通过ZygoteServer.java # runSelectLoop()进入循环等待，用来接收Socket发来的消息，用来fork出其他应用进程，比如Launcher进程。
Zygote孵化出的第一个服务进程是SystemServer进程，Zygote孵化出的第一个应用进程是ActivityManagerService.systemReady()时启动的 Home Activity。Zygote进程都是通过Linux的fork()函数孵化出新的进程。
不论是服务进程还是应用进程，进程的入口都是ActivityThread.main()。我们上面已经讨论过 SystemServer进程。接下来讨论通过Zygote孵化出一个应用进程：
0. Zygote fork()到应用进程启动流程
1.ZygoteConnection.java # processOneCommand()
说明
Zygote进程接收socket消息，实际上是在ZygoteConnection.java # processOneCommand() 中的 readArgumentList()方法进行读取。如果需要新建进程，将会进入Zygote.forkAndSpecialize()方法中。
源码
Runnable processOneCommand(ZygoteServer zygoteServer){
//读取socket消息
args = readArgumentList();
//根据消息内容决定要做什么行为
...
pid = Zygote.forkAndSpecialize(...);
try{
if(pid == 0){
//如果是fork出来的进程
return handleChildProc(...);
}else{
//如果仍然是Zygote进程
}
}
}
2. Zygote.java # forkAndSpecialize()
说明
这里主要是调用dalvik中ZygoteHooks的preFork进行预处理，再调用postForkCommon进行fork后进程的处理
源码
public static int forkAndSpecialize(..){
VM_HOOKS.preFork();//VM_HOOKS是ZygoteHooks实例
int pid = nativeForkAndSpecialize(...);//native方法进行fork
VM_HOOKS.postForkCommon();//处理fork后的进程
}
3. ZygoteHooks.java # preFork()
说明
在fork进程之前做的准备：
- 关闭四个守护进程：
- HeapTaskDaemon（Java堆整理线程）
- ReferenceQueueDaemon（引用队列线程）
- FinalizerDaemon（析构线程）
- FinalizerWatchdogDaemon（析构监控线程）
- 等待所有线程停止
- ative层的fork前的处理
源码
public void preFork() {
Daemons.stop();//先调用目标线程interrupt()方法，在调用join方法等待线程执行完成。（改为同步等待，确保关闭完成）
waitUntilAllThreadsStopped();//线程消息都存在"/proc/self/task"中
token = nativePreFork();
}
4. Zyote.java # nativeForkAndSpecialize()
说明
任务是fork子进程。方法是JNI调用com_android_internal_os_Zygote.cpp # com_android_internal_os_Zygote_nativeForkAndSpecialize.
源码
static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(...) {
return ForkAndSpecializeCommon(env, uid, gid, gids, runtime_flags,
rlimits, capabilities, capabilities, mount_external, se_info,
se_name, false, fdsToClose, fdsToIgnore, is_child_zygote == JNI_TRUE,
instructionSet, appDataDir);
}
5. com_android_internal_os_Zygote.cpp # ForkAndSpecializeCommon()
说明
在这里真正fork进程，在Android10.0之后，其中的fork()方法将会被抽取出去。fork完成后，会进行进程的一些资源处理，selinux权限处理，并在最后反射调用Zygote的callPostForkChildHooks() 进行Java堆线程的一些处理
源码
static pid_t ForkAndSpecializeCommon(...) {
...
// ----------下面这部分代码在Android10.0被单独抽到ForkCommon()方法中----------
pid_t pid = fork();
//fork子进程，这里执行一次，会返回两次
//pid = 0 表示fork成功，且当前程序在fork的子进程中执行
//pid > 0 表示fork成功，且当前程序在Zygote中执行，pid为fork的子进程的真正PID（进程ID）
if (pid == 0) {
//进入子进程
PreApplicationInit();
//关闭并清除文件描述符
if (!DetachDescriptors(env, fdsToClose, &error_msg)) {
fail_fn(error_msg);
}
// ----------下面这部分代码在Android10.0被单独抽到SpecializeCommon()方法中----------
if (!is_system_server && getuid() == 0) {
//对于非system_server的子进程，创建进程组
int rc = createProcessGroup(uid, getpid());
...
}
//设置group
if (!SetGids(env, javaGids, &error_msg)) {
fail_fn(error_msg);
}
//设置资源限制
if (!SetRLimits(env, javaRlimits, &error_msg)) {
fail_fn(error_msg);
}
//selinux上下文，这部分写法与Android10.0中的大同小异
rc = selinux_android_setcontext(uid, is_system_server, se_info_c_str, se_name_c_str);
//设置子进程的signal信号处理函数为默认函数
UnsetChldSignalHandler();
//反射调用zygote.callPostForkChildHooks()
env->CallStaticVoidMethod(gZygoteClass, gCallPostForkChildHooks, runtime_flags,
is_system_server, is_child_zygote, instructionSet);
...
return pid;
}
6. ZygoteHooks.java # postForkCommon()
说明
native层进行进程fork之后，启动Zygote的四个Daemon守护线程。
源码
public void postForkCommon() {
Daemons.startPostZygoteFork();
nativePostZygoteFork();
}
7. ZygoteConnection.java # handleChildProc()
说明
执行该方法时，是在子进程的上下文中，Zygote进程不会走到这一步。该方法最终获取到需要执行的ActivityThread的main()
源码
private Runnable handleChildProc(...){
//关闭socket
closeSocket();
...
if (!isZygote) {
//App进程将会进入这里，调用目标类的main()
return ZygoteInit.zygoteInit(...);
} else {
return ZygoteInit.childZygoteInit(...);
}
}
8. ZygoteInit.java # zygoteInit()
说明
进行一些环节的初始化，启动Binder进程等操作。并把ActivityThread
源码
public static final Runnable zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) {
...
RuntimeInit.commonInit();//初始化运行环境
ZygoteInit.nativeZygoteInit();//启动Binder线程池进程
//调用程序入口函数
return RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
RuntimeInit.java # applicationInit()
protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) {
...
return findStaticMain(args.startClass, args.startArgs, classLoader);
}
RuntimeInit.java # findStaticMain()
把反射得来的 ActivityThread的main()入口返回给ZygoteInit的main()方法（此时程序运行在之前fork出来的新进程，不影响Zygote进程），通过caller.run()进行调用。
protected static Runnable findStaticMain(String className, String[] argv,
ClassLoader classLoader) {
Class<?> cl;
try {
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {}
Method m;
try {
m = cl.getMethod("main", new Class[] { String[].class });//反射获取main()方法
} catch (NoSuchMethodException ex) {}
...
return new MethodAndArgsCaller(m, argv);
}
RuntieInit.java # MethodAndArgsCaller.class
static class MethodAndArgsCaller implements Runnable {
private final Method mMethod;
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
//封装到run方法中，暴露出去
public void run() {
try {
mMethod.invoke(null, new Object[] { mArgs });
} catch (IllegalAccessException ex) { }
}
}
至此，新的应用程序进程以及创建成功，并以ActivityThread.main()为起点，进入消息循环Looper，开始了应用程序。
单单这样是不够的，应用程序还需要Activity等各种组件，所以接下来就正式进入到从ActivityThread.main()到Activity.onCreate()的历程
六、 Activity的启动流程（从ActivityThread到Activity）
0. Activity启动流程图
1. ActivityThread.java # main()
说明
由 ZygoteInit.java # main() 的 caller.run()方法，正式进入APP的主线程的main()入口。这里为主线程处理，首先创建ActivityThread对象，调用attach进行处理，最终进入Looper循环。
源码
public static void main(String[] args) {
...
//在当前进程中的LocalThread中存放当前线程的Looper
Looper.prepareMainLooper();
...
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
//死循环一旦退出，表面程序结束，抛出RuntieException
Looper.loop();
...
}
//第一个参数表示当前进程是应用进程还是服务进程（如SystemServer）
private void attach(boolean system, long startSeq){
sCurrentActivityThread = this;
mSystemThread = system;
if(!system){
//如果应用进程
...
RuntimeInit.setApplicationObject(mAppThread.asBinder());
final IActivityManager mgr = ActivityManager.getService();
try {
//通过Binder调用AMS的attachApplication方法，进行activity的启动
mgr.attachApplication(mAppThread, startSeq);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
...
} else {
//通过system_server启动ActivityThread对象
...
}
// 为 ViewRootImpl 设置配置更新回调，
ViewRootImpl.ConfigChangedCallback configChangedCallback
= (Configuration globalConfig) -> {
synchronized (mResourcesManager) {
...
}
};
//添加回调监听接口
ViewRootImpl.addConfigCallback(configChangedCallback);
}
2. ActivityManagerService.java # attachApplication()
说明
清除一些没有用的记录，最终调用ActivityStackSupervisor.java # realStartActivityLocked()方法进行Activity的启动。
源码
private final boolean attachApplicationLocked(IApplicationThread thread,long startSeq) {
synchronized (this) {
int callingPid = Binder.getCallingPid();
final int callingUid = Binder.getCallingUid();
final long origId = Binder.clearCallingIdentity();
attachApplicationLocked(thread, callingPid, callingUid, startSeq);
Binder.restoreCallingIdentity(origId);
}
}
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid, int callingUid, long startSeq) {
...
//如果当前的Application记录仍然依附在之前的进程，清除掉
if (app.thread != null) {
handleAppDiedLocked(app, true, true);
}
...
if (normalMode) {
try {
//直接调用ActivityStackSupervisor的方法
//在Android10中，将会把该任务交给ATM，ATM中层层调用才到ActivityStackSupervisor的该方法
if (mStackSupervisor.attachApplicationLocked(app)) {
didSomething = true;
}
} catch (Exception e) {
...
}
}
}
3. ActivityStackSupervisor.java # attachApplicationLocked()
说明
在该方法中，通过realStartActivityLocked()真正地准备去启动Activity。
在realStartActivityLocked()之后层层调用的主要过程：
- 等到所有Activity都onPause之后才会去启动新Activity
- 为ClientTransaction设置LaunchActivityItem作为callback
- 通过ClientLifecycleManager.scheduleTransaction()来发起启动Activity
- 层层调用来到ActivityThread的scheduleTransaction()。ActivityThread继承自ClientTransactionHandler
- ActivityThread的scheduleTransaction()主动通过sendMessage发出EXECUTE_TRANSACTION消息
- ActivityThread的Handler收到消息后，通过TransactionExecutor.execute() 来回调之前设置的 LaunchActivityItem.execute()，从而通过ActivityThread的引用调用其 handleLaunchActivity()方法
- handleLaunchActivity()中，调用performLaunchActivity()
源码
ActivityStackSupervisor.java # attachApplicationLocked()
boolean attachApplicationLocked(ProcessRecord app) throws RemoteException {
...
if(realStartActivityLocked(activity,app,top==activity,true)){
didSomething = true;
}
}
ActivityStackSupervisor.java # realStartActivityLocked()
final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app,
boolean andResume, boolean checkConfig) throws RemoteException {
//等到所有的onPause()方法执行结束才会去启动新的Activity
if (!allPausedActivitiesComplete()) {
...
return false;
}
//添加 LaunchActivityItem
final ClientTransaction clientTransaction = ClientTransaction.obtain(app.thread,
r.appToken);
//LaunchActivityItem.obtain()作为回调参数
clientTransaction.addCallback( LaunchActivityItem.obtain(new Intent(r.intent, ...));
...
try{//设置生命周期状态
final ActivityLifecycleItem lifecycleItem;
if (andResume) {
lifecycleItem = ResumeActivityItem.obtain(mService.isNextTransitionForward());
} else {
lifecycleItem = PauseActivityItem.obtain();
}
clientTransaction.setLifecycleStateRequest(lifecycleItem);
//mService.getLifecycleManager返回的是ClientLifecycleManager
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
} catch (RemoteException e) {
if (r.launchFailed) {
//第二次启动失败，finish activity
stack.requestFinishActivityLocked(r.appToken, Activity.RESULT_CANCELED,null,"2nd-crash", false);
return false;
}
//第一次失败，重启进程并重试
r.launchFailed = true;
app.activities.remove(r);
throw e;
}
} finally {
endDeferResume();
}
...
return true;
}
ClientLifycycleManager.java # scheduleTransaction()
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
final IApplicationThread client = transaction.getClient();
transaction.schedule();
if (!(client instanceof Binder)) {
transaction.recycle();
}
}
ClientTransaction.java # schedule()
里面的mClient是 IApplicationThread 实例，传入的是app.thread，即ActivityThread实例
public void schedule() throws RemoteException {
mClient.scheduleTransaction(this);
}
ActivityThread.java # scheduleTransaction()
这里的scheduleTransaction()没有实现，调用的是父类的方法，ActivityThread.java继承自ClientTransactionHandler.java
ClientTransactionHandler.java # scheduleTransaction()
void scheduleTransaction(ClientTransaction transaction) {
//之前有传入LaunchActivityItem.obtain()作为一个回调，在这里将会被调用,只会更新一些ActivityThread的变量、状态
transaction.preExecute(this);
//发送到ActivityThread的handler里
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}
ActivityThread.java # sendMessage()
private void sendMessage(int what, Object obj) {
Message msg = Message.obtain();
...
mH.sendMessage(msg);
}
最后有ActivityThread.java中的mH来处理消息
ActivityThread.java -> H.class
class H extends Handler{
...
public void handleMessage(){
...
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
//调用ClientTransaction中的callbacks，如之前加入的LaunchActivityItem.execute()
mTransactionExecutor.execute(transaction);
if (isSystem()) {
transaction.recycle();
}
break;
}
}
TransactionExecutor.java # execute()
public void execute(ClientTransaction transaction) {
executeCallbacks(transaction);
executeLifecycleState(transaction);
}
public void executeCallbacks(ClientTransaction transaction) {
final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
final int size = callbacks.size();
for (int i = 0; i < size; ++i) {
...
item.execute(mTransactionHandler, token, mPendingActions);
...
}
}
LaunchActivityThread.java # execute()
LaunchActivityThread是之前构造 ClientTransaction 时设置的 callback ，在这里被调用execute()方法，最后让 ActivityThread 调用handleLaunchActivity()方法
public void execute(ClientTransactionHandler client, IBinder token,
PendingTransactionActions pendingActions) {
//这里的client是ActivityThread（ActivityThread继承自ClientTransactionHandler）
client.handleLaunchActivity(r, pendingActions, null );
}
ActivityThread.java # handleLaunchActivity()
public Activity handleLaunchActivity(ActivityClientRecord r,
PendingTransactionActions pendingActions, Intent customIntent) {
。。。
//初始化WindowManagerGlobal
WindowManagerGlobal.initialize();
//调用performLaunchActivity，来处理Activity
final Activity a = performLaunchActivity(r, customIntent);
...
return a;
}
4. ActivityThread.java # performLaunchActivity()
说明
该方法是启动activity的核心实现。
获取ComponentName, Context, 通过 Instrumentation.java # newActivity() 来反射实例化Activity，并设置一些内容，最后还通过Instrumentation.java # callActivityOnCreate()方法来回调Activity的 onCreate() 方法
源码
private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
//获取ComponentName
ComponentName component = r.intent.getComponent();
//获取context
ContextImpl appContext = createBaseContextForActivity(r);
Activity activity = null;
//通过Instrumentation反射获取Activity实例
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
} catch (Exception e) {}
//回调activity的attach()方法与onCreate()方法
try {
//回调activity的attach方法
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);
//设置intent
if (customIntent != null) {
activity.mIntent = customIntent;
}
//设置主题
int theme = r.activityInfo.getThemeResource();
if (theme != 0) {
activity.setTheme(theme);
}
//通过Instrumentation来回调activity的onCreate()方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
//加入mActivities Map统一管理
mActivities.put(r.token, r);
} catch (SuperNotCalledException e) {
。。。
}
return activity;
}
5. Instrumentation.java # callActivityOnCreate()
说明
callActivityOnCreate() 先进行activity的onCreate()的预处理，再去调用activity的onCreate()，最后处理activity的onCreate()后的信息处理
源码
public void callActivityOnCreate(Activity activity, Bundle icicle) {
prePerformCreate(activity);
activity.performCreate(icicle);
postPerformCreate(activity);
}
Activity.java # performCreate()
final void performCreate(Bundle icicle, PersistableBundle persistentState) {
...
if (persistentState != null) {
onCreate(icicle, persistentState);
} else {
onCreate(icicle);
}
mFragments.dispatchActivityCreated();
}
至此，Activity的onCreate()方法回调完成，应用启动流程完成，APP应用程序真正启动起来。
