先說(shuō)總結(jié)：
當(dāng)手機(jī)電源按下，引導(dǎo)芯片代碼會(huì)從Boot Rom開始執(zhí)行，加載引導(dǎo)程序BootLoader到RAM，然后執(zhí)行。
BootLoader會(huì)啟動(dòng)idle進(jìn)程（pid=0）。idle進(jìn)程主要是初始化進(jìn)程管理、內(nèi)存管理等。
然后idle進(jìn)程會(huì)啟動(dòng)init進(jìn)程（pid=1）和kthread進(jìn)程（pid=2）。init進(jìn)程作為用戶空間的鼻祖。
Init進(jìn)程先是解析init.rc文件，然后又會(huì)通過(guò)fork，去加載zygote進(jìn)程。zygote進(jìn)程是java進(jìn)程的鼻祖。
Zygote進(jìn)程首先會(huì)初始化我們的運(yùn)行時(shí)環(huán)境，也就是android runtime。因?yàn)樵趜ygote之前都是c、c++的運(yùn)行環(huán)境，沒(méi)有java的運(yùn)行時(shí)環(huán)境。
啟動(dòng)運(yùn)行時(shí)環(huán)境后，就進(jìn)入java了。然后zygote進(jìn)程又會(huì)通過(guò)fork，加載systemServer進(jìn)程。android用到的系統(tǒng)服務(wù)都是在SystemServer進(jìn)程中，有90多個(gè)服務(wù)。像AMS、PMS。
SystemServer啟動(dòng)后，就會(huì)啟動(dòng)我們的launcher app。啟動(dòng)launcher app時(shí)，會(huì)發(fā)消息給zygote進(jìn)程，讓zygote進(jìn)程去啟動(dòng)一個(gè)進(jìn)程，啟動(dòng)進(jìn)程后，我們的app就會(huì)啟動(dòng)自己。
activity是如何啟動(dòng)的？
調(diào)用startActivity，通過(guò)一系列方法的調(diào)用，通過(guò)binder通信，進(jìn)入到systemServer進(jìn)程。binder拿的systemServer進(jìn)程中的AMS（10之前）/ATMS（10之后）服務(wù)。拿到服務(wù)的代理對(duì)象后，就會(huì)調(diào)用服務(wù)的startActivity，通過(guò)binder通信，進(jìn)入到systemServer進(jìn)程中。systemServer進(jìn)程，先判斷要啟動(dòng)的activity所需的進(jìn)程是否存在，如果不存在，就通過(guò)socket通信，通知給zygote進(jìn)程，創(chuàng)建一個(gè)新的進(jìn)程，然后在新進(jìn)程中通過(guò)反射啟動(dòng)ActivityThread.main()。執(zhí)行這個(gè)方法后，由于新的進(jìn)程需要被AMS/ATMS管理，所以新的進(jìn)程會(huì)把它的binder對(duì)象給到AMS/ATMS中去，AMS/ATMS就會(huì)持有新的進(jìn)程的binder對(duì)象，就可以去管理新的進(jìn)程，從而去管理它的生命周期。如果要啟動(dòng)的activity所需的進(jìn)程存在，那就不需要通知zygote，而是直接通過(guò)進(jìn)程的binder對(duì)象去啟動(dòng)activity。
我們的android系統(tǒng)是基于linux系統(tǒng)的，而在linux中，所有的進(jìn)程都是由init進(jìn)程直接或間接fork出來(lái)的。zygote也不例外。
在android系統(tǒng)中，zygote是一個(gè)進(jìn)程的名字。當(dāng)手機(jī)開機(jī)時(shí)，linux系統(tǒng)內(nèi)核加載完成之后，就會(huì)啟動(dòng)init進(jìn)程。init進(jìn)程fork出zygote進(jìn)程。
SystemServer進(jìn)程也是由zygote進(jìn)程fork而來(lái)。
我們知道，每一個(gè)app都是一個(gè)單獨(dú)的dalvik虛擬機(jī)，一個(gè)獨(dú)立的進(jìn)程。所以當(dāng)系統(tǒng)的第一個(gè)zygote進(jìn)程運(yùn)行之后，在這之后啟動(dòng)app，相當(dāng)于開啟了一個(gè)新的進(jìn)程。而為了實(shí)現(xiàn)資源的共享和更快的啟動(dòng)速度，android系統(tǒng)開啟新進(jìn)程的方式，是通過(guò)fork第一個(gè)zygote進(jìn)程實(shí)現(xiàn)的。所以說(shuō)，除了第一個(gè)zygote進(jìn)程，其他應(yīng)用所有的進(jìn)程都是由zygote進(jìn)程的子進(jìn)程。
AndroidFramework里有兩大進(jìn)程：一個(gè)就是zygote進(jìn)程，另一個(gè)就是SystemServer進(jìn)程。
一、zygote進(jìn)程
init進(jìn)程啟動(dòng)zygote進(jìn)程，fork SystemServer進(jìn)程。
ZygoteInit 是 zygote 進(jìn)程的啟動(dòng)類。在zygote開啟的時(shí)候，會(huì)調(diào)用ZygoteInit.main()進(jìn)行初始化。并fork中SystemServer進(jìn)程。
public static void main(String[] argv) {
......
try {
......
// 在加載首個(gè)zygote的時(shí)候，會(huì)傳入初始化參數(shù)，使得 startSystemServer = true
boolean startSystemServer = false;
String zygoteSocketName = "zygote";
String abiList = null;
boolean enableLazyPreload = false;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
// 首次加載，置為true
startSystemServer = true;
} else if ("--enable-lazy-preload".equals(argv[i])) {
enableLazyPreload = true
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
zygoteSocketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}
......
// 開始fork我們的SystemServer進(jìn)程
if (startSystemServer) {
// forkSystemServer方法的返回值是要么是一個(gè)MethodAndArgsCaller對(duì)象，要是是null
// 準(zhǔn)備參數(shù)，fork出ystemServer
Runnable r = forkSystemServer(abiList, zygoteSocketName, zygoteServer);
--> ......
// 請(qǐng)求fork SystemServer 進(jìn)程
pid = Zygote.forkSystemServer(
parsedArgs.mUid, parsedArgs.mGid,
parsedArgs.mGids,
parsedArgs.mRuntimeFlags, null, parsedArgs.mPermittedCapabilities,
parsedArgs.mEffectiveCapabilities);
--> ......
// SystemServer的命令行參數(shù)，這個(gè)就是SystemServer.main()的args參數(shù)。后面會(huì)通過(guò)反射調(diào)用SystemServer.main()
String[] args = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,"
+ "1024,1032,1065,3001,3002,3003,3006,3007,3009,3010,3011",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
"com.android.server.SystemServer",
};
// 在native層fork SystemServer
int pid = nativeForkSystemServer(
uid, gid, gids, runtimeFlags, rlimits,
permittedCapabilities, effectiveCapabilities);
// 如果這是孩子，則為 0，如果這是父母，則為孩子的 pid，或者錯(cuò)誤時(shí)為 -1。
return pid;
......
return handleSystemServerProcess(parsedArgs);
--> return ZygoteInit.zygoteInit(parsedArgs.mTargetSdkVersion, parsedArgs.mDisabledCompatChanges, parsedArgs.mRemainingArgs, cl);
// 在applicationInit中會(huì)對(duì)args數(shù)組進(jìn)行解析，轉(zhuǎn)換成有用的Arguments對(duì)象
--> return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv, classLoader);
// args.startClass = com.android.server.SystemServer
--> return findStaticMain(args.startClass, args.startArgs, classLoader);
--> ......
Method m;
try {
// 找到SystemServer.main(argv[]) 方法
m = cl.getMethod("main", new Class[] { String[].class });
......
return new MethodAndArgsCaller(m, argv);
}
// r == null，說(shuō)明在父（zygote）進(jìn)程中，r != null說(shuō)明在子（system_server）進(jìn)程中。
if (r != null) {
// 執(zhí)行的是MethodAndArgsCaller.run()，run方法內(nèi)部其實(shí)就是通過(guò)反射執(zhí)行SystemServer.main(argv[])
r.run();
return;
}
// 這里面是個(gè)while循環(huán)，用來(lái)接收socket消息。后面介紹啟動(dòng)進(jìn)程會(huì)講到。
caller = zygoteServer.runSelectLoop(abiList);
}
......
}
......
}
二、SystemServer進(jìn)程
1、啟動(dòng)SystemServer進(jìn)程，完成mSystemContext和ActivityThread的創(chuàng)建，初始化SystemServiceManager對(duì)象。
SystemServer.main()：
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
......
// 加載本地系統(tǒng)服務(wù)庫(kù)，并進(jìn)行初始化
System.loadLibrary("android_servers");
......
// 創(chuàng)建系統(tǒng)上下文
createSystemContext();
// 詳細(xì)看一下createSystemContext()
// 初始化系統(tǒng)上下文對(duì)象mSystemContext，并設(shè)置默認(rèn)的主題。
// mSystemContext實(shí)際上是一個(gè)ContextImpl對(duì)象。
--> private void createSystemContext() {
ActivityThread activityThread = ActivityThread.systemMain();
//
--> ActivityThread thread = new ActivityThread();
thread.attach(true, 0);
--> ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);
// 創(chuàng)建了 Application對(duì)象，并調(diào)用了Application.onCreate()
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
mInitialApplication.onCreate();
return thread;
mSystemContext = activityThread.getSystemContext();
mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
final Context systemUiContext = activityThread.getSystemUiContext();
systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}
// Call per-process mainline module initialization.
ActivityThread.initializeMainlineModules();
// 初始化SystemServiceManager對(duì)象，下面的系統(tǒng)服務(wù)開啟都需要調(diào)用SystemServiceManager.startService(Class<T>)，這個(gè)方法通過(guò)反射來(lái)啟動(dòng)對(duì)應(yīng)的服務(wù)
mSystemServiceManager = new SystemServiceManager(mSystemContext);
......
// 啟動(dòng)服務(wù)。接下來(lái)我們?cè)敿?xì)看一下啟動(dòng)的服務(wù)。
try {
t.traceBegin("StartServices");
startBootstrapServices(t); // 引導(dǎo)服務(wù)：ATMS、AMS等
startCoreServices(t); // 系統(tǒng)所需的核心服務(wù)
startOtherServices(t); // 其他服務(wù)：WMS等
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
t.traceEnd(); // StartServices
}
......
}
2、啟動(dòng)系統(tǒng)服務(wù)，ActivityManagerService、PackageManagerService、 WindowManagerService等。
系統(tǒng)里面重要的服務(wù)都是在這個(gè)進(jìn)程里面開啟的，比如 ActivityManagerService、PackageManagerService、 WindowManagerService等等。在SystemServer 進(jìn)程開啟的時(shí)候，會(huì)調(diào)用SystemServer.main()，初始化ActivityManagerService。
// 在這里開啟了幾個(gè)核心的服務(wù)，因?yàn)檫@些服務(wù)之間相互依賴，所以都放 在了這個(gè)方法里面
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
......
// android10之后，增減了ATMS。用來(lái)單獨(dú)管理activity
// 初始化ATMS
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
// 初始化AMS
mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
mWindowManagerGlobalLock = atm.getGlobalLock();
t.traceEnd();
......
// 電源管理器需要盡早啟動(dòng)，因?yàn)槠渌?wù)需要它。
t.traceBegin("StartPowerManager");
mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
t.traceEnd();
......
// 現(xiàn)在電源管理已經(jīng)開啟，ActivityManagerService負(fù)責(zé)電源管理功能
t.traceBegin("InitPowerManagement");
mActivityManagerService.initPowerManagement();
t.traceEnd();
......
// 初始化DisplayManagerService
t.traceBegin("StartDisplayManager");
mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
t.traceEnd();
......
// 初始化PackageManagerService
t.traceBegin("StartPackageManagerService");
try {
Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain");
mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
domainVerificationService, mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
} finally {
Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain");
}
......
}
2.1 ATMS的創(chuàng)建：
mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService().
先看mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class)：
mSystemServiceManager.startService() @SystemServer
// 通過(guò)反射獲取服務(wù)
--> final String name = serviceClass.getName(); @SystemServiceManager
final T service;
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
startService(service);
// 返回的service是T泛型，繼承自SystemService
return service;
--> mServices.add(service);
// 啟動(dòng)服務(wù)
service.onStart();
根據(jù)上面分析，ActivityTaskManagerService.Lifecycle繼承自SystemService，mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class)最后是調(diào)用了ActivityTaskManagerService.Lifecycle.onStart()。
那再來(lái)看ActivityTaskManagerService.Lifecycle：
public Lifecycle(Context context) {
super(context);
// ActivityTaskManagerService.Lifecycle構(gòu)造中初始化了mService。就是ATMS
mService = new ActivityTaskManagerService(context);
}
public void onStart() {
// 將 ATMS 加入到ServiceManager中
publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
// 注冊(cè) Binder 服務(wù)。
--> ServiceManager.addService(name, service, allowIsolated, dumpPriority); @SystemService
--> getIServiceManager().addService(name, service, allowIsolated, dumpPriority); @ServiceManager
// 調(diào)用 ATMS 的start()方法。
mService.start();
}
public ActivityTaskManagerService getService() {
// 將 ATMS 對(duì)象返回
return mService;
}
接下來(lái)我們看下ActivityTaskManagerService構(gòu)造方法中做了什么：
public ActivityTaskManagerService(Context context) {
mContext = context;
mFactoryTest = FactoryTest.getMode();
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
mLifecycleManager = new ClientLifecycleManager(); // 管理生命周期
mInternal = new LocalService();
GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
mWindowOrganizerController = new WindowOrganizerController(this);
mTaskOrganizerController = mWindowOrganizerController.mTaskOrganizerController;
}
ActivityServer進(jìn)程創(chuàng)建了SystemServiceManager，然后SystemServiceManager來(lái)啟動(dòng)各種服務(wù)，并將對(duì)應(yīng)的服務(wù)添加到SystemService中。
2.2 AMS的創(chuàng)建：
mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
ActivityManagerService中同樣有一個(gè)Lifecycle
public Lifecycle(Context context) {
super(context);
// ActivityManagerService.Lifecycle構(gòu)造中初始化了mService。就是AMS
mService = new ActivityManagerService(context, sAtm);
}
public static ActivityManagerService startService(
SystemServiceManager ssm, ActivityTaskManagerService atm) {
sAtm = atm; // atm就是 ATMS
// 還是由SystemServiceManager啟動(dòng)服務(wù)
return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
}
public ActivityManagerService getService() {
return mService;
}
接下來(lái)我們看下ActivityManagerService構(gòu)造方法中做了什么：
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
······
// 廣播的管理
final BroadcastConstants foreConstants = new BroadcastConstants(
Settings.Global.BROADCAST_FG_CONSTANTS);
foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
final BroadcastConstants backConstants = new BroadcastConstants(
Settings.Global.BROADCAST_BG_CONSTANTS);
backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
final BroadcastConstants offloadConstants = new BroadcastConstants(
Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
// by default, no "slow" policy in this queue
offloadConstants.SLOW_TIME = Integer.MAX_VALUE;
mEnableOffloadQueue = SystemProperties.getBoolean(
"persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", foreConstants, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", backConstants, true);
mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
"offload", offloadConstants, true);
// 三種廣播形式
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
mBroadcastQueues[2] = mOffloadBroadcastQueue;
// Services的管理
mServices = new ActiveServices(this);
......
// 電量狀態(tài)的管理
// TODO: Move creation of battery stats service outside of activity manager service.
mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
BackgroundThread.get().getHandler());
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.scheduleWriteToDisk();
mOnBattery = DEBUG_POWER ? true
: mBatteryStatsService.getActiveStatistics().getIsOnBattery();
mBatteryStatsService.getActiveStatistics().setCallback(this);
mOomAdjProfiler.batteryPowerChanged(mOnBattery);
// 進(jìn)程狀態(tài)的管理
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
mUserController = new UserController(this);
mPendingIntentController = new PendingIntentController(
mHandlerThread.getLooper(), mUserController, mConstants);
if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
mUseFifoUiScheduling = true;
}
mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
// mActivityTaskManager就是 ATMS
mActivityTaskManager = atm;
// ATMS進(jìn)行初始化，下面我們看下ATMS初始化中干了什么
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
DisplayThread.get().getLooper());
// 獲取ATMInternal，后面會(huì)講到。先有個(gè)印象
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
......
mInternal = new LocalService();
mPendingStartActivityUids = new PendingStartActivityUids(mContext);
}
mActivityTaskManager.initialize():
public void initialize(IntentFirewall intentFirewall, PendingIntentController intentController,
Looper looper) {
mH = new H(looper);
mUiHandler = new UiHandler();
mIntentFirewall = intentFirewall;
final File systemDir = SystemServiceManager.ensureSystemDir();
mAppWarnings = createAppWarnings(mUiContext, mH, mUiHandler, systemDir);
mCompatModePackages = new CompatModePackages(this, systemDir, mH);
mPendingIntentController = intentController;
// 創(chuàng)建ActivityStackSupervisor
mStackSupervisor = createStackSupervisor();
mTaskChangeNotificationController =
new TaskChangeNotificationController(mGlobalLock, mStackSupervisor, mH);
mLockTaskController = new LockTaskController(mContext, mStackSupervisor, mH);
// 控制activity的啟動(dòng),這個(gè)后面還會(huì)講到
mActivityStartController = new ActivityStartController(this);
// 最近使用的app
setRecentTasks(new RecentTasks(this, mStackSupervisor));
mVrController = new VrController(mGlobalLock);
mKeyguardController = mStackSupervisor.getKeyguardController();
}
經(jīng)過(guò)上面這些步驟，我們的ActivityManagerService對(duì)象已經(jīng)創(chuàng)建好了，并且完成了成員變量的初始化。而且在這之前，調(diào)用createSystemContext()創(chuàng)建上下文的時(shí)候，也已經(jīng)完成了mSystemContext和ActivityThread的創(chuàng)建。注意，這是系統(tǒng)進(jìn)程開啟時(shí)的流程。在這之后，會(huì)開啟系統(tǒng)的Launcher程序，完成系統(tǒng)界面的加載與顯示。
2.3 WMS的創(chuàng)建和綁定
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
t.traceBegin("startOtherServices");
......
WindowManagerService wm = null;
......
t.traceBegin("StartWindowManagerService");
// WMS 需要準(zhǔn)備好傳感器服務(wù)
ConcurrentUtils.waitForFutureNoInterrupt(mSensorServiceStart, START_SENSOR_SERVICE);
mSensorServiceStart = null;
wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);
ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
t.traceEnd();
t.traceBegin("SetWindowManagerService");
// AMS 綁定 WMS
mActivityManagerService.setWindowManager(wm);
t.traceEnd();
t.traceBegin("WindowManagerServiceOnInitReady");
wm.onInitReady();
t.traceEnd();
......
// 啟動(dòng) Launcher
mActivityManagerService.systemReady(() -> {
······
// 啟動(dòng) SystemUi
startSystemUi(context, windowManagerF);
......
}, t);
}
WindowManagerService.main():
public static WindowManagerService main(final Context context, final InputManagerService im,
final boolean showBootMsgs, final boolean onlyCore, WindowManagerPolicy policy,
ActivityTaskManagerService atm, Supplier<SurfaceControl.Transaction> transactionFactory,
Supplier<Surface> surfaceFactory,
Function<SurfaceSession, SurfaceControl.Builder> surfaceControlFactory) {
DisplayThread.getHandler().runWithScissors(() ->
// 創(chuàng)建WindowManagerService對(duì)象
sInstance = new WindowManagerService(context, im, showBootMsgs, onlyCore, policy,
atm, transactionFactory, surfaceFactory, surfaceControlFactory), 0);
return sInstance;
}
3、Launcher進(jìn)程的啟動(dòng)
mActivityManagerService.systemReady()
// mAtmInternal還記得是什么嗎？在AMS的構(gòu)造方法中獲取的。就是ActivityTaskManagerInternal。
// ActivityTaskManagerInternal是個(gè)抽象類，ATMS實(shí)現(xiàn)了它。
// 所以我們進(jìn)入到ATMS中看resumeTopActivities()方法
--> mAtmInternal.resumeTopActivities(false /* scheduleIdle */); @ActivityManagerService
--> mRootWindowContainer.resumeFocusedStacksTopActivities(); @ActivityTaskServiceManager
// 這邊分成兩步走，但最后都是調(diào)用的 resumeHomeActivity()
--> if (focusedStack != null) { @RootWindowContainer
// 會(huì)執(zhí)行這個(gè)...
result |= focusedStack.resumeTopActivityUncheckedLocked(target, targetOptions);
// 關(guān)鍵方法：resumeTopActivityInnerLocked()
--> result = resumeTopActivityInnerLocked(prev, options); @ActivityStack
--> return resumeNextFocusableActivityWhenStackIsEmpty(prev, options);
--> return mRootWindowContainer.resumeHomeActivity(prev, reason, getDisplayArea());
} else if (targetStack == null) {
result |= resumeHomeActivity(null /* prev */, "no-focusable-task",
display.getDefaultTaskDisplayArea());
}
接下來(lái)重點(diǎn)看下RootWindowContainer.resumeHomeActivity(prev, reason, getDisplayArea());
RootWindowContainer.resumeHomeActivity(prev, reason, getDisplayArea());
--> return startHomeOnTaskDisplayArea(mCurrentUser, myReason, taskDisplayArea,
false /* allowInstrumenting */, false /* fromHomeKey */);
// mService就是 ATMS。在創(chuàng)建AMS的時(shí)候，初始化ATMS的方法中，new出來(lái)一個(gè)ActivityStartController，用來(lái)控制activity的啟動(dòng)。
// 這里獲取到ActivityStartController，去啟動(dòng)HomeActivity。這個(gè)方法很重要。。。。
--> mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
taskDisplayArea);
// obtainStarter返回的是ActivityStarter對(duì)象，經(jīng)過(guò)一系列設(shè)置，最后執(zhí)行的是ActivityStarter.execute()
// ActivityStarter.execute()非常關(guān)鍵?。。≈攸c(diǎn)?。。「鷹５墓芾硐嚓P(guān)
--> mLastHomeActivityStartResult = obtainStarter(intent, "startHomeActivity: " + reason)
.setOutActivity(tmpOutRecord)
.setCallingUid(0)
.setActivityInfo(aInfo)
.setActivityOptions(options.toBundle())
.execute(); @ActivityStartController
上面執(zhí)行到 ActivityStarter.execute()，這個(gè)方法很關(guān)鍵。我們接下來(lái)看這個(gè)方法。
ActivityStarter.execute()
--> res = executeRequest(mRequest);
--> ActivityRecord sourceRecord = null; // 啟動(dòng)方
ActivityRecord resultRecord = null; // 將要啟動(dòng)的
......
mLastStartActivityResult = startActivityUnchecked(r, sourceRecord, voiceSession,
request.voiceInteractor, startFlags, true /* doResume */, checkedOptions, inTask,
restrictedBgActivity, intentGrants);
--> result = startActivityInner(r, sourceRecord, voiceSession, voiceInteractor,
startFlags, doResume, options, inTask, restrictedBgActivity, intentGrants);
--> mRootWindowContainer.resumeFocusedStacksTopActivities(mTargetStack, mStartActivity, mOptions);
--> result = targetStack.resumeTopActivityUncheckedLocked(target, targetOptions);@RootWindowContainer
// 這個(gè)方法就非常關(guān)鍵了。。。
--> result = resumeTopActivityInnerLocked(prev, options);@ActivityStack
// 這個(gè)相當(dāng)重要。。。下面著重看。。。
--> mStackSupervisor.startSpecificActivity(next, true, true);
ActivityStackSupervisor.startSpecificActivity()。這個(gè)方法非常非常重要?。?！要記住?。?！
void startSpecificActivity(ActivityRecord r, boolean andResume, boolean checkConfig) {
// 判斷要啟動(dòng)的activity的application是否已經(jīng)在運(yùn)行中？
// Is this activity's application already running?
final WindowProcessController wpc =
mService.getProcessController(r.processName, r.info.applicationInfo.uid);
boolean knownToBeDead = false;
// 進(jìn)程已經(jīng)存在
if (wpc != null && wpc.hasThread()) {
try {
// 真正的去啟動(dòng)Activity
realStartActivityLocked(r, wpc, andResume, checkConfig);
return;
} catch (RemoteException e) {
Slog.w(TAG, "Exception when starting activity "
+ r.intent.getComponent().flattenToShortString(), e);
}
// If a dead object exception was thrown -- fall through to
// restart the application.
knownToBeDead = true;
}
r.notifyUnknownVisibilityLaunchedForKeyguardTransition();
final boolean isTop = andResume && r.isTopRunningActivity();
// 如果進(jìn)程還不存在，就在這里去啟動(dòng)app的進(jìn)程。。。mService是ATMS.
mService.startProcessAsync(r, knownToBeDead, isTop, isTop ? "top-activity" : "activity");
}
3.1 AMS創(chuàng)建socket去通知zygote，創(chuàng)建Launcher進(jìn)程
ActivityTaskManagerService.startProcessAsync();
// ActivityManagerInternal::startProcess，代表調(diào)用的是ActivityManagerService.startProcess()。
--> final Message m = PooledLambda.obtainMessage(ActivityManagerInternal::startProcess,
mAmInternal, activity.processName, activity.info.applicationInfo, knownToBeDead,
isTop, hostingType, activity.intent.getComponent()); @ActivityTaskManagerService
--> ActivityManagerService.startProcess()
// 只關(guān)注方法的調(diào)用，參數(shù)太多，可以不看。下面的參數(shù)都省略
--> startProcessLocked();
--> return mProcessList.startProcessLocked();
--> final Process.ProcessStartResult startResult = startProcess();@ProcessList
--> startResult = Process.start();
--> return ZYGOTE_PROCESS.start();
--> return startViaZygote();@ZygoteProcess
--> ......
// args配置的參數(shù)
argsForZygote.add("--runtime-args");
argsForZygote.add("--setuid=" + uid);
argsForZygote.add("--setgid=" + gid);
......
// openZygoteSocketIfNeeded(),打開Zygote的Socket
return zygoteSendArgsAndGetResult(openZygoteSocketIfNeeded(abi),
zygotePolicyFlags,
argsForZygote);
創(chuàng)建socket與zygote的socke連接
ZygoteProcess.openZygoteSocketIfNeeded(String abi)
// 與zygote的socke創(chuàng)建連接
--> attemptConnectionToPrimaryZygote();
--> primaryZygoteState = ZygoteState.connect(mZygoteSocketAddress, mUsapPoolSocketAddress);
socket通知zygote
ZygoteProcess.zygoteSendArgsAndGetResult()
--> return attemptZygoteSendArgsAndGetResult(zygoteState, msgStr);
// socket 操作
--> final BufferedWriter zygoteWriter = zygoteState.mZygoteOutputWriter;
final DataInputStream zygoteInputStream = zygoteState.mZygoteInputStream;
zygoteWriter.write(msgStr);
zygoteWriter.flush();
3.2 zygote收到socket通知后，創(chuàng)建Launcher進(jìn)程
還記得上面有提過(guò)在zygote進(jìn)程中有個(gè)死循環(huán)，用來(lái)接收socket消息的么？
ZygoteInit.main()
--> caller = zygoteServer.runSelectLoop(abiList);
--> ......
while (true) {
......
// 進(jìn)行等待
pollReturnValue = Os.poll(pollFDs, pollTimeoutMs);
......
// 有socket消息時(shí)，進(jìn)行處理
ZygoteConnection connection = peers.get(pollIndex);
final Runnable command = connection.processOneCommand(this);
// 創(chuàng)建pid。關(guān)注方法，參數(shù)不重要，省略
--> pid = Zygote.forkAndSpecialize();
// 反射調(diào)用ActivityThread.main()
--> return handleChildProc(parsedArgs, childPipeFd, parsedArgs.mStartChildZygote);
反射調(diào)用了ActivityThread.main()
ActivityThread.main()
--> ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
// 把應(yīng)用的句柄發(fā)給AMS,讓AMS進(jìn)行統(tǒng)一管理。句柄就是ApplicationThread,
--> mgr.attachApplication(mAppThread, startSeq);
--> attachApplicationLocked(thread, callingPid, callingUid, startSeq);@ActivityManagerService
// 關(guān)注方法，參數(shù)不重要，省略
--> thread.bindApplication();
......
didSomething = mAtmInternal.attachApplication(app.getWindowProcessController());
--> return mRootWindowContainer.attachApplication(wpc);
// RootWindowContainer::startActivityForAttachedApplicationIfNeeded
--> final PooledFunction c = PooledLambda.obtainFunction(
RootWindowContainer::startActivityForAttachedApplicationIfNeeded, this,
PooledLambda.__(ActivityRecord.class), app, stack.topRunningActivity());
// 還記得前面有區(qū)分進(jìn)程是否存在的地方嗎？不管進(jìn)程存不存在，最后啟動(dòng)activity都是調(diào)用的是StackSupervisor.realStartActivityLocked()
--> mStackSupervisor.realStartActivityLocked(r, app, top == r /*andResume*/, true /*checkConfig*/)
3.3 zygote進(jìn)程啟動(dòng)launcher進(jìn)程
ActivityStackSupervisor.realStartActivityLocked()
// 添加callBack。關(guān)注方法，參數(shù)省略。后面會(huì)用到。。。
--> clientTransaction.addCallback(LaunchActivityItem.obtain(......);
......
// ActivityTaskManagerService.getLifecycleManager() = ClientLifecycleManager
mService.getLifecycleManager().scheduleTransaction(clientTransaction);
--> transaction.schedule();
// mClient是IApplicationThread的實(shí)例，也就是ActivityThread對(duì)象。
--> mClient.scheduleTransaction(this);
// 調(diào)用ActivityThread父類ClientTransactionHandler的scheduleTransaction()方法。
--> ActivityThread.this.scheduleTransaction(transaction);@ActivityThread
// 又調(diào)用ActivityThread的sendMessage()方法，發(fā)送EXECUTE_TRANSACTION消息
--> sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
--> mH.sendMessage(msg);
接收EXECUTE_TRANSACTION消息
case EXECUTE_TRANSACTION:
final ClientTransaction transaction = (ClientTransaction) msg.obj;
mTransactionExecutor.execute(transaction);
--> executeCallbacks(transaction);@TransactionExecutor
//
--> for (int i = 0; i < size; ++i) {
final ClientTransactionItem item = callbacks.get(i);
......
// 這里的item就是上面添加的LaunchActivityItem。
item.execute(mTransactionHandler, token, mPendingActions);
--> ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo, mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState, mPendingResults, mPendingNewIntents, mIsForward, mProfilerInfo, client, mAssistToken, mFixedRotationAdjustments);
// ActivityThread.handleLaunchActivity()
client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
--> final Activity a = performLaunchActivity(r, customIntent);@ActivityThread
--> java.lang.ClassLoader cl = appContext.getClassLoader();
// 反射創(chuàng)建activity
activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent);
......
// 調(diào)用activity的oncreate方法
if (r.isPersistable()) {
mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
mInstrumentation.callActivityOnCreate(activity, r.state);
}
......
}
......
break;
經(jīng)過(guò)上面一系列調(diào)用，最終調(diào)用了mInstrumentation.callActivityOnCreate(activity, r.state)。后面的流程就和app的啟動(dòng)流程一樣了，后面一起分析。
為什么說(shuō)AMS是服務(wù)端對(duì)象呢？那就要說(shuō)到android系統(tǒng)里的服務(wù)器和客戶端的概念。
其實(shí)服務(wù)器客戶端的概念不僅僅存在于web開發(fā)中，在android的框架設(shè)計(jì)中，使用的也是這一種模式。服務(wù)器端指的就是所有app共用的系統(tǒng)服務(wù)，比如我們這里提到的ActivityManagerService，和前面提到的PackageManagerService、WindowManagerService等等，這些基礎(chǔ)的系統(tǒng)服務(wù)是被所有app共用的，當(dāng)某個(gè)app想實(shí)現(xiàn)某個(gè)操作的時(shí)候，要告訴這些系統(tǒng)服務(wù)，比如你想要打開一個(gè)app，那么我們知道了包名和MainActivity類名之后就可以打開。
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
ComponentName cn = new ComponentName(packageName, className);
intent.setComponent(cn);
startActivity(intent);
但是，我們的app通過(guò)調(diào)用startActivity()并不能直接打開另一個(gè)app，這個(gè)方法會(huì)通過(guò)一系列的調(diào)用，最后還是告訴AMS說(shuō)：我要打開這個(gè)app，我知道它的地址和名字，你幫我打開吧！所以是AMS來(lái)通知zygote進(jìn)程來(lái)fork一個(gè)新進(jìn)程，來(lái)開啟我們的目標(biāo)app的。這就像是瀏覽器想要打開一個(gè)超鏈接，瀏覽器把網(wǎng)址發(fā)送給服務(wù)器，然后由服務(wù)器把需要的資源文件發(fā)送給客戶端。
知道了Android Framework的客戶端服務(wù)器架構(gòu)后，我們還需要了解一件事，就是我們的app和AMS(SystemServer進(jìn)程)，還有zygote進(jìn)程分屬于三個(gè)獨(dú)立的進(jìn)程，那它們之間是怎么通信的呢？
app和AMS（SystemServer進(jìn)程）通過(guò) Binder 進(jìn)行IPC通信，AMS和zygote通過(guò) Socket 進(jìn)行IPC通信。
那么AMS有什么用呢？在前面我們知道了，如果想要打開一個(gè)app的話，需要AMS去通知zygote進(jìn)程，除此之外，其實(shí)所有的Activity的開啟、暫停、關(guān)閉都需要AMS來(lái)控制。所以我們說(shuō)AMS控制系統(tǒng)中所有Activity的生命周期。
在andorid系統(tǒng)中，任何一個(gè)activity的啟動(dòng)都是由AMS和應(yīng)用程序進(jìn)程（只要是ActivityThread）相互配合來(lái)完成的。AMS服務(wù)統(tǒng)一調(diào)度系統(tǒng)中所有進(jìn)程的Activity啟動(dòng)，而每個(gè)Activity的啟動(dòng)過(guò)程則由其所屬的進(jìn)程具體來(lái)完成。
后面專門介紹下AMS與ActivityThread是如何通力合作一起控制Activiy的生命周期。
