• Android—AMS启动

    1.         Installer installer = mSystemServiceManager.startService(Installer.class);
    2.         ActivityTaskManagerService atm = mSystemServiceManager.startService(
    3.                 ActivityTaskManagerService.Lifecycle.class).getService();
    4.         mActivityManagerService = ActivityManagerService.Lifecycle.startService(
    5.                 mSystemServiceManager, atm);
    6.         mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    7.         mActivityManagerService.setInstaller(installer);

    1.ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);

    1.         public static ActivityManagerService startService(
    2.                 SystemServiceManager ssm, ActivityTaskManagerService atm) {
    3.             sAtm = atm;
    4.             return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
    5.         }

      我们从之前的分析知道ActivityManagerService.Lifecycle.startService传入class对象时会实例化该类对象并且调用它的onStart方法，这里我们先看ActivityManagerService.Lifecycle

    1.     public static final class Lifecycle extends SystemService {
    2.         private final ActivityManagerService mService;
    3.         private static ActivityTaskManagerService sAtm;
    4.  
    5.         public Lifecycle(Context context) {
    6.             super(context);
    7.             mService = new ActivityManagerService(context, sAtm);
    8.         }
    9.  
    10.         public static ActivityManagerService startService(
    11.                 SystemServiceManager ssm, ActivityTaskManagerService atm) {
    12.             sAtm = atm;
    13.             return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
    14.         }
    15.  
    16.         @Override
    17.         public void onStart() {
    18.             mService.start();
    19.         }
    20.         ....
    21.     }

    ActivityManagerService.Lifecycle的构造函数又实例化了一个AMS，跟进去看下

    1.     public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
    2.         LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
    3.         mInjector = new Injector();
    4.         //系统上下文，与SystemServer的保持一致
    5.         mContext = systemContext;
    6.  
    7.         mFactoryTest = FactoryTest.getMode();
    8.         //系统进程的主线程
    9.         mSystemThread = ActivityThread.currentActivityThread();
    10.         mUiContext = mSystemThread.getSystemUiContext();
    11.  
    12.         Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
    13.         //处理AMS消息的handle
    14.         mHandlerThread = new ServiceThread(TAG,
    15.                 THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    16.         mHandlerThread.start();
    17.         mHandler = new MainHandler(mHandlerThread.getLooper());
    18.         //UiHandler对应于Android中的Ui线程
    19.         mUiHandler = mInjector.getUiHandler(this);
    20.  
    21.         mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
    22.                 THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
    23.         mProcStartHandlerThread.start();
    24.         mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
    25.  
    26.         mConstants = new ActivityManagerConstants(mContext, this, mHandler);
    27.         final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
    28.         mProcessList.init(this, activeUids);
    29.         mLowMemDetector = new LowMemDetector(this);
    30.         mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
    31.  
    32.         // Broadcast policy parameters
    33.         final BroadcastConstants foreConstants = new BroadcastConstants(
    34.                 Settings.Global.BROADCAST_FG_CONSTANTS);
    35.         foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
    36.  
    37.         final BroadcastConstants backConstants = new BroadcastConstants(
    38.                 Settings.Global.BROADCAST_BG_CONSTANTS);
    39.         backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
    40.  
    41.         final BroadcastConstants offloadConstants = new BroadcastConstants(
    42.                 Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
    43.         offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
    44.         // by default, no "slow" policy in this queue
    45.         offloadConstants.SLOW_TIME = Integer.MAX_VALUE;
    46.  
    47.         mEnableOffloadQueue = SystemProperties.getBoolean(
    48.                 "persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);
    49.  
    50.         mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
    51.                 "foreground", foreConstants, false);
    52.         mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
    53.                 "background", backConstants, true);
    54.         mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
    55.                 "offload", offloadConstants, true);
    56.         mBroadcastQueues[0] = mFgBroadcastQueue;
    57.         mBroadcastQueues[1] = mBgBroadcastQueue;
    58.         mBroadcastQueues[2] = mOffloadBroadcastQueue;
    59.  
    60.         mServices = new ActiveServices(this);
    61.         mProviderMap = new ProviderMap(this);
    62.         mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
    63.         mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
    64.  
    65.         final File systemDir = SystemServiceManager.ensureSystemDir();
    66.  
    67.         // TODO: Move creation of battery stats service outside of activity manager service.
    68.         mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
    69.                 BackgroundThread.get().getHandler());
    70.         mBatteryStatsService.getActiveStatistics().readLocked();
    71.         mBatteryStatsService.scheduleWriteToDisk();
    72.         mOnBattery = DEBUG_POWER ? true
    73.                 : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
    74.         mBatteryStatsService.getActiveStatistics().setCallback(this);
    75.         mOomAdjProfiler.batteryPowerChanged(mOnBattery);
    76.  
    77.         mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
    78.  
    79.         mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
    80.  
    81.         mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
    82.  
    83.         mUserController = new UserController(this);
    84.  
    85.         mPendingIntentController = new PendingIntentController(
    86.                 mHandlerThread.getLooper(), mUserController);
    87.  
    88.         if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
    89.             mUseFifoUiScheduling = true;
    90.         }
    91.  
    92.         mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
    93.         mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
    94.         //得到ActivityTaskManagerService的对象，调用ATM.initialize
    95.         mActivityTaskManager = atm;
    96.         mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
    97.                 DisplayThread.get().getLooper());
    98.         mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
    99.  
    100.         mProcessCpuThread = new Thread("CpuTracker") {
    101.             @Override
    102.             public void run() {
    103.                 synchronized (mProcessCpuTracker) {
    104.                     mProcessCpuInitLatch.countDown();
    105.                     mProcessCpuTracker.init();
    106.                 }
    107.                 while (true) {
    108.                     try {
    109.                         try {
    110.                             synchronized(this) {
    111.                                 final long now = SystemClock.uptimeMillis();
    112.                                 long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
    113.                                 long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
    114.                                 //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
    115.                                 //        + ", write delay=" + nextWriteDelay);
    116.                                 if (nextWriteDelay < nextCpuDelay) {
    117.                                     nextCpuDelay = nextWriteDelay;
    118.                                 }
    119.                                 if (nextCpuDelay > 0) {
    120.                                     mProcessCpuMutexFree.set(true);
    121.                                     this.wait(nextCpuDelay);
    122.                                 }
    123.                             }
    124.                         } catch (InterruptedException e) {
    125.                         }
    126.                         updateCpuStatsNow();
    127.                     } catch (Exception e) {
    128.                         Slog.e(TAG, "Unexpected exception collecting process stats", e);
    129.                     }
    130.                 }
    131.             }
    132.         };
    133.  
    134.         mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
    135.  
    136.         Watchdog.getInstance().addMonitor(this);
    137.         Watchdog.getInstance().addThread(mHandler);
    138.  
    139.         // bind background threads to little cores
    140.         // this is expected to fail inside of framework tests because apps can't touch cpusets directly
    141.         // make sure we've already adjusted system_server's internal view of itself first
    142.         updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
    143.         try {
    144.             Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
    145.                     Process.THREAD_GROUP_SYSTEM);
    146.             Process.setThreadGroupAndCpuset(
    147.                     mOomAdjuster.mAppCompact.mCompactionThread.getThreadId(),
    148.                     Process.THREAD_GROUP_SYSTEM);
    149.         } catch (Exception e) {
    150.             Slog.w(TAG, "Setting background thread cpuset failed");
    151.         }
    152.  
    153.     }

    AMS的构造函数主要做了几件事：

    1. 创建ServiceThread子线程并获取对应线程的handler
    2. 创建前台广播、后台广播、特殊广播的3条队列
    3. 创建ActiveServices
    4. 创建ProviderMap
    5. 赋值ATMS，并进行初始化
    6. 创建CPU监控线程、开启WatchDog等

    可以看到AMS构造函数里面已经没有Activity相关的了，在Android10的版本已经移交给了ATMS了。

    接下来看AMS的start()方法

    1.     private void start() {
    2.         removeAllProcessGroups();
    3.         mProcessCpuThread.start();
    4.  
    5.         mBatteryStatsService.publish();
    6.         mAppOpsService.publish(mContext);
    7.         Slog.d("AppOps", "AppOpsService published");
    8.         LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    9.         mActivityTaskManager.onActivityManagerInternalAdded();
    10.         mUgmInternal.onActivityManagerInternalAdded();
    11.         mPendingIntentController.onActivityManagerInternalAdded();
    12.         // Wait for the synchronized block started in mProcessCpuThread,
    13.         // so that any other access to mProcessCpuTracker from main thread
    14.         // will be blocked during mProcessCpuTracker initialization.
    15.         try {
    16.             mProcessCpuInitLatch.await();
    17.         } catch (InterruptedException e) {
    18.             Slog.wtf(TAG, "Interrupted wait during start", e);
    19.             Thread.currentThread().interrupt();
    20.             throw new IllegalStateException("Interrupted wait during start");
    21.         }
    22.     }
    23.

    publish是把服务添加进ServiceManager和LocalServices

    1.     public void publish() {
    2.         LocalServices.addService(BatteryStatsInternal.class, new LocalService());
    3.         ServiceManager.addService(BatteryStats.SERVICE_NAME, asBinder());
    4.     }
    1. 启动CPU监控线程
    2. 注册电池、权限管理相关服务

    2.mActivityManagerService.setSystemServiceManager(mSystemServiceManager);

    1.     public void setSystemServiceManager(SystemServiceManager mgr) {
    2.         mSystemServiceManager = mgr;
    3.     }

    将SystemServer.java中创建的SystemServiceManager对象设置到了AMS中。

    3.mActivityManagerService.setInstaller(installer)

    1.     public void setInstaller(Installer installer) {
    2.         mInstaller = installer;
    3.     }

    将Installer对象设置到AMS中

    回到SystemServer.run中，进入startOtherServices(); 该方法最后调用了AMS的systemReady方法

    1. mActivityManagerService.systemReady(() -> {
    2.         ......    
    3.         }, BOOT_TIMINGS_TRACE_LOG);

    我们先看systemReady的内容

    1.     public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    2.         traceLog.traceBegin("PhaseActivityManagerReady");
    3.         synchronized(this) {
    4.             if (mSystemReady) {
    5.                 // If we're done calling all the receivers, run the next "boot phase" passed in
    6.                 // by the SystemServer
    7.                 if (goingCallback != null) {
    8.                     goingCallback.run();
    9.                 }
    10.                 return;
    11.             }
    12.  
    13.             mLocalDeviceIdleController
    14.                     = LocalServices.getService(DeviceIdleController.LocalService.class);
    15.             mActivityTaskManager.onSystemReady();
    16.             // Make sure we have the current profile info, since it is needed for security checks.
    17.             mUserController.onSystemReady();
    18.             mAppOpsService.systemReady();
    19.             mSystemReady = true;
    20.         }
    21.  
    22.         try {
    23.             sTheRealBuildSerial = IDeviceIdentifiersPolicyService.Stub.asInterface(
    24.                     ServiceManager.getService(Context.DEVICE_IDENTIFIERS_SERVICE))
    25.                     .getSerial();
    26.         } catch (RemoteException e) {}
    27.  
    28.         ArrayList procsToKill = null;
    29.         synchronized(mPidsSelfLocked) {
    30.             for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
    31.                 ProcessRecord proc = mPidsSelfLocked.valueAt(i);
    32.                 if (!isAllowedWhileBooting(proc.info)){
    33.                     if (procsToKill == null) {
    34.                         procsToKill = new ArrayList();
    35.                     }
    36.                     procsToKill.add(proc);
    37.                 }
    38.             }
    39.         }
    40.  
    41.         synchronized(this) {
    42.             if (procsToKill != null) {
    43.                 for (int i=procsToKill.size()-1; i>=0; i--) {
    44.                     ProcessRecord proc = procsToKill.get(i);
    45.                     Slog.i(TAG, "Removing system update proc: " + proc);
    46.                     mProcessList.removeProcessLocked(proc, true, false, "system update done");
    47.                 }
    48.             }
    49.  
    50.             // Now that we have cleaned up any update processes, we
    51.             // are ready to start launching real processes and know that
    52.             // we won't trample on them any more.
    53.             mProcessesReady = true;
    54.         }
    55.  
    56.         Slog.i(TAG, "System now ready");
    57.         EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_AMS_READY, SystemClock.uptimeMillis());
    58.  
    59.         mAtmInternal.updateTopComponentForFactoryTest();
    60.         mAtmInternal.getLaunchObserverRegistry().registerLaunchObserver(mActivityLaunchObserver);
    61.  
    62.         watchDeviceProvisioning(mContext);
    63.  
    64.         retrieveSettings();
    65.         mUgmInternal.onSystemReady();
    66.  
    67.         final PowerManagerInternal pmi = LocalServices.getService(PowerManagerInternal.class);
    68.         if (pmi != null) {
    69.             pmi.registerLowPowerModeObserver(ServiceType.FORCE_BACKGROUND_CHECK,
    70.                     state -> updateForceBackgroundCheck(state.batterySaverEnabled));
    71.             updateForceBackgroundCheck(
    72.                     pmi.getLowPowerState(ServiceType.FORCE_BACKGROUND_CHECK).batterySaverEnabled);
    73.         } else {
    74.             Slog.wtf(TAG, "PowerManagerInternal not found.");
    75.         }
    76.  
    77.         if (goingCallback != null) goingCallback.run();
    78.         // Check the current user here as a user can be started inside goingCallback.run() from
    79.         // other system services.
    80.         final int currentUserId = mUserController.getCurrentUserId();
    81.         Slog.i(TAG, "Current user:" + currentUserId);
    82.         if (currentUserId != UserHandle.USER_SYSTEM && !mUserController.isSystemUserStarted()) {
    83.             // User other than system user has started. Make sure that system user is already
    84.             // started before switching user.
    85.             throw new RuntimeException("System user not started while current user is:"
    86.                     + currentUserId);
    87.         }
    88.         traceLog.traceBegin("ActivityManagerStartApps");
    89.         mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START,
    90.                 Integer.toString(currentUserId), currentUserId);
    91.         mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START,
    92.                 Integer.toString(currentUserId), currentUserId);
    93.  
    94.         // On Automotive, at this point the system user has already been started and unlocked,
    95.         // and some of the tasks we do here have already been done. So skip those in that case.
    96.         // TODO(b/132262830): this workdound shouldn't be necessary once we move the
    97.         // headless-user start logic to UserManager-land
    98.         final boolean bootingSystemUser = currentUserId == UserHandle.USER_SYSTEM;
    99.  
    100.         if (bootingSystemUser) {
    101.             mSystemServiceManager.startUser(currentUserId);
    102.         }
    103.  
    104.         synchronized (this) {
    105.             // Only start up encryption-aware persistent apps; once user is
    106.             // unlocked we'll come back around and start unaware apps
    107.             startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
    108.  
    109.             // Start up initial activity.
    110.             mBooting = true;
    111.             // Enable home activity for system user, so that the system can always boot. We don't
    112.             // do this when the system user is not setup since the setup wizard should be the one
    113.             // to handle home activity in this case.
    114.             if (UserManager.isSplitSystemUser() &&
    115.                     Settings.Secure.getInt(mContext.getContentResolver(),
    116.                          Settings.Secure.USER_SETUP_COMPLETE, 0) != 0) {
    117.                 ComponentName cName = new ComponentName(mContext, SystemUserHomeActivity.class);
    118.                 try {
    119.                     AppGlobals.getPackageManager().setComponentEnabledSetting(cName,
    120.                             PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0,
    121.                             UserHandle.USER_SYSTEM);
    122.                 } catch (RemoteException e) {
    123.                     throw e.rethrowAsRuntimeException();
    124.                 }
    125.             }
    126.  
    127.             if (bootingSystemUser) {
    128.                 mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
    129.             }
    130.  
    131.             mAtmInternal.showSystemReadyErrorDialogsIfNeeded();
    132.  
    133.             if (bootingSystemUser) {
    134.                 final int callingUid = Binder.getCallingUid();
    135.                 final int callingPid = Binder.getCallingPid();
    136.                 long ident = Binder.clearCallingIdentity();
    137.                 try {
    138.                     Intent intent = new Intent(Intent.ACTION_USER_STARTED);
    139.                     intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
    140.                             | Intent.FLAG_RECEIVER_FOREGROUND);
    141.                     intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
    142.                     broadcastIntentLocked(null, null, intent,
    143.                             null, null, 0, null, null, null, OP_NONE,
    144.                             null, false, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
    145.                             currentUserId);
    146.                     intent = new Intent(Intent.ACTION_USER_STARTING);
    147.                     intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
    148.                     intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
    149.                     broadcastIntentLocked(null, null, intent,
    150.                             null, new IIntentReceiver.Stub() {
    151.                                 @Override
    152.                                 public void performReceive(Intent intent, int resultCode, String data,
    153.                                         Bundle extras, boolean ordered, boolean sticky, int sendingUser)
    154.                                         throws RemoteException {
    155.                                 }
    156.                             }, 0, null, null,
    157.                             new String[] {INTERACT_ACROSS_USERS}, OP_NONE,
    158.                             null, true, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
    159.                             UserHandle.USER_ALL);
    160.                 } catch (Throwable t) {
    161.                     Slog.wtf(TAG, "Failed sending first user broadcasts", t);
    162.                 } finally {
    163.                     Binder.restoreCallingIdentity(ident);
    164.                 }
    165.             } else {
    166.                 Slog.i(TAG, "Not sending multi-user broadcasts for non-system user "
    167.                         + currentUserId);
    168.             }
    169.             mAtmInternal.resumeTopActivities(false /* scheduleIdle */);
    170.             if (bootingSystemUser) {
    171.                 mUserController.sendUserSwitchBroadcasts(-1, currentUserId);
    172.             }
    173.  
    174.             BinderInternal.nSetBinderProxyCountWatermarks(BINDER_PROXY_HIGH_WATERMARK,
    175.                     BINDER_PROXY_LOW_WATERMARK);
    176.             BinderInternal.nSetBinderProxyCountEnabled(true);
    177.             BinderInternal.setBinderProxyCountCallback(
    178.                     new BinderInternal.BinderProxyLimitListener() {
    179.                         @Override
    180.                         public void onLimitReached(int uid) {
    181.                             Slog.wtf(TAG, "Uid " + uid + " sent too many Binders to uid "
    182.                                     + Process.myUid());
    183.                             BinderProxy.dumpProxyDebugInfo();
    184.                             if (uid == Process.SYSTEM_UID) {
    185.                                 Slog.i(TAG, "Skipping kill (uid is SYSTEM)");
    186.                             } else {
    187.                                 killUid(UserHandle.getAppId(uid), UserHandle.getUserId(uid),
    188.                                         "Too many Binders sent to SYSTEM");
    189.                             }
    190.                         }
    191.                     }, mHandler);
    192.  
    193.             traceLog.traceEnd(); // ActivityManagerStartApps
    194.             traceLog.traceEnd(); // PhaseActivityManagerReady
    195.         }
    196.     }

     第一次进来mSystemReady是false的

    1. 确保基础服务已经systemReady
    2. 清掉系统更新进程
    3. 运行callback
    4. mAtmInternal.startHomeOnAllDisplays运行launcher应用
    5. 发广播

    callback：

    1.         mActivityManagerService.systemReady(() -> {
    2.             Slog.i(TAG, "Making services ready");
    3.             traceBeginAndSlog("StartActivityManagerReadyPhase");
    4.             mSystemServiceManager.startBootPhase(
    5.                     SystemService.PHASE_ACTIVITY_MANAGER_READY);
    6.             traceEnd();
    7.             traceBeginAndSlog("StartObservingNativeCrashes");
    8.             try {
    9.                 mActivityManagerService.startObservingNativeCrashes();
    10.             } catch (Throwable e) {
    11.                 reportWtf("observing native crashes", e);
    12.             }
    13.             traceEnd();
    14.  
    15.             // No dependency on Webview preparation in system server. But this should
    16.             // be completed before allowing 3rd party
    17.             final String WEBVIEW_PREPARATION = "WebViewFactoryPreparation";
    18.             Future webviewPrep = null;
    19.             if (!mOnlyCore && mWebViewUpdateService != null) {
    20.                 webviewPrep = SystemServerInitThreadPool.get().submit(() -> {
    21.                     Slog.i(TAG, WEBVIEW_PREPARATION);
    22.                     TimingsTraceLog traceLog = new TimingsTraceLog(
    23.                             SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
    24.                     traceLog.traceBegin(WEBVIEW_PREPARATION);
    25.                     ConcurrentUtils.waitForFutureNoInterrupt(mZygotePreload, "Zygote preload");
    26.                     mZygotePreload = null;
    27.                     mWebViewUpdateService.prepareWebViewInSystemServer();
    28.                     traceLog.traceEnd();
    29.                 }, WEBVIEW_PREPARATION);
    30.             }
    31.  
    32.             if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
    33.                 traceBeginAndSlog("StartCarServiceHelperService");
    34.                 mSystemServiceManager.startService(CAR_SERVICE_HELPER_SERVICE_CLASS);
    35.                 traceEnd();
    36.             }
    37.  
    38.             traceBeginAndSlog("StartSystemUI");
    39.             try {
    40.                 startSystemUi(context, windowManagerF);
    41.             } catch (Throwable e) {
    42.                 reportWtf("starting System UI", e);
    43.             }
    44.             traceEnd();
    45.             // Enable airplane mode in safe mode. setAirplaneMode() cannot be called
    46.             // earlier as it sends broadcasts to other services.
    47.             // TODO: This may actually be too late if radio firmware already started leaking
    48.             // RF before the respective services start. However, fixing this requires changes
    49.             // to radio firmware and interfaces.
    50.             if (safeMode) {
    51.                 traceBeginAndSlog("EnableAirplaneModeInSafeMode");
    52.                 try {
    53.                     connectivityF.setAirplaneMode(true);
    54.                 } catch (Throwable e) {
    55.                     reportWtf("enabling Airplane Mode during Safe Mode bootup", e);
    56.                 }
    57.                 traceEnd();
    58.             }
    59.             traceBeginAndSlog("MakeNetworkManagementServiceReady");
    60.             try {
    61.                 if (networkManagementF != null) {
    62.                     networkManagementF.systemReady();
    63.                 }
    64.             } catch (Throwable e) {
    65.                 reportWtf("making Network Managment Service ready", e);
    66.             }
    67.             CountDownLatch networkPolicyInitReadySignal = null;
    68.             if (networkPolicyF != null) {
    69.                 networkPolicyInitReadySignal = networkPolicyF
    70.                         .networkScoreAndNetworkManagementServiceReady();
    71.             }
    72.             traceEnd();
    73.             traceBeginAndSlog("MakeIpSecServiceReady");
    74.             try {
    75.                 if (ipSecServiceF != null) {
    76.                     ipSecServiceF.systemReady();
    77.                 }
    78.             } catch (Throwable e) {
    79.                 reportWtf("making IpSec Service ready", e);
    80.             }
    81.             traceEnd();
    82.             traceBeginAndSlog("MakeNetworkStatsServiceReady");
    83.             try {
    84.                 if (networkStatsF != null) {
    85.                     networkStatsF.systemReady();
    86.                 }
    87.             } catch (Throwable e) {
    88.                 reportWtf("making Network Stats Service ready", e);
    89.             }
    90.             traceEnd();
    91.             traceBeginAndSlog("MakeConnectivityServiceReady");
    92.             try {
    93.                 if (connectivityF != null) {
    94.                     connectivityF.systemReady();
    95.                 }
    96.             } catch (Throwable e) {
    97.                 reportWtf("making Connectivity Service ready", e);
    98.             }
    99.             traceEnd();
    100.             traceBeginAndSlog("MakeNetworkPolicyServiceReady");
    101.             try {
    102.                 if (networkPolicyF != null) {
    103.                     networkPolicyF.systemReady(networkPolicyInitReadySignal);
    104.                 }
    105.             } catch (Throwable e) {
    106.                 reportWtf("making Network Policy Service ready", e);
    107.             }
    108.             traceEnd();
    109.  
    110.             // Wait for all packages to be prepared
    111.             mPackageManagerService.waitForAppDataPrepared();
    112.  
    113.             // It is now okay to let the various system services start their
    114.             // third party code...
    115.             traceBeginAndSlog("PhaseThirdPartyAppsCanStart");
    116.             // confirm webview completion before starting 3rd party
    117.             if (webviewPrep != null) {
    118.                 ConcurrentUtils.waitForFutureNoInterrupt(webviewPrep, WEBVIEW_PREPARATION);
    119.             }
    120.             mSystemServiceManager.startBootPhase(
    121.                     SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
    122.             traceEnd();
    123.  
    124.             traceBeginAndSlog("StartNetworkStack");
    125.             try {
    126.                 // Note : the network stack is creating on-demand objects that need to send
    127.                 // broadcasts, which means it currently depends on being started after
    128.                 // ActivityManagerService.mSystemReady and ActivityManagerService.mProcessesReady
    129.                 // are set to true. Be careful if moving this to a different place in the
    130.                 // startup sequence.
    131.                 NetworkStackClient.getInstance().start(context);
    132.             } catch (Throwable e) {
    133.                 reportWtf("starting Network Stack", e);
    134.             }
    135.             traceEnd();
    136.  
    137.             traceBeginAndSlog("MakeLocationServiceReady");
    138.             try {
    139.                 if (locationF != null) {
    140.                     locationF.systemRunning();
    141.                 }
    142.             } catch (Throwable e) {
    143.                 reportWtf("Notifying Location Service running", e);
    144.             }
    145.             traceEnd();
    146.             traceBeginAndSlog("MakeCountryDetectionServiceReady");
    147.             try {
    148.                 if (countryDetectorF != null) {
    149.                     countryDetectorF.systemRunning();
    150.                 }
    151.             } catch (Throwable e) {
    152.                 reportWtf("Notifying CountryDetectorService running", e);
    153.             }
    154.             traceEnd();
    155.             traceBeginAndSlog("MakeNetworkTimeUpdateReady");
    156.             try {
    157.                 if (networkTimeUpdaterF != null) {
    158.                     networkTimeUpdaterF.systemRunning();
    159.                 }
    160.             } catch (Throwable e) {
    161.                 reportWtf("Notifying NetworkTimeService running", e);
    162.             }
    163.             traceEnd();
    164.             traceBeginAndSlog("MakeInputManagerServiceReady");
    165.             try {
    166.                 // TODO(BT) Pass parameter to input manager
    167.                 if (inputManagerF != null) {
    168.                     inputManagerF.systemRunning();
    169.                 }
    170.             } catch (Throwable e) {
    171.                 reportWtf("Notifying InputManagerService running", e);
    172.             }
    173.             traceEnd();
    174.             traceBeginAndSlog("MakeTelephonyRegistryReady");
    175.             try {
    176.                 if (telephonyRegistryF != null) {
    177.                     telephonyRegistryF.systemRunning();
    178.                 }
    179.             } catch (Throwable e) {
    180.                 reportWtf("Notifying TelephonyRegistry running", e);
    181.             }
    182.             traceEnd();
    183.             traceBeginAndSlog("MakeMediaRouterServiceReady");
    184.             try {
    185.                 if (mediaRouterF != null) {
    186.                     mediaRouterF.systemRunning();
    187.                 }
    188.             } catch (Throwable e) {
    189.                 reportWtf("Notifying MediaRouterService running", e);
    190.             }
    191.             traceEnd();
    192.             traceBeginAndSlog("MakeMmsServiceReady");
    193.             try {
    194.                 if (mmsServiceF != null) {
    195.                     mmsServiceF.systemRunning();
    196.                 }
    197.             } catch (Throwable e) {
    198.                 reportWtf("Notifying MmsService running", e);
    199.             }
    200.             traceEnd();
    201.  
    202.             traceBeginAndSlog("IncidentDaemonReady");
    203.             try {
    204.                 // TODO: Switch from checkService to getService once it's always
    205.                 // in the build and should reliably be there.
    206.                 final IIncidentManager incident = IIncidentManager.Stub.asInterface(
    207.                         ServiceManager.getService(Context.INCIDENT_SERVICE));
    208.                 if (incident != null) {
    209.                     incident.systemRunning();
    210.                 }
    211.             } catch (Throwable e) {
    212.                 reportWtf("Notifying incident daemon running", e);
    213.             }
    214.             traceEnd();
    215.         }, BOOT_TIMINGS_TRACE_LOG);
    216.     }

    callback内容：

    1. 监测Native Crash
    2. 启动WebView相关
    3. 启动SystemUi

    AMS启动主要工作

    1. 将自身AMS添加到ServiceManger
    2. 将内部类LocalService:ActivityManagerInternal添加到LocalServices
    3. 在启动完bootStrap、core、otherServices后调用systemReady方法
    4. systemReady判断各类服务是否已ready，然后启动SystemUI和Launcher应用。
  • 相关阅读:
    docker（Kubernetes）环境如何查看network namespace
    零基础学Java第五节(面向对象一)
    说下 MySQL 中的锁
    python Threads and ThreadPools
    真题集P115---2015年真题(以及 力扣54)
    【7 Vue3 – Composition API】
    【计算机网络笔记七】应用层（四）HTTP 通过Content-Type提交数据的方式
    [交互]前端展示服务端获取的图片
    Linux基本指令（上）——“Linux”
    17.9处理大数据对象(血干JAVA系类)
  • 原文地址：https://blog.csdn.net/weixin_41939525/article/details/126017791