1 AMS簡介
AMS（Activity Manager Service）是Android中最核心的服務(wù)，管理著四大組件的啟動、切換、調(diào)度及應(yīng)用進(jìn)程的管理和調(diào)度等工作。AndroidQ將Activity移到了ActivityTaskManagerService中，但也和AMS相關(guān)聯(lián)。AMS通過使用一些系統(tǒng)資源和數(shù)據(jù)結(jié)構(gòu)（如進(jìn)程、任務(wù)棧、記錄四大組件生命周期的狀態(tài)機等）來管理Activity、Service、Broadcast、ContentProvider四大組件的生命周期管理。其職責(zé)與操作系統(tǒng)中的進(jìn)程管理和調(diào)度模塊相類似，因此它在Android中非常重要。
本文基于Android10（Q）的源碼做分析
2 AMS啟動流程
我們上一章節(jié)【Android Framework系列】第4章 PMS原理對PMS進(jìn)行了講解，我們知道PMS會在開機/安裝app時解析APK的AndroidManifest.xml文件，并將解析的結(jié)果緩存在PMS中。
下面同樣我們對AMS進(jìn)行分析。PMS和AMS的啟動都是在SystemServer進(jìn)程，系統(tǒng)啟動后Zygote進(jìn)程第一個fork出SystemServer進(jìn)程，進(jìn)入到SystemServer:main()->run()->startBootstrapServices() 啟動引導(dǎo)服務(wù)，進(jìn)而完成PMS和AMS等核心服務(wù)的啟動。
在Android系統(tǒng)所有的核心服務(wù)都會經(jīng)過SystemServer啟動，AMS和PMS都是一樣。SystemServer會在手機開機時啟動運行。關(guān)于SystemServer是如何啟動的可以查看文章【Android Framework系列】第3章 Zygote進(jìn)程相關(guān)和【Android車載系列】第10章 系統(tǒng)服務(wù)-SystemServer源碼分析（API28）
2.1 AMS被啟動
我們知道AMS是在SystemServer進(jìn)程中被啟動，下面我們來看看具體是怎么啟動的AMS:
/frameworks/base/services/java/com/android/server/SystemServer.java
348 public static void main(String[] args) {
349 new SystemServer().run();
350 }
......
370 private void run() {
......
507 // Start services.
508 try {
509 traceBeginAndSlog("StartServices");
// 引導(dǎo)服務(wù)
510 startBootstrapServices();
// 核心服務(wù)
511 startCoreServices();
// 其他服務(wù)
512 startOtherServices();
513 SystemServerInitThreadPool.shutdown();
514 } catch (Throwable ex) {
515 Slog.e("System", "******************************************");
516 Slog.e("System", "************ Failure starting system services", ex);
517 throw ex;
518 } finally {
519 traceEnd();
520 }
......
543 }
......
623 private void startBootstrapServices() {
......
658 ActivityTaskManagerService atm = mSystemServiceManager.startService(
659 ActivityTaskManagerService.Lifecycle.class).getService();
660 mActivityManagerService = ActivityManagerService.Lifecycle.startService(
661 mSystemServiceManager, atm);
662 mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
663 mActivityManagerService.setInstaller(installer);
664 mWindowManagerGlobalLock = atm.getGlobalLock();
......
779 mActivityManagerService.setSystemProcess();
......
818 }
......
874 /**
875 * Starts a miscellaneous grab bag of stuff that has yet to be refactored and organized.
876 */
877 private void startOtherServices() {
......
// 安裝ContentProvider
982 mActivityManagerService.installSystemProviders();
......
1023 wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
1024 new PhoneWindowManager(), mActivityManagerService.mActivityTaskManager);
1025 ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
1026 DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
1027 ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
1028 /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
// WMS與AMS/ATMS關(guān)聯(lián)起來
1032 mActivityManagerService.setWindowManager(wm);
......
// 所有的服務(wù)已經(jīng)準(zhǔn)備就緒
2035 mActivityManagerService.systemReady(() -> {
......
// 啟動階段500
2038 mSystemServiceManager.startBootPhase(
2039 SystemService.PHASE_ACTIVITY_MANAGER_READY);
......
2042 try {
// 監(jiān)測Native Crash
2043 mActivityManagerService.startObservingNativeCrashes();
2044 } catch (Throwable e) {
2045 reportWtf("observing native crashes", e);
2046 }
......
2051 final String WEBVIEW_PREPARATION = "WebViewFactoryPreparation";
2052 Future<?> webviewPrep = null;
2053 if (!mOnlyCore && mWebViewUpdateService != null) {
2054 webviewPrep = SystemServerInitThreadPool.get().submit(() -> {
2055 Slog.i(TAG, WEBVIEW_PREPARATION);
2056 TimingsTraceLog traceLog = new TimingsTraceLog(
2057 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
2058 traceLog.traceBegin(WEBVIEW_PREPARATION);
2059 ConcurrentUtils.waitForFutureNoInterrupt(mZygotePreload, "Zygote preload");
2060 mZygotePreload = null;
// 啟動WebView相關(guān)
2061 mWebViewUpdateService.prepareWebViewInSystemServer();
2062 traceLog.traceEnd();
2063 }, WEBVIEW_PREPARATION);
2064 }
......
2073 try {
// 啟動SystemUi
2074 startSystemUi(context, windowManagerF);
2075 } catch (Throwable e) {
2076 reportWtf("starting System UI", e);
2077 }
......
// 啟動階段600
2154 mSystemServiceManager.startBootPhase(
2155 SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
......
2249 }, BOOT_TIMINGS_TRACE_LOG);
2250 }
SystemServer將AMS啟動并初始化主要兩大階段：
第一階段：startBootstrapServices()方法中啟動引導(dǎo)服務(wù)：
- 創(chuàng)建
ActivityTaskManagerService(ATMS)對象，用于管理Activity - 創(chuàng)建
AMS對象，并啟動服務(wù) - 將
AMS所在的系統(tǒng)進(jìn)程SystemServer，納入到AMS的進(jìn)程管理體系中setSystemProcess()：將framewok-res.apk信息加入到SystemServer進(jìn)程的LoadedApk中，構(gòu)建SystemServe進(jìn)程的ProcessRecord，保存到AMS中，以便AMS進(jìn)程統(tǒng)一管理
第二階段：startOtherServices()方法中啟動其他服務(wù)：
- 為系統(tǒng)進(jìn)程安裝ContentProvider對象
installSystemProviders()：安裝SystemServer進(jìn)程中的SettingsProvider.apk， - 初始化WMS，并關(guān)聯(lián)AMS及ATMS兩個服務(wù)。
setWindowManager()方法將AMS與WMS關(guān)聯(lián)起來，通過ATMS來管理Activity - AMS啟動完成，通知服務(wù)或應(yīng)用完成后續(xù)工作，或直接啟動新進(jìn)程。
AMS.systemReady()：許多服務(wù)或應(yīng)用進(jìn)程必須等待AMS完成啟動工作后，才能啟動或進(jìn)行一些后續(xù)工作，AMS就是在SystemReady()中，通知或啟動這些等待的服務(wù)和應(yīng)用進(jìn)程，例如啟動桌面等。
我們看到在第一階段中，對AMS和ATMS進(jìn)行創(chuàng)建時都是調(diào)用的startService()方法。其中AMS創(chuàng)建調(diào)用ActivityManagerService.Lifecycle.startService()，而ATMS創(chuàng)建是mSystemServiceManager.startService()實際上mSystemServiceManager內(nèi)部也是調(diào)用的ActivityManagerService.Lifecycle.startService()對服務(wù)進(jìn)行創(chuàng)建。下面我們通過AMS的Lifecycle來看看AMS的初始化。
2.2 AMS初始化
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
......
2209 public static final class Lifecycle extends SystemService {
2210 private final ActivityManagerService mService;
2211 private static ActivityTaskManagerService sAtm;
2212
2213 public Lifecycle(Context context) {
2214 super(context);
2215 mService = new ActivityManagerService(context, sAtm);
2216 }
2217
2218 public static ActivityManagerService startService(
2219 SystemServiceManager ssm, ActivityTaskManagerService atm) {
2220 sAtm = atm;
2221 return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
2222 }
2223
2224 @Override
2225 public void onStart() {
2226 mService.start();
2227 }
2228
2229 @Override
2230 public void onBootPhase(int phase) {
2231 mService.mBootPhase = phase;
2232 if (phase == PHASE_SYSTEM_SERVICES_READY) {
2233 mService.mBatteryStatsService.systemServicesReady();
2234 mService.mServices.systemServicesReady();
2235 } else if (phase == PHASE_ACTIVITY_MANAGER_READY) {
2236 mService.startBroadcastObservers();
2237 } else if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) {
2238 mService.mPackageWatchdog.onPackagesReady();
2239 }
2240 }
2241
2242 @Override
2243 public void onCleanupUser(int userId) {
2244 mService.mBatteryStatsService.onCleanupUser(userId);
2245 }
2246
2247 public ActivityManagerService getService() {
2248 return mService;
2249 }
2250 }
......
ATMS(ActivityTaskManagerService)是Android 10新引入的變化，也是系統(tǒng)服務(wù)，用來管理Activity啟動和調(diào)度，包括其容器(task、stacks、displays等)。這篇主要關(guān)于AMS的啟動，因此ActivityTaskManagerService這里不贅述。
Android 10將原先AMS中對activity的管理和調(diào)度移到了ATMS中，位置放到了frameworks/base/services/core/java/com/android/server/wm/下，因此AMS負(fù)責(zé)四大組件中另外3個(service, broadcast, contentprovider)的管理和調(diào)度。
這里的Lifecycle是AMS的內(nèi)部類。ActivityManagerService.Lifecycle.startService()最終返回的是mService，即創(chuàng)建的AMS對象，上面我們也知道ATMS最終也是通過這種方式創(chuàng)建。
AMS 創(chuàng)建流程簡述：
1.SystemServer：依次調(diào)用main()、run()、startBootstrapServices()，再調(diào)用Lifecyle的startService()方法；
2.Lifecyle：startService()方法中調(diào)用SystemServiceManager的startService()方法，并將Lifecyle.class傳入；
3.SystemServiceManager：startService()方法通過反射調(diào)用Lifecyle的構(gòu)造方法，生成Lifecyle對象；
4.Lifecyle：構(gòu)造方法中調(diào)用AMS的構(gòu)造方法創(chuàng)建AMS對象，并通過getService()方法返回AMS對象。
下面我們繼續(xù)看看AMS的構(gòu)造函數(shù)：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
......
2435 public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
2436 LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
2437 mInjector = new Injector();
// 系統(tǒng)上下文，是在SystemServer進(jìn)程fork出來后通過createSystemContext()創(chuàng)建的，即與SystemServer進(jìn)程是一一致
2438 mContext = systemContext;
2439
2440 mFactoryTest = FactoryTest.getMode();
// 系統(tǒng)進(jìn)程的主線程 sCurrentActivityThread，這里是systemMain()中創(chuàng)建的ActivityThread對象。即也與SystemServer一樣的。
2441 mSystemThread = ActivityThread.currentActivityThread();
2442 mUiContext = mSystemThread.getSystemUiContext();
2443
2444 Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
2445
2446 mHandlerThread = new ServiceThread(TAG,
2447 THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
2448 mHandlerThread.start();
// 處理AMS消息的handler
2449 mHandler = new MainHandler(mHandlerThread.getLooper());
// UiHandler對應(yīng)于Android中的Ui線程
2450 mUiHandler = mInjector.getUiHandler(this);
2451
2452 mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
2453 THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
2454 mProcStartHandlerThread.start();
2455 mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
2456
2457 mConstants = new ActivityManagerConstants(mContext, this, mHandler);
2458 final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
2459 mProcessList.init(this, activeUids);
2460 mLowMemDetector = new LowMemDetector(this);
2461 mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
2462
2463 // Broadcast policy parameters
2464 final BroadcastConstants foreConstants = new BroadcastConstants(
2465 Settings.Global.BROADCAST_FG_CONSTANTS);
2466 foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
2467
2468 final BroadcastConstants backConstants = new BroadcastConstants(
2469 Settings.Global.BROADCAST_BG_CONSTANTS);
2470 backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
2471
2472 final BroadcastConstants offloadConstants = new BroadcastConstants(
2473 Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
2474 offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
2475 // by default, no "slow" policy in this queue
2476 offloadConstants.SLOW_TIME = Integer.MAX_VALUE;
2477
2478 mEnableOffloadQueue = SystemProperties.getBoolean(
2479 "persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);
2480
//創(chuàng)建幾種廣播相關(guān)對象，前臺廣播、后臺廣播、offload。
2481 mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
2482 "foreground", foreConstants, false);
2483 mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
2484 "background", backConstants, true);
2485 mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
2486 "offload", offloadConstants, true);
2487 mBroadcastQueues[0] = mFgBroadcastQueue;
2488 mBroadcastQueues[1] = mBgBroadcastQueue;
2489 mBroadcastQueues[2] = mOffloadBroadcastQueue;
2490
// 創(chuàng)建ActiveServices對象，管理 ServiceRecord
2491 mServices = new ActiveServices(this);
// 創(chuàng)建ProviderMap對象，管理ContentProviderRecord
2492 mProviderMap = new ProviderMap(this);
2493 mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
2494 mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
2495
2496 final File systemDir = SystemServiceManager.ensureSystemDir();
2497
2498 // TODO: Move creation of battery stats service outside of activity manager service.
2499 mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
2500 BackgroundThread.get().getHandler());
2501 mBatteryStatsService.getActiveStatistics().readLocked();
2502 mBatteryStatsService.scheduleWriteToDisk();
2503 mOnBattery = DEBUG_POWER ? true
2504 : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
2505 mBatteryStatsService.getActiveStatistics().setCallback(this);
2506 mOomAdjProfiler.batteryPowerChanged(mOnBattery);
2507
2508 mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
2509
2510 mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
2511
2512 mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
2513
2514 mUserController = new UserController(this);
2515
2516 mPendingIntentController = new PendingIntentController(
2517 mHandlerThread.getLooper(), mUserController);
2518
2519 if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
2520 mUseFifoUiScheduling = true;
2521 }
2522
2523 mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
2524 mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
2525
//得到ActivityTaskManagerService的對象，調(diào)用ATM.initialize
2526 mActivityTaskManager = atm;
2527 mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
2528 DisplayThread.get().getLooper());
2529 mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
2530
2531 mProcessCpuThread = new Thread("CpuTracker") {
2532 @Override
2533 public void run() {
2534 synchronized (mProcessCpuTracker) {
2535 mProcessCpuInitLatch.countDown();
2536 mProcessCpuTracker.init();
2537 }
2538 while (true) {
2539 try {
2540 try {
2541 synchronized(this) {
2542 final long now = SystemClock.uptimeMillis();
2543 long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
2544 long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
2545 //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
2546 // + ", write delay=" + nextWriteDelay);
2547 if (nextWriteDelay < nextCpuDelay) {
2548 nextCpuDelay = nextWriteDelay;
2549 }
2550 if (nextCpuDelay > 0) {
2551 mProcessCpuMutexFree.set(true);
2552 this.wait(nextCpuDelay);
2553 }
2554 }
2555 } catch (InterruptedException e) {
2556 }
2557 updateCpuStatsNow();
2558 } catch (Exception e) {
2559 Slog.e(TAG, "Unexpected exception collecting process stats", e);
2560 }
2561 }
2562 }
2563 };
2564
2565 mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
2566
2567 Watchdog.getInstance().addMonitor(this);
2568 Watchdog.getInstance().addThread(mHandler);
2569
2570 // bind background threads to little cores
2571 // this is expected to fail inside of framework tests because apps can't touch cpusets directly
2572 // make sure we've already adjusted system_server's internal view of itself first
2573 updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
2574 try {
2575 Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
2576 Process.THREAD_GROUP_SYSTEM);
2577 Process.setThreadGroupAndCpuset(
2578 mOomAdjuster.mAppCompact.mCompactionThread.getThreadId(),
2579 Process.THREAD_GROUP_SYSTEM);
2580 } catch (Exception e) {
2581 Slog.w(TAG, "Setting background thread cpuset failed");
2582 }
2583
2584 }
AMS的構(gòu)造方法主要是在做一些初始化的先關(guān)操作:
- 保存了自己的運行環(huán)境的
Context和ActivityThread -
AMS負(fù)責(zé)調(diào)度四大組件，初始化broadcast,service和contentProvider相關(guān)的變量，負(fù)責(zé)三大大組件的(service、broadcast、provider)管理和調(diào)度(activity移到了ActivityTaskManagerService中，但此處也綁定了ActivityTaskManagerService對象)， - 接著初始化了
電量統(tǒng)計服務(wù)，監(jiān)控內(nèi)存、電池、權(quán)限(可以了解下appops.xml)以及性能相關(guān)的對象或變量。mLowMemDetector、mBatteryStatsService、mProcessStats、mAppOpsService、mProcessCpuThread等。創(chuàng)建了系統(tǒng)的第一個用戶，初始化了基本的配置信息 - 創(chuàng)建了Activity調(diào)度的核心類，因為Activity調(diào)度比較復(fù)雜，Activity相關(guān)的信息初始化會在
ActivityStackSupervisor中
下面我們繼續(xù)看一下ActivityManagerService的start()方法：
2.2.1 ActivityManagerService的start()
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
2594 private void start() {
// 移除所有的進(jìn)程組
2595 removeAllProcessGroups();
// 啟動CPU進(jìn)程
2596 mProcessCpuThread.start();
2597
// 啟動電池狀態(tài)服務(wù)
2598 mBatteryStatsService.publish();
2599 mAppOpsService.publish(mContext);
2600 Slog.d("AppOps", "AppOpsService published");
2601 LocalServices.addService(ActivityManagerInternal.class, new LocalService());
// 創(chuàng)建本地服務(wù)并注冊，將創(chuàng)建的本地服務(wù)放入本地服務(wù)集合完成注冊
2602 mActivityTaskManager.onActivityManagerInternalAdded();
2603 mUgmInternal.onActivityManagerInternalAdded();
2604 mPendingIntentController.onActivityManagerInternalAdded();
2605 // Wait for the synchronized block started in mProcessCpuThread,
2606 // so that any other access to mProcessCpuTracker from main thread
2607 // will be blocked during mProcessCpuTracker initialization.
2608 try {
// 等待mProcessCpuThread完成初始化后，釋放鎖
2609 mProcessCpuInitLatch.await();
2610 } catch (InterruptedException e) {
2611 Slog.wtf(TAG, "Interrupted wait during start", e);
2612 Thread.currentThread().interrupt();
2613 throw new IllegalStateException("Interrupted wait during start");
2614 }
2615 }
AMS的start()方法很簡單，只是啟動了幾個服務(wù)，并把AMS服務(wù)自己保存到localService中供程序內(nèi)部調(diào)用;AMS的構(gòu)造方法和start()方法中做了AMS服務(wù)一些變量的初始化和相關(guān)服務(wù)的初始化。
接著看下一個重要的方法setSystemProcess：
2.2.2 ActivityManagerService的setSystemProcess()方法
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
2040 public void setSystemProcess() {
2041 try {
// 將AMS注冊到ServiceManager中
2042 ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
2043 DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
// 注冊進(jìn)程狀態(tài)服務(wù)
2044 ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
// 注冊內(nèi)存Binder
2045 ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
2046 DUMP_FLAG_PRIORITY_HIGH);
// 注冊圖像信息Binder
2047 ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
// 注冊數(shù)據(jù)庫Binder
2048 ServiceManager.addService("dbinfo", new DbBinder(this));
2049 if (MONITOR_CPU_USAGE) {
// 注冊監(jiān)控CPU使用狀態(tài)Binder
2050 ServiceManager.addService("cpuinfo", new CpuBinder(this),
2051 /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
2052 }
// 注冊權(quán)限控制Binder
2053 ServiceManager.addService("permission", new PermissionController(this));
// 注冊進(jìn)程服務(wù)Binder
2054 ServiceManager.addService("processinfo", new ProcessInfoService(this));
2055
// 查詢并處理ApplicationInfo
2056 ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
2057 "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
// 將Application信息配置到ActivityThread中
2058 mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
2059
2060 synchronized (this) {
// 創(chuàng)建并處理ProcessRecord
2061 ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
2062 false,
2063 0,
2064 new HostingRecord("system"));
2065 app.setPersistent(true);
2066 app.pid = MY_PID;
2067 app.getWindowProcessController().setPid(MY_PID);
2068 app.maxAdj = ProcessList.SYSTEM_ADJ;
2069 app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
2070 mPidsSelfLocked.put(app);
2071 mProcessList.updateLruProcessLocked(app, false, null);
2072 updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
2073 }
2074 } catch (PackageManager.NameNotFoundException e) {
2075 throw new RuntimeException(
2076 "Unable to find android system package", e);
2077 }
2078
2079 // Start watching app ops after we and the package manager are up and running.
2080 mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
2081 new IAppOpsCallback.Stub() {
2082 @Override public void opChanged(int op, int uid, String packageName) {
2083 if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
2084 if (mAppOpsService.checkOperation(op, uid, packageName)
2085 != AppOpsManager.MODE_ALLOWED) {
2086 runInBackgroundDisabled(uid);
2087 }
2088 }
2089 }
2090 });
2091 }
-
setSystemProcess()方法中，首先將自己AMS服務(wù)注冊到了ServiceManager中，然后又注冊了權(quán)限服務(wù)等其他的系統(tǒng)服務(wù); - 通過先前創(chuàng)建的Context，得到
PMS服務(wù)，檢索framework-res的Application信息，然后將它配置到系統(tǒng)的ActivityThread中; - 為了能讓
AMS同樣可以管理調(diào)度系統(tǒng)進(jìn)程，也創(chuàng)建了一個關(guān)于系統(tǒng)進(jìn)程的ProcessRecord對象，ProcessRecord對象保存一個進(jìn)程的相關(guān)信息; - 然后將它保存到
mPidsSelfLocked集合中方便管理; -
AMS具體是如何將檢索到的framework-res的application信息，配置到ActivityThread中的，需要繼續(xù)分析ActivityThread的installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader))方法;
我們繼續(xù)往下看ActivityThread類中的installSystemApplicationInfo()方法：
2.2.3 ActivityThread的installSystemApplicationInfo
/frameworks/base/core/java/android/app/ActivityThread.java
2417 public void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
2418 synchronized (this) {
2419 getSystemContext().installSystemApplicationInfo(info, classLoader);
2420 getSystemUiContext().installSystemApplicationInfo(info, classLoader);
2421
2422 // give ourselves a default profiler
2423 mProfiler = new Profiler();
2424 }
2425 }
這個方法中最終調(diào)用上面創(chuàng)建的SystemContext和SystemUiContext的installSystemApplicationInfo()方法。
那就接著看ConxtextImpl的installSystemApplicationInfo()方法：
/frameworks/base/core/java/android/app/ContextImpl.java
......
2427 /**
2428 * System Context to be used for UI. This Context has resources that can be themed.
2429 * Make sure that the created system UI context shares the same LoadedApk as the system context.
2430 * @param systemContext The system context which created by
2431 * {@link #createSystemContext(ActivityThread)}.
2432 * @param displayId The ID of the display where the UI is shown.
2433 */
2434 static ContextImpl createSystemUiContext(ContextImpl systemContext, int displayId) {
2435 final LoadedApk packageInfo = systemContext.mPackageInfo;
2436 ContextImpl context = new ContextImpl(null, systemContext.mMainThread, packageInfo, null,
2437 null, null, 0, null, null);
2438 context.setResources(createResources(null, packageInfo, null, displayId, null,
2439 packageInfo.getCompatibilityInfo()));
2440 context.updateDisplay(displayId);
2441 return context;
2442 }
2443
2444 /**
2445 * The overloaded method of {@link #createSystemUiContext(ContextImpl, int)}.
2446 * Uses {@Code Display.DEFAULT_DISPLAY} as the target display.
2447 */
2448 static ContextImpl createSystemUiContext(ContextImpl systemContext) {
2449 return createSystemUiContext(systemContext, Display.DEFAULT_DISPLAY);
2450 }
......
2581 void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
2582 mPackageInfo.installSystemApplicationInfo(info, classLoader);
2583 }
......
它有最終調(diào)用了mPackageInfo的installSystemApplication()方法：
/frameworks/base/core/java/android/app/LoadedApk.java
240 /**
241 * Sets application info about the system package.
242 */
243 void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
244 assert info.packageName.equals("android");
245 mApplicationInfo = info;
246 mDefaultClassLoader = classLoader;
247 mAppComponentFactory = createAppFactory(info, mDefaultClassLoader);
248 mClassLoader = mAppComponentFactory.instantiateClassLoader(mDefaultClassLoader,
249 new ApplicationInfo(mApplicationInfo));
250 }
mPackageInfo就是在創(chuàng)建Context對象的時候傳進(jìn)來的LoadedApk，里面保存了一個應(yīng)用程序的基本信息;setSystemProcess()主要就是設(shè)置系統(tǒng)集成的一些信息，在這里設(shè)置了系統(tǒng)進(jìn)程的Application信息，創(chuàng)建了系統(tǒng)進(jìn)程的ProcessRecord對象將其保存在進(jìn)程集合中，方便AMS管理調(diào)度;
到這里，我們第一階段startBootstrapServices()方法中啟動引導(dǎo)服務(wù)里對AMS做了初始化已經(jīng)結(jié)束，下面我繼續(xù)看第二階段startOtherServices()方法中啟動其他服務(wù)中對AMS的初始化。
我們從上面可以看到startOtherServices()方法中調(diào)用了AMS的installSystemProviders()方法，我們來卡一下這個方法做了什么：
2.2.4 ActivityManagerService的installSystemProviders
ActivityManagerService的installSystemProviders()方法;
Android系統(tǒng)中有很多配置信息都需要保存，這些信息是保存在SettingsProvider中，而這個SettingsProvider也是運行在SystemServer進(jìn)程中的，由于SystemServer進(jìn)程依賴SettingsProvider，放在一個進(jìn)程中可以減少進(jìn)程間通信的效率損失;
下面就來分析下如何將SettingsProvider.apk也加載到SystemServer進(jìn)程中;
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
7543 public final void installSystemProviders() {
7544 List<ProviderInfo> providers;
7545 synchronized (this) {
// 找到名為"system"的進(jìn)程，就是setSystemProcess中創(chuàng)建的ProcessRecord對象
7546 ProcessRecord app = mProcessList.mProcessNames.get("system", SYSTEM_UID);
7547 providers = generateApplicationProvidersLocked(app);
7548 if (providers != null) {
7549 for (int i=providers.size()-1; i>=0; i--) {
7550 ProviderInfo pi = (ProviderInfo)providers.get(i);
7551 if ((pi.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) == 0) {
7552 Slog.w(TAG, "Not installing system proc provider " + pi.name
7553 + ": not system .apk");
// 移除非系統(tǒng)provider
7554 providers.remove(i);
7555 }
7556 }
7557 }
7558 }
7559 if (providers != null) {
// 安裝所有的系統(tǒng)provider
7560 mSystemThread.installSystemProviders(providers);
7561 }
7562
7563 synchronized (this) {
7564 mSystemProvidersInstalled = true;
7565 }
7566 mConstants.start(mContext.getContentResolver());
// 創(chuàng)建核心Settings Observer，用于監(jiān)聽Settings的改變
7567 mCoreSettingsObserver = new CoreSettingsObserver(this);
7568 mActivityTaskManager.installSystemProviders();
// 開發(fā)者權(quán)限
7569 mDevelopmentSettingsObserver = new DevelopmentSettingsObserver();
7570 SettingsToPropertiesMapper.start(mContext.getContentResolver());
7571 mOomAdjuster.initSettings();
7572
7573 // Now that the settings provider is published we can consider sending
7574 // in a rescue party.
7575 RescueParty.onSettingsProviderPublished(mContext);
7576
7577 //mUsageStatsService.monitorPackages();
7578 }
找到名稱為system的進(jìn)程對象，就是SystemServer進(jìn)程，然后根據(jù)進(jìn)程對象去查詢所有有關(guān)的ContentProvider，調(diào)用系統(tǒng)進(jìn)程的主線程ActivityThread安裝所有相關(guān)的ContentProvider,具體是如何查找相關(guān)的ContentProvider和如何安裝ContentProvider到系統(tǒng)主線程。
generateApplicationProvidersLocked()函數(shù)：返回一個ProviderInfo List。installSystemProviders()函數(shù)：ActivityThread可以看做是進(jìn)程的Android運行環(huán)境，那么該方法表示為該進(jìn)程安裝ContentProvider。
接著分析下面兩個方法;
2.2.5 ActivityManagerService的generateApplicationProvidersLocked()
首先來看generateApplicationProvidersLocked()方法：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
......
6409 private final List<ProviderInfo> generateApplicationProvidersLocked(ProcessRecord app) {
6410 List<ProviderInfo> providers = null;
6411 try {
// 向PMS查詢滿足要求的ProviderInfo，最重要的查詢條件包括：進(jìn)程名和進(jìn)程uid
6412 providers = AppGlobals.getPackageManager()
6413 .queryContentProviders(app.processName, app.uid,
6414 STOCK_PM_FLAGS | PackageManager.GET_URI_PERMISSION_PATTERNS
6415 | MATCH_DEBUG_TRIAGED_MISSING, /*metadastaKey=*/ null)
6416 .getList();
6417 } catch (RemoteException ex) {
6418 }
6419 if (DEBUG_MU) Slog.v(TAG_MU,
6420 "generateApplicationProvidersLocked, app.info.uid = " + app.uid);
6421 int userId = app.userId;
6422 if (providers != null) {
6423 int N = providers.size();
6424 app.pubProviders.ensureCapacity(N + app.pubProviders.size());
6425 for (int i=0; i<N; i++) {
......
// AMS對ContentProvider的管理
6427 ProviderInfo cpi =
6428 (ProviderInfo)providers.get(i);
6429 boolean singleton = isSingleton(cpi.processName, cpi.applicationInfo,
6430 cpi.name, cpi.flags);
6431 if (singleton && UserHandle.getUserId(app.uid) != UserHandle.USER_SYSTEM) {
6432 // This is a singleton provider, but a user besides the
6433 // default user is asking to initialize a process it runs
6434 // in... well, no, it doesn't actually run in this process,
6435 // it runs in the process of the default user. Get rid of it.
6436 providers.remove(i);
6437 N--;
6438 i--;
6439 continue;
6440 }
6441
6442 ComponentName comp = new ComponentName(cpi.packageName, cpi.name);
6443 ContentProviderRecord cpr = mProviderMap.getProviderByClass(comp, userId);
6444 if (cpr == null) {
// ContentProvider在AMS中用ContentProviderRecord來表示
6445 cpr = new ContentProviderRecord(this, cpi, app.info, comp, singleton);
// 保存到AMS的mProvidersByClass中
6446 mProviderMap.putProviderByClass(comp, cpr);
6447 }
6448 if (DEBUG_MU) Slog.v(TAG_MU,
6449 "generateApplicationProvidersLocked, cpi.uid = " + cpr.uid);
// 將信息也保存到ProcessRecord中
6450 app.pubProviders.put(cpi.name, cpr);
6451 if (!cpi.multiprocess || !"android".equals(cpi.packageName)) {
......
// 保存PackageName到ProcessRecord中
6456 app.addPackage(cpi.applicationInfo.packageName,
6457 cpi.applicationInfo.longVersionCode, mProcessStats);
6458 }
6459 notifyPackageUse(cpi.applicationInfo.packageName,
6460 PackageManager.NOTIFY_PACKAGE_USE_CONTENT_PROVIDER);
6461 }
6462 }
6463 return providers;
6464 }
- 這個方法就是從
PMS中查詢和SystemServer進(jìn)程相關(guān)的Provider，也就是SettingsProvder，然后將它保存到AMS的ContentProvider列表中; - 同時也將它保存到系統(tǒng)進(jìn)程對象
ProcessRecord的變量pubProviders列表中，保存到AMS的provider列表中是因為AMS需要管理所有的ContentProvder; - 保存到進(jìn)程對象的
pubProviders列表中是因為，每個ContentProvider都需要對應(yīng)到一個進(jìn)程中去;
2.2.6 ActivityThread的installSystemProviders()
接著看如何將SettingsProvider安裝到系統(tǒng)的主進(jìn)程中去：
/frameworks/base/core/java/android/app/ActivityThread.java
......
6515 private void installContentProviders(
6516 Context context, List<ProviderInfo> providers) {
6517 final ArrayList<ContentProviderHolder> results = new ArrayList<>();
6518
6519 for (ProviderInfo cpi : providers) {
6520 if (DEBUG_PROVIDER) {
6521 StringBuilder buf = new StringBuilder(128);
6522 buf.append("Pub ");
6523 buf.append(cpi.authority);
6524 buf.append(": ");
6525 buf.append(cpi.name);
6526 Log.i(TAG, buf.toString());
6527 }
// 調(diào)用installProvider函數(shù)，得到一個ContentProviderHolder對象
6528 ContentProviderHolder cph = installProvider(context, null, cpi,
6529 false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
6530 if (cph != null) {
6531 cph.noReleaseNeeded = true;
// 將返回的cph保存到results數(shù)組中
6532 results.add(cph);
6533 }
6534 }
6535
6536 try {
// 調(diào)用AMS的publishContentProviders注冊這些ContentProvider
6537 ActivityManager.getService().publishContentProviders(
6538 getApplicationThread(), results);
6539 } catch (RemoteException ex) {
6540 throw ex.rethrowFromSystemServer();
6541 }
6542 }
......
7167 public final void installSystemProviders(List<ProviderInfo> providers) {
7168 if (providers != null) {
7169 installContentProviders(mInitialApplication, providers);
7170 }
7171 }
- 該方法將得到的
ContentProvder對象封裝成了contentProviderHolder對象，其實就是Binder對象，這樣就可以進(jìn)程間傳輸了，然后跨進(jìn)程調(diào)用AMS服務(wù)注冊Provider; -
AMS負(fù)責(zé)管理ContentProvider，只有將ContentProvider注冊到AMS服務(wù)其他進(jìn)程才能訪問;
接著看AMS如何注冊Provider：
2.2.7 ActivityManagerService的publishContentProviders()注冊Provider
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
7342
7343 public final void publishContentProviders(IApplicationThread caller,
7344 List<ContentProviderHolder> providers) {
7345 if (providers == null) {
7346 return;
7347 }
7348
7349 enforceNotIsolatedCaller("publishContentProviders");
7350 synchronized (this) {
7351 final ProcessRecord r = getRecordForAppLocked(caller);
7352 if (DEBUG_MU) Slog.v(TAG_MU, "ProcessRecord uid = " + r.uid);
7353 if (r == null) {
7354 throw new SecurityException(
7355 "Unable to find app for caller " + caller
7356 + " (pid=" + Binder.getCallingPid()
7357 + ") when publishing content providers");
7358 }
7359
7360 final long origId = Binder.clearCallingIdentity();
7361
7362 final int N = providers.size();
7363 for (int i = 0; i < N; i++) {
7364 ContentProviderHolder src = providers.get(i);
7365 if (src == null || src.info == null || src.provider == null) {
7366 continue;
7367 }
7368 ContentProviderRecord dst = r.pubProviders.get(src.info.name);
7369 if (DEBUG_MU) Slog.v(TAG_MU, "ContentProviderRecord uid = " + dst.uid);
7370 if (dst != null) {
7371 ComponentName comp = new ComponentName(dst.info.packageName, dst.info.name);
7372 mProviderMap.putProviderByClass(comp, dst);
7373 String names[] = dst.info.authority.split(";");
7374 for (int j = 0; j < names.length; j++) {
7375 mProviderMap.putProviderByName(names[j], dst);
7376 }
7377
7378 int launchingCount = mLaunchingProviders.size();
7379 int j;
7380 boolean wasInLaunchingProviders = false;
7381 for (j = 0; j < launchingCount; j++) {
7382 if (mLaunchingProviders.get(j) == dst) {
7383 mLaunchingProviders.remove(j);
7384 wasInLaunchingProviders = true;
7385 j--;
7386 launchingCount--;
7387 }
7388 }
7389 if (wasInLaunchingProviders) {
7390 mHandler.removeMessages(CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG, r);
7391 }
7392 // Make sure the package is associated with the process.
7393 // XXX We shouldn't need to do this, since we have added the package
7394 // when we generated the providers in generateApplicationProvidersLocked().
7395 // But for some reason in some cases we get here with the package no longer
7396 // added... for now just patch it in to make things happy.
7397 r.addPackage(dst.info.applicationInfo.packageName,
7398 dst.info.applicationInfo.longVersionCode, mProcessStats);
7399 synchronized (dst) {
7400 dst.provider = src.provider;
7401 dst.setProcess(r);
7402 dst.notifyAll();
7403 }
7404 updateOomAdjLocked(r, true, OomAdjuster.OOM_ADJ_REASON_GET_PROVIDER);
7405 maybeUpdateProviderUsageStatsLocked(r, src.info.packageName,
7406 src.info.authority);
7407 }
7408 }
7409
7410 Binder.restoreCallingIdentity(origId);
7411 }
7412 }
-
AMS的注冊服務(wù)就是根據(jù)參數(shù)傳過來的provider信息，找到原先進(jìn)程中pubProviders列表中保存的ContentProviderRecord，然后將它分別以類為key保存在mProviderMap中，和以authority為key保存在mProviderMap中 - 即
AMS提供了多種方案來查找一個ContentProvider，一種是通過authority來查找，一種是指明CompomentName來查找 - 此刻位置一個
SettingsProvider就正式注冊到SystemServer進(jìn)程中了，所以可以看出installSystemProvider方法的主要工作就是按照普通進(jìn)程類似的方式，將SettingsProvider注冊到系統(tǒng)進(jìn)程中，方便系統(tǒng)進(jìn)程對settings的配置數(shù)據(jù)進(jìn)行調(diào)用
我們繼續(xù)看第二階段startOtherServices()方法往下走，有一個非常關(guān)鍵的方法systemReady()
2.2.8 ActivityManagerService的systemReady
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
8967
8968 public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
8969 traceLog.traceBegin("PhaseActivityManagerReady");
8970 synchronized(this) {
// 第一次進(jìn)入mSystemReady為false
8971 if (mSystemReady) {
8972 // If we're done calling all the receivers, run the next "boot phase" passed in
8973 // by the SystemServer
8974 if (goingCallback != null) {
8975 goingCallback.run();
8976 }
8977 return;
8978 }
8979
// 關(guān)鍵服務(wù)等待systemReady，繼續(xù)完成一些初始化或進(jìn)一步的工作
8980 mLocalDeviceIdleController
8981 = LocalServices.getService(DeviceIdleController.LocalService.class);
// 調(diào)用各種服務(wù)的Ready方法
8982 mActivityTaskManager.onSystemReady();
8983 // Make sure we have the current profile info, since it is needed for security checks.
8984 mUserController.onSystemReady();
8985 mAppOpsService.systemReady();
8986 mSystemReady = true;
8987 }
8988
8989 try {
//獲取設(shè)備識別字符串
8990 sTheRealBuildSerial = IDeviceIdentifiersPolicyService.Stub.asInterface(
8991 ServiceManager.getService(Context.DEVICE_IDENTIFIERS_SERVICE))
8992 .getSerial();
8993 } catch (RemoteException e) {}
8994
// 收集目前已經(jīng)存在的進(jìn)程（mPidsSelfLocked中保留了當(dāng)前正在運行的所有進(jìn)程信息）
8995 ArrayList<ProcessRecord> procsToKill = null;
8996 synchronized(mPidsSelfLocked) {
8997 for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
8998 ProcessRecord proc = mPidsSelfLocked.valueAt(i);
// 已啟動的進(jìn)程，若進(jìn)程沒有FLAG_PERSISTENT標(biāo)志，則會被加入到procsToKill中
8999 if (!isAllowedWhileBooting(proc.info)){
9000 if (procsToKill == null) {
9001 procsToKill = new ArrayList<ProcessRecord>();
9002 }
9003 procsToKill.add(proc);
9004 }
9005 }
9006 }
9007
// 銷毀在AMS啟動之前存在的進(jìn)程（關(guān)閉procsToKill中的所有進(jìn)程）
9008 synchronized(this) {
9009 if (procsToKill != null) {
9010 for (int i=procsToKill.size()-1; i>=0; i--) {
9011 ProcessRecord proc = procsToKill.get(i);
9012 Slog.i(TAG, "Removing system update proc: " + proc);
9013 mProcessList.removeProcessLocked(proc, true, false, "system update done");
9014 }
9015 }
9016
9017 // Now that we have cleaned up any update processes, we
9018 // are ready to start launching real processes and know that
9019 // we won't trample on them any more.
// 到這里系統(tǒng)準(zhǔn)備完畢
9020 mProcessesReady = true;
9021 }
9022
9023 Slog.i(TAG, "System now ready");
9024 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_AMS_READY, SystemClock.uptimeMillis());
9025
9026 mAtmInternal.updateTopComponentForFactoryTest();
9027 mAtmInternal.getLaunchObserverRegistry().registerLaunchObserver(mActivityLaunchObserver);
9028
9029 watchDeviceProvisioning(mContext);
9030
// 初始化Settings變量
9031 retrieveSettings();
9032 mUgmInternal.onSystemReady();
9033
9034 final PowerManagerInternal pmi = LocalServices.getService(PowerManagerInternal.class);
9035 if (pmi != null) {
9036 pmi.registerLowPowerModeObserver(ServiceType.FORCE_BACKGROUND_CHECK,
9037 state -> updateForceBackgroundCheck(state.batterySaverEnabled));
9038 updateForceBackgroundCheck(
9039 pmi.getLowPowerState(ServiceType.FORCE_BACKGROUND_CHECK).batterySaverEnabled);
9040 } else {
9041 Slog.wtf(TAG, "PowerManagerInternal not found.");
9042 }
9043
// 運行g(shù)oingCallback，SystemServer調(diào)用時傳入的
9044 if (goingCallback != null) goingCallback.run();
9045 // Check the current user here as a user can be started inside goingCallback.run() from
9046 // other system services.
9047 final int currentUserId = mUserController.getCurrentUserId();
9048 Slog.i(TAG, "Current user:" + currentUserId);
// 獲取UserId
9049 if (currentUserId != UserHandle.USER_SYSTEM && !mUserController.isSystemUserStarted()) {
9050 // User other than system user has started. Make sure that system user is already
9051 // started before switching user.
9052 throw new RuntimeException("System user not started while current user is:"
9053 + currentUserId);
9054 }
9055 traceLog.traceBegin("ActivityManagerStartApps");
// 給BatteryStatsService發(fā)送狀態(tài)
9056 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START,
9057 Integer.toString(currentUserId), currentUserId);
9058 mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START,
9059 Integer.toString(currentUserId), currentUserId);
// SystemServiceManager設(shè)置UserId
9060 mSystemServiceManager.startUser(currentUserId);
9061
9062 synchronized (this) {
9063 // Only start up encryption-aware persistent apps; once user is
9064 // unlocked we'll come back around and start unaware apps
9065 startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
9066
9067 // Start up initial activity.
9068 mBooting = true;
9069 // Enable home activity for system user, so that the system can always boot. We don't
9070 // do this when the system user is not setup since the setup wizard should be the one
9071 // to handle home activity in this case.
9072 if (UserManager.isSplitSystemUser() &&
9073 Settings.Secure.getInt(mContext.getContentResolver(),
9074 Settings.Secure.USER_SETUP_COMPLETE, 0) != 0) {
9075 ComponentName cName = new ComponentName(mContext, SystemUserHomeActivity.class);
9076 try {
9077 AppGlobals.getPackageManager().setComponentEnabledSetting(cName,
9078 PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0,
9079 UserHandle.USER_SYSTEM);
9080 } catch (RemoteException e) {
9081 throw e.rethrowAsRuntimeException();
9082 }
9083 }
// 調(diào)用ActivityTaskManagerService的startHomeOnAllDisplays方法（就是啟動Launcher的Activity）
9084 mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
9085
9086 mAtmInternal.showSystemReadyErrorDialogsIfNeeded();
9087
9088 final int callingUid = Binder.getCallingUid();
9089 final int callingPid = Binder.getCallingPid();
9090 long ident = Binder.clearCallingIdentity();
9091 try {
// 發(fā)送一些廣播ACTION_USER_STARTED 和 ACTION_USER_STARTING
9092 Intent intent = new Intent(Intent.ACTION_USER_STARTED);
9093 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
9094 | Intent.FLAG_RECEIVER_FOREGROUND);
9095 intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
9096 broadcastIntentLocked(null, null, intent,
9097 null, null, 0, null, null, null, OP_NONE,
9098 null, false, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
9099 currentUserId);
9100 intent = new Intent(Intent.ACTION_USER_STARTING);
9101 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
9102 intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
9103 broadcastIntentLocked(null, null, intent,
9104 null, new IIntentReceiver.Stub() {
9105 @Override
9106 public void performReceive(Intent intent, int resultCode, String data,
9107 Bundle extras, boolean ordered, boolean sticky, int sendingUser)
9108 throws RemoteException {
9109 }
9110 }, 0, null, null,
9111 new String[] {INTERACT_ACROSS_USERS}, OP_NONE,
9112 null, true, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
9113 UserHandle.USER_ALL);
9114 } catch (Throwable t) {
9115 Slog.wtf(TAG, "Failed sending first user broadcasts", t);
9116 } finally {
9117 Binder.restoreCallingIdentity(ident);
9118 }
9119 mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
9120 mUserController.sendUserSwitchBroadcasts(-1, currentUserId);
9121
9122 BinderInternal.nSetBinderProxyCountWatermarks(BINDER_PROXY_HIGH_WATERMARK,
9123 BINDER_PROXY_LOW_WATERMARK);
9124 BinderInternal.nSetBinderProxyCountEnabled(true);
9125 BinderInternal.setBinderProxyCountCallback(
9126 new BinderInternal.BinderProxyLimitListener() {
9127 @Override
9128 public void onLimitReached(int uid) {
9129 Slog.wtf(TAG, "Uid " + uid + " sent too many Binders to uid "
9130 + Process.myUid());
9131 BinderProxy.dumpProxyDebugInfo();
9132 if (uid == Process.SYSTEM_UID) {
9133 Slog.i(TAG, "Skipping kill (uid is SYSTEM)");
9134 } else {
9135 killUid(UserHandle.getAppId(uid), UserHandle.getUserId(uid),
9136 "Too many Binders sent to SYSTEM");
9137 }
9138 }
9139 }, mHandler);
9140
9141 traceLog.traceEnd(); // ActivityManagerStartApps
9142 traceLog.traceEnd(); // PhaseActivityManagerReady
9143 }
9144 }
systemReady()方法也是比較長，大致可以分為：
- 在
systemReady()的時候初始化了deviceIdleController等對象 - 移除并殺死了那些不該在AMS之前啟動的進(jìn)程（進(jìn)程沒有FLAG_PERSISTENT標(biāo)志，則會被kill掉）
- 運行g(shù)oingCallback，執(zhí)行了參數(shù)傳入的回調(diào)函數(shù)
- 啟動Launcher的Activity，即桌面應(yīng)用
- 啟動那些persistent配置為1的進(jìn)程
從前面SystemServer的startOtherServices()中，我們知道systemReady()方法回調(diào)后，也做了一些列邏輯，回調(diào)函數(shù)做了以下工作：
- 主要就是啟動systemUI并調(diào)用其他服務(wù)的systemReady方法
- SystemReady函數(shù)完成了系統(tǒng)就緒的必要的工作
- 啟動了HomeActivity和SystemUI
- 然后Android系統(tǒng)就全部啟動了
3 總結(jié)
到這里AMS的啟動我們再來總結(jié)一下：
- 系統(tǒng)啟動后
Zygote進(jìn)程第一個fork出SystemServer進(jìn)程 -
SystemServer->run()->createSystemContext()：
創(chuàng)建了系統(tǒng)的ActivityThread對象，運行環(huán)境mSystemContext、systemUiContext。 -
SystemServer->run()->startBootstrapServices()->ActivityManagerService.Lifecycle.startService()：
AMS在引導(dǎo)服務(wù)啟動方法中，通過構(gòu)造函數(shù)new ActivityManagerService()進(jìn)行了一些對象創(chuàng)建和初始化(除activity外3大組件的管理和調(diào)度對象創(chuàng)建；內(nèi)存、電池、權(quán)限、性能、cpu等的監(jiān)控等相關(guān)對象創(chuàng)建)，start()啟動服務(wù)(移除進(jìn)程組、啟動cpu線程、注冊權(quán)限、電池等服務(wù))。 -
SystemServer->run()->startBootstrapServices()->setSystemServiceManager()、setInstaller()、initPowerManagement()、setSystemProcess()：
AMS創(chuàng)建后進(jìn)行了一系列相關(guān)的初始化和設(shè)置。setSystemProcess()：將framework-res.apk的信息加入到SystemServer進(jìn)程的LoadedApk中，并創(chuàng)建了SystemServer進(jìn)程的ProcessRecord，加入到mPidsSelfLocked，由AMS統(tǒng)一管理。 -
SystemServer->run()->startOtherServices()：
AMS啟動后的后續(xù)工作，主要調(diào)用systemReady()和運行調(diào)用時傳入的goingCallback。systemReady()/goingCallback：各種服務(wù)或進(jìn)程等AMS啟動完成后需進(jìn)一步完成的工作及系統(tǒng)相關(guān)初始化。 桌面應(yīng)用在systemReady()方法中啟動，systemui在goingCallback中完成。當(dāng)桌面應(yīng)用啟動完成后，發(fā)送開機廣播ACTION_BOOT_COMPLETED
到此為止，整個AMS啟動完成。下一章節(jié)我們將講解Activity的啟動流程文章來源：http://www.zghlxwxcb.cn/news/detail-554705.html
下面附上AMS啟動過程圖：
文章來源地址http://www.zghlxwxcb.cn/news/detail-554705.html
到了這里，關(guān)于【Android Framework系列】5章 AMS啟動流程的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
