文章目录
在从Android 8.0源码的角度剖析Android系统启动过程(1)一文中,我们介绍了Android系统启动过程中的init进程和Zygote进程的启动流程,本文将在此基础上,继续介绍SystemServer进程和Launcher进程的启动流程,其中,SystemServer进程由Zygote进程通过fork形式创建并启动,该进程主要用于启动系统中各种关键的系统服务,比如AMS、PMS、WMS等等,而Launcher进程就是我们的系统桌面启动器,当AMS服务被SystemServer进程启动后首先就会去启动该进程。随着Launcher进程被启动完毕,Android系统启动过程也执行完毕。
1. SystemServer进程
SytemServer进程启动时序图如下:
在分析Zygote进程启动过程中,我们了解到SystemServer进程是在在ZygoteInit的main方法
中被创建的,在该方法中调用了ZygoteInit的startSystemServer方法
,该方法又调用了Zygote的nativeForkSystemServer方法
,这个方法是一个native方法,最终由它在native层通过调用fork函数实现在Zygote进程中创建SystemServer进程。如果pid=0,说明SystemServer进程被创建成功,此时当前代码逻辑运行在SystemServer子进程,接下来就会去调用ZygoteInit的handleSystemServerProcess方法
进入SystemServer进程的启动过程。startSystemServer方法源码如下:
// Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
private static boolean startSystemServer(String abiList, String socketName,
ZygoteServer zygoteServer)
throws Zygote.MethodAndArgsCaller, RuntimeException {
...
// SystemServer进程启动参数
// 注意"com.android.server.SystemServer"
// 后面会用到
String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,\
1008,1009,1010,1018,1021,1023,1032,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"com.android.server.SystemServer",
};
ZygoteConnection.Arguments parsedArgs = null;
int pid;
try {
parsedArgs = new ZygoteConnection.Arguments(args);
ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);
// Zygote进程通过fork自身创建一个子进程
// 即SystemServer进程
pid = Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.debugFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);
} catch (IllegalArgumentException ex) {
throw new RuntimeException(ex);
}
/* For child process */
// 当前代码逻辑运行在子进程中
if (pid == 0) {
if (hasSecondZygote(abiList)) {
waitForSecondaryZygote(socketName);
}
// 关闭Server Socket
// 注:SystemServer进程fork自Zygote进程,自然拥有一份Server Socket的副本
// 但是由于Server Socket是用来监听AMS请求的,SystemServer用不到
// 就将其关闭掉了
zygoteServer.closeServerSocket();
// 处理SystemServer进程
handleSystemServerProcess(parsedArgs);
}
return true;
}
接下来,我们看下ZygoteInit的handleSystemServerProcess方法。
// Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
private static void handleSystemServerProcess(
ZygoteConnection.Arguments parsedArgs)
throws Zygote.MethodAndArgsCaller {
...
ClassLoader cl = null;
if (systemServerClasspath != null) {
// 创建一个PathClassLoader
// 注:PathClassLoader用于加载系统类和应用程序的类
cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
Thread.currentThread().setContextClassLoader(cl);
}
// 进入SystemServer进程具体工作逻辑
ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
}
handleSystemServerProcess方法主要完成两件事,一是创建一个PathClassLoader对象,该对象是一个类加载器,主要用于加载系统类和应用程序的类;二是调用ZygoteInit的zygoteInit
方法进入下一步的处理,并将之前创建的PathClassLoader对象作为参数传入。其中,ZygoteInit的zygoteInit
方法源码如下:
// Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
public static final void zygoteInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
if (RuntimeInit.DEBUG) {
Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
}
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
RuntimeInit.redirectLogStreams();
RuntimeInit.commonInit();
// 启动Binder线程池
ZygoteInit.nativeZygoteInit();
// 进入com.android.server.SystemServer类的main方法
RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
}
zygoteInit方法主要完成两个任务:(1)
创建、启动Binder线程池。有了Binder线程池,SystemServer进程就可以通过Binder机制与其他进程进行通信;(2)
通过反射的方式调用SystemServer类的main方法,该方法最终完成各种系统服务的启动工作。接下来,我们重点分析以上两点。
1.1 启动Binder线程池
从ZygoteInit的zygoteInit
方法可知,Binder线程池的启动时通过调用ZygoteInit的nativeZygoteInit
方法实现的,该方法是一个native方法,它的具体实现位于native层的AndroidRuntime.cpp
源文件中。这里需要注意的是,AndroidRuntime.cpp中对nativeZygoteInit的注册是通过调用JNIEnv的RegisterNatives方法注册Java需要调用的Native方法,跟我们日常开发NDK流程有点不一样,即native层方法没有用"JNIEXPORT void JNICALL Java_...
"标明。相关源码如下:
// \Android8.0\frameworks\base\core\jni\AndroidRuntime.cpp
// 注册nativeZygoteInit方法对应的native层方法
int register_com_android_internal_os_ZygoteInit(JNIEnv* env)
{
const JNINativeMethod methods[] = {
{ "nativeZygoteInit", "()V",
(void*) com_android_internal_os_ZygoteInit_nativeZygoteInit },
};
// 注册对应的native方法
// 即将native层的nativeZygoteInit映射到
// "com_android_internal_os_ZygoteInit_nativeZygoteInit"函数
return jniRegisterNativeMethods(env, "com/android/internal/os/ZygoteInit",
methods, NELEM(methods));
}
// \Android8.0\frameworks\base\core\jni\AndroidRuntime.cpp
static AndroidRuntime* gCurRuntime = NULL;
static void com_android_internal_os_ZygoteInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
{
gCurRuntime->onZygoteInit();
}
从"com_android_internal_os_ZygoteInit_nativeZygoteInit
"函数源码可知,它只有一行代码,即通过指针变量gCurRuntime调用AndroidRuntime中的onZygoteInit
函数,但是遗憾的是,我在AndroidRuntime.cpp源文件中翻遍了都没有找到onZygoteInit
函数。有没有可能该指针变量指向的是AndroidRuntime的子类?确实如此!还记得在上一篇文章中分析Init进程启动Zygote进程时在app_main.cpp的main函数中,调用了一个名为AppRuntime
类的start函数进入了Zygote进程的初始化流程,而这个AppRuntime
就是AndroidRuntime的子类,定义在app_main.cpp源文件中。AppRuntime$onZygoteInit函数源码如下:
// \Android8.0\frameworks\base\cmds\app_process.cpp$AppRuntime
class AppRuntime : public AndroidRuntime
{
...
virtual void onZygoteInit()
{
sp<ProcessState> proc = ProcessState::self();
ALOGV("App process: starting thread pool.\n");
// 创建Binder线程池
proc->startThreadPool();
}
}
在AppRuntime$onZygoteInit函数中,最终调用ProcessState的startThreadPool函数首先判断线程池是否已经启动,如果没有,则将线程池状态mThreadPoolStarted属性设置为true,然后ProcessState的调用spawnPooledThread函数来创建、启动Binder线程池。ProcessState类中的源码如下:
// \Android8.0\frameworks\native\libs\binder\ProcessState.cpp
void ProcessState::startThreadPool()
{
// 获取互斥锁
AutoMutex _l(mLock);
if (!mThreadPoolStarted) {
// 将线程池状态设置为true
mThreadPoolStarted = true;
// 创建线程池,启动
spawnPooledThread(true);
}
}
// \Android8.0\frameworks\native\libs\binder\ProcessState.cpp
void ProcessState::spawnPooledThread(bool isMain)
{
if (mThreadPoolStarted) {
// 拼接Binder线程池名称 Binder:%d_%X
String8 name = makeBinderThreadName();
ALOGV("Spawning new pooled thread, name=%s\n", name.string());
// 创建Binder线程池
sp<Thread> t = new PoolThread(isMain);
// 启动Binder线程池
t->run(name.string());
}
}
1.2 启动系统服务
前面说到,在ZygoteInit的handleSystemServerProcess方法中会去调用RuntimeInit$applicationInit
方法进入SystemServer进程的启动各种系统服务流程。RuntimeInit$applicationInit
方法源码如下:
// Android8.0\frameworks\base\core\java\com\android\internal\os\RuntimeInit.java
protected static void applicationInit(int targetSdkVersion, String[] argv,
ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
...
// 将SytemServer进程启动参数(ZygoteInit$startSystemServer)
// String args[] = {
// "--setuid=1000",
// "--setgid=1000",
// ...
// "--nice-name=system_server",
// "--runtime-args",
// "com.android.server.SystemServer",
// };
// 存储到Arguments中
final Arguments args;
try {
args = new Arguments(argv);
} catch (IllegalArgumentException ex) {
Slog.e(TAG, ex.getMessage());
// let the process exit
return;
}
// Remaining arguments are passed to the start class's static main
// 调用startClass的main方法,该方法是一个静态方法
// 这个startClass就是在startSystemServer中启动参数中传入的
// “com.android.server.SystemServer”
invokeStaticMain(args.startClass, args.startArgs, classLoader);
}
RuntimeInit$applicationInit
方法首先会将ZygoteInit
s
t
a
r
t
S
y
s
t
e
m
S
e
r
v
e
r
传
递
过
来
的
S
y
s
t
e
m
S
e
r
v
e
r
启
动
参
数
存
储
到
A
r
g
u
m
e
n
t
s
中
,
然
后
调
用
‘
R
u
n
t
i
m
e
I
n
i
t
startSystemServer传递过来的SystemServer启动参数存储到Arguments中,然后调用`RuntimeInit
startSystemServer传递过来的SystemServer启动参数存储到Arguments中,然后调用‘RuntimeInitinvokeStaticMain方法,该方法将通过反射的形式调用args.startClass表示类的main方法,而这个arg.startClass表示的类就是“com.android.server.SystemServer”。
RuntimeInit$invokeStaticMain`方法源码如下:
// Android8.0\frameworks\base\core\java\com\android\internal\os\RuntimeInit.java
private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
throws Zygote.MethodAndArgsCaller {
Class<?> cl;
try {
// 通过类名全限定路径获取对应的Class对象
cl = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(
"Missing class when invoking static main " + className,
ex);
}
Method m;
try {
// 通过Class对象获取className类的main方法
m = cl.getMethod("main", new Class[] { String[].class });
} catch (NoSuchMethodException ex) {
throw new RuntimeException(
"Missing static main on " + className, ex);
} catch (SecurityException ex) {
throw new RuntimeException(
"Problem getting static main on " + className, ex);
}
int modifiers = m.getModifiers();
if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
throw new RuntimeException(
"Main method is not public and static on " + className);
}
// 抛出MethodAndArgsCaller异常
// 并将m作为参数传出去,将被ZygoteInit.main函数捕获
throw new Zygote.MethodAndArgsCaller(m, argv);
}
在invokeStaticMain方法中,对“com.android.server.SystemServer”的main方法调用比较巧妙,它通过反射方式获取到SystemServer类的main方法信息后并没有直接去调用它,而是在方法的最后抛出了一个Zygote.MethodAndArgsCaller
异常,并将代表"main"函数的Method的对象和相关参数传递进去。那么问题来了,又在哪里捕获这个Zygote.MethodAndArgsCaller
异常?首先我们来分析捕获这个异常的地方。通常一个异常的抛出,要么由方法本身捕获,要么由调用它的上一级方法,甚至更上多级。因此,我们采用向上回溯方式,从当前方法(invokeStaticMain)向上查找到底哪个方法catch了Zygote.MethodAndArgsCaller
异常,最终我们找到ZygoteInit的main方法对这个异常进行了捕获,而该main方法就是之前我们分析得到的,即启动SystemServer进程的入口!回顾下ZygoteInit的main方法:
// \Android8.0\frameworks\base\core\java\com\android\internal\os\ZygoteInit.java
public static void main(String argv[]) {
...
try{
// 启动SystemServer进程
if (startSystemServer) {
startSystemServer(abiList, socketName, zygoteServer);
}
...
} catch (Zygote.MethodAndArgsCaller caller) {
// 捕获ygote.MethodAndArgsCaller异常
caller.run();
}
...
}
// Android8.0\frameworks\base\core\java\com\android\
// internal\os\Zygote.java$MethodAndArgsCaller
public static class MethodAndArgsCaller extends Exception
implements Runnable {
/** method to call */
private final Method mMethod;
/** argument array */
private final String[] mArgs;
public MethodAndArgsCaller(Method method, String[] args) {
mMethod = method;
mArgs = args;
}
public void run() {
try {
// 调用m方法,传入参数为mArgs
// mArgs=“com.android.server.SystemServer”
mMethod.invoke(null, new Object[] { mArgs });
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex);
} catch (InvocationTargetException ex) {
Throwable cause = ex.getCause();
if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
} else if (cause instanceof Error) {
throw (Error) cause;
}
throw new RuntimeException(ex);
}
}
}
从上述源码可知,ZygoteInit的main方法捕获到Zygote.MethodAndArgsCaller异常后,会直接调用Zygote.MethodAndArgsCaller的run方法,再调用反射类Method的invoke方法对“com.android.server.SystemServer”类的main方法进行动态调用,SystemServer类将完成SystemServer进程的具体任务。接下来,我们分析SystemServer类的main方法,该方法实现很简单,就是new了一个SystemServer对象,然后调用它的run方法。相关源码如下:
// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
public static void main(String[] args) {
// 创建一个SystemServer实例
// 调用该实例的run方法
new SystemServer().run();
}
private void run() {
// Prepare the main looper thread (this thread).
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);
android.os.Process.setCanSelfBackground(false);
// 创建当前线程Looper对象
Looper.prepareMainLooper();
// Initialize native services.
// 加载系统库libandroid_servers.so
System.loadLibrary("android_servers");
// Initialize the system context.
// 创建系统的Context
createSystemContext();
// Create the system service manager.
// 创建系统服务管理器
mSystemServiceManager = new SystemServiceManager(mSystemContext);
mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
// Prepare the thread pool for init tasks that can be parallelized
// 准备线程池
SystemServerInitThreadPool.get();
...
// 启动服务
try {
traceBeginAndSlog("StartServices");
// 启动Bootstrap(引导)服务
startBootstrapServices();
// 启动Core(核心)服务
startCoreServices();
// 启动Other(其他)服务
startOtherServices();
SystemServerInitThreadPool.shutdown();
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
traceEnd();
}
...
// 开启消息循环
Looper.loop();
}
总的来说,SystemServer的run方法主要完成以下工作:
- 创建当前线程的Looper对象,开启消息循环;
- 创建系统服务管理器SystemServiceManager,用于对系统服务进行创建、启动以及生命周期管理;
- 启动系统服务,包括引导服务、核心服务以及其他服务。
1.2.1 启动Bootstrap(引导)服务
SystemServer的startBootstrapServices方法源码如下:
// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startBootstrapServices() {
...
// Installer服务
traceBeginAndSlog("StartInstaller");
Installer installer = mSystemServiceManager.startService(Installer.class);
traceEnd();
// AMS服务
traceBeginAndSlog("StartActivityManager");
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
traceEnd();
// PowerManagerService服务
traceBeginAndSlog("StartPowerManager");
mPowerManagerService =
mSystemServiceManager.startService(PowerManagerService.class);
traceEnd();
// LightsService服务
traceBeginAndSlog("StartLightsService");
mSystemServiceManager.startService(LightsService.class);
traceEnd();
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
mFactoryTestMode !=
FactoryTest.FACTORY_TEST_OFF,
mOnlyCore);
// PMS服务
mFirstBoot = mPackageManagerService.isFirstBoot();
mPackageManager = mSystemContext.getPackageManager();
...
// SensorService服务
mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
BootTimingsTraceLog traceLog = new BootTimingsTraceLog(
SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
traceLog.traceBegin(START_SENSOR_SERVICE);
startSensorService();
traceLog.traceEnd();
}, START_SENSOR_SERVICE);
}
引导服务主要包括(部分):
-
Installer:系统安装APK时的服务类;
-
ActivityManagerService:负责四大组件的启动、切换以及调度;
-
PowerManagerService:计算系统中与Power相关的计算,决策系统该如何反应;
-
LightsService:管理和显示背景LED;
-
PackageManagerService:负责对APK的安装、解析、卸载等工作;
-
SensorService:为系统提供各种感应器服务;
1.2.2 启动Core(核心)服务
SystemServer的startCoreServices方法源码如下:
// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startCoreServices() {
// Records errors and logs, for example wtf()
traceBeginAndSlog("StartDropBoxManager");
mSystemServiceManager.startService(DropBoxManagerService.class);
traceEnd();
traceBeginAndSlog("StartBatteryService");
// Tracks the battery level. Requires LightService.
mSystemServiceManager.startService(BatteryService.class);
traceEnd();
// Tracks application usage stats.
traceBeginAndSlog("StartUsageService");
mSystemServiceManager.startService(UsageStatsService.class);
mActivityManagerService.setUsageStatsManager(
LocalServices.getService(UsageStatsManagerInternal.class));
traceEnd();
traceBeginAndSlog("StartWebViewUpdateService");
mWebViewUpdateService =
mSystemServiceManager.startService(WebViewUpdateService.class);
traceEnd();
}
系统核心服务包括:
- DropBoxManagerService: 用于生成和管理系统运行时的一些日志文件;
- BatteryService: 管理电池相关的服务;
- UsageStatsService: 使用户使用每一个APP的频率,使用时长;
- WebViewUpdateService: WebView更新服务;
1.2.3 启动Other(其他)服务
SystemServer的startOtherServices方法源码如下:
// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startOtherServices() {
...
// Camera Service
if (!disableCameraService) {
Slog.i(TAG, "Camera Service Proxy");
traceBeginAndSlog("StartCameraServiceProxy");
mSystemServiceManager.startService(CameraServiceProxy.class);
traceEnd();
}
// VibratorService
traceBeginAndSlog("StartVibratorService");
vibrator = new VibratorService(context);
ServiceManager.addService("vibrator", vibrator);
traceEnd();
// AlarmManagerService
traceBeginAndSlog("StartAlarmManagerService");
mSystemServiceManager.startService(AlarmManagerService.class);
traceEnd();
// StartInputManagerService
traceBeginAndSlog("StartInputManagerService");
inputManager = new InputManagerService(context);
traceEnd();
// WindowManagerService
traceBeginAndSlog("SetWindowManagerService");
mActivityManagerService.setWindowManager(wm);
traceEnd();
// BluetoothService
traceBeginAndSlog("StartBluetoothService");
mSystemServiceManager.startService(BluetoothService.class);
traceEnd();
// NetworkManagementService
if (!disableNetwork) {
traceBeginAndSlog("StartNetworkManagementService");
try {
networkManagement = NetworkManagementService.create(context);
ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE,
networkManagement);
} catch (Throwable e) {
reportWtf("starting NetworkManagement Service", e);
}
traceEnd();
}
// WIFI_SERVICE_CLASS
traceBeginAndSlog("StartWifi");
mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
traceEnd();
// NotificationManagerService
traceBeginAndSlog("StartNotificationManager");
mSystemServiceManager.startService(NotificationManagerService.class);
SystemNotificationChannels.createAll(context);
notification = INotificationManager.Stub.asInterface(
ServiceManager.getService(Context.NOTIFICATION_SERVICE));
networkPolicy.bindNotificationManager(notification);
traceEnd();
...
}
系统其他服务包括(部分):
-
CameraService: 摄像头相关服务;
-
AlarmManagerService: 全局定时器管理服务;
-
InputManagerSevice:管理输入事件服务;
-
WindowManagerService:窗口管理服务;
-
BluetoothService:蓝牙管理服务;
-
WifiService:Wifi相关服务
-
NotificationManagerService:通知管理服务;
-
LocationManagerService:定位管理服务;
-
AudioService:音频相关管理服务;
2. Launcher进程
Launcher进程启动时序图如下:
在从Android 8.0源码的角度剖析APK打包、安装过程一文中,我们曾谈到APK的安装、卸载都是由系统服务PackageManagerService(简称PMS
)完成的。当PMS系统服务被SystemSystem进程启动后,它会去扫描/system/app
等目录,将这些目录下的APK应用程序安装,其中就包括系统应用Launcher。Launcher又被称为桌面启动器,是Android系统不可缺少的部分,它提供一个可视化桌面允许我们与Android系统进行交互,比如为一个安装好的应用程序生成一个快捷方式、打开或删除一个应用等。在ActvityManagerService(简称AMS
)被启动后,它就会去启动Launcher进程,具体入口在startOtherServices
函数中,通过调用AMS的systemReady方法实现。相关源码如下:
// \Android8.0\frameworks\base\services\java\com\android\server\SystemServer.java
private void startOtherServices() {
...
// 启动Launcher进程
mActivityManagerService.systemReady(() -> {
Slog.i(TAG, "Making services ready");
traceBeginAndSlog("StartActivityManagerReadyPhase");
mSystemServiceManager.startBootPhase(
SystemService.PHASE_ACTIVITY_MANAGER_READY);
traceEnd();
}
...
try {
// 启动com.android.systemui.SystemUIService服务
// SystemUI是系统启动中第一个用户肉眼可见的应用,其功能包罗万象,
// 比如开机后看到的锁屏界面,充电时充电界面,状态栏,导航栏,多任务栏等
startSystemUi(context, windowManagerF);
} catch (Throwable e) {
reportWtf("starting System UI", e);
}
...
}
// Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityManagerService.java
public void systemReady(final Runnable goingCallback, BootTimingsTraceLog traceLog) {
...
// 调用ActivityStackSupervisor的resumeFocusedStackTopActivityLocked方法
mStackSupervisor.resumeFocusedStackTopActivityLocked();
...
}
AMS的systemReady
方法又调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked
方法,该方法又调用了ActivityStackSupervisor的resumeFocusedStackTopActivityLocked
方法。
// \Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityStackSupervisor.java
boolean resumeFocusedStackTopActivityLocked(
ActivityStack targetStack, ActivityRecord target, ActivityOptions targetOptions) {
if (targetStack != null && isFocusedStack(targetStack)) {
// 调用ActivityStack的resumeTopActivityUncheckedLocked
return targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);
}
final ActivityRecord r = mFocusedStack.topRunningActivityLocked();
if (r == null || r.state != RESUMED) {
mFocusedStack.resumeTopActivityUncheckedLocked(null, null);
} else if (r.state == RESUMED) {
// Kick off any lingering app transitions form the MoveTaskToFront operation.
mFocusedStack.executeAppTransition(targetOptions);
}
return false;
}
在上述方法中,调用了ActivityStack的resumeTopActivityUncheckedLocked,这个ActivityStack对象是用来描述Activity堆栈的。resumeTopActivityUncheckedLocked方法实现很简单,它继续调用了ActivityStack的resumeTopActivityInnerLocked,该方法源码如下:
// \Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityStack.java
private boolean resumeTopActivityInnerLocked(ActivityRecord prev,
ActivityOptions options) {
if (!mService.mBooting && !mService.mBooted) {
// Not ready yet!
return false;
}
...
// mStackId == HOME_STACK_ID
else if (!isHomeStack()){
// Launching home next
// 进入启动Launcher home
if (DEBUG_STATES) Slog.d(TAG_STATES,
"resumeTopActivityLocked: Launching home next");
return isOnHomeDisplay() &&
mStackSupervisor.resumeHomeStackTask(prev, "prevFinished");
}
}
resumeTopActivityInnerLocked方法会判断当前mStackId
属性是否等于HOME_STACK_ID,如果不等于,说明Launcher还没有被启动,就会去调用ActivityStackSupervisor的resumeHomeStackTask方法,该方法最终会去调用AMS的startHomeActivityLocked方法,由这个方法执行Launcher应用的主Activity。源码如下:
// \Android8.0\frameworks\base\services\core\java\com\android\server\am
// ActivityManagerService.java
boolean startHomeActivityLocked(int userId, String reason) {
...
// 获取Launcher进程的Home的主Activity信息
Intent intent = getHomeIntent();
...
// ActivityStarter:启动Launcher
mActivityStarter.startHomeActivityLocked(intent, aInfo, myReason);
...
}
Intent getHomeIntent() {
// 设置Intent的Action属性
// String mTopAction = Intent.ACTION_MAIN;
Intent intent = new Intent(mTopAction, mTopData != null ?
Uri.parse(mTopData) : null);
intent.setComponent(mTopComponent);
intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
// 设置Intent的Category属性
if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
intent.addCategory(Intent.CATEGORY_HOME);
}
return intent;
}
AMS的startHomeActivityLocked方法首先会通过getHomeIntent方法获取一个Intent对象,并设置该Intent对象的Action属性值为Intent.ACTION_MAIN
和Category属性值为Intent.CATEGORY_HOME
,而这两个属性值恰好对得上Launcher应用源码的AndroidManifest.xml中名为"com.android.launcher2.Launcher"的Activity过滤条件,也就是说,这个Intent目的就是去启动Launcher的Home Activity,即"com.android.launcher2.Launcher"。然后,调用ActivityStarter的startHomeActivityLocked方法进入具体的启动流程,这个与启动一个普通的Activity差不多,就不在继续分析下去了,请参考文章《从Android 6.0源码的角度剖析Activity的启动过程》。至此,Launcher应用的启动分析完毕。Launcher2的AndroidMainfest.xml源码如下:
// \Android8.0\packages\apps\Launcher2\AndroidMainfest.xml
<application
android:name="com.android.launcher2.LauncherApplication"
android:label="@string/application_name"
android:icon="@mipmap/ic_launcher_home"
android:hardwareAccelerated="true"
android:largeHeap="@bool/config_largeHeap"
android:supportsRtl="true">
<activity
android:name="com.android.launcher2.Launcher"
android:launchMode="singleTask"
android:clearTaskOnLaunch="true"
android:stateNotNeeded="true"
android:resumeWhilePausing="true"
android:theme="@style/Theme"
android:windowSoftInputMode="adjustPan"
android:screenOrientation="nosensor">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.HOME" />
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.MONKEY"/>
</intent-filter>
</activity>
</application>