Android从开机到APP启动流程——基于Android9.0
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
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();
//配置如是否打开SystemServersocketName是什么是否开启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层的核心服务例如创建 AMSActivityManagerService。PKMSPackageManagerService等。这些服务以不同的线程方式存在于 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进程返回nullZygoteInit.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() 进行一些配置后就开始了三大主要任务
- 启动引导服务如AMSPMS等
- 启动核心服务
- 启动其他服务
源码
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");
// 启动引导服务。如AMSPMS等进去看
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引导级别的服务例如 AMSActivityManagerService、PowerManagerService、PackageManagerServicePKMS/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需要做几件事
- 初始化SystemContextAMS的上下文将与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继承HandlerActivityThread中大量事件处理依赖此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的全局ThreadLocalprepare()方法为当前线程设置一个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)启动流程
AMSActivityManagerService启动的最后一步就是开启 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{
//回调告知controllerActivity开启完成
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进程之前做的准备
- 关闭四个守护进程
- HeapTaskDaemonJava堆整理线程
- 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中将会把该任务交给ATMATM中层层调用才到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是ActivityThreadActivityThread继承自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应用程序真正启动起来。