Framework学习（四）：AMS 核心分析
Framework学习（四）：AMS 核心分析
ActivityManagerService核心学习
1. AMS 是什么？
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
.....................
}
-
从java角度来看，ams就是一个java对象，实现了Ibinder接口，所以它是一个用于进程之间通信的 接口，这个对象初始化是在systemServer.java 的run()方法里面。
public Lifecycle(Context context) { super(context); mService = new ActivityManagerService(context); } -
ActivityManagerService从名字就可以看出，它是一个服务，用来管理Activity，而且是一个系统服务
-
AMS是一个Binder ams实现了Ibinder接口，所以它是一个Binder，这意味着他可以用于进程间通信，也是一个Binder线程。 如果我们启动一个个hello World安卓用于程序，里面不另外启动其他线程，这个里面最少要启动4个 线程：
- main线程，只是程序的主线程，也是日常用到的最多的线程，也叫UI线程，因为android的组件 是非线程安全的，所以只允许UI/MAIN线程来操作。
- GC线程，java有垃圾回收机制，每个java程序都有一个专门负责垃圾回收的线程，
- Binder1 ApplicationThread，这个类实现了Ibinder接口，用于进程之间通信，具体 来说，就是我们程序和AMS通信的工具
- Binder2 ViewRoot.W对象，他也是实现了IBinder接口，就是用于我们的应用程序和 wms通信的工具。
2. AMS 的作用
ActivityManagerService是Android系统中一个特别重要的系统服务，也是我们上层APP打交道最多的系 统服务之一。ActivityManagerService（以下简称AMS） 主要负责四大组件的启动、切换、调度以及应 用进程的管理和调度工作。所有的APP应用都需要 与AMS打交道。AMS在GUI中的关系如图所示。
AMS处理的逻辑多而复杂，因此AMS并不是孤军奋战，这些和AMS共同奋战的类被称为AMS大家族，在Android7.0 和 8.0 后 对AMS相关部分处理有很大区别，我们将主要介绍8.0 以后的版本，其中涉及到的源码部分均是来自 Search (aospxref.com) Android12
3. AMS启动流程
在看AMS的启动流程前，先回顾下Android的整体启动流程
3.1 系统启动流程
3.2 其中Init进程启动的过程为：
3.3 其中Zygote进程启动的过程：
3.4 SystemServer进程启动过程：
而我们要学习的AMS 就是在SystemServer进程中启动的。
/frameworks/base/services/java/com/android/server/SystemServer.java
701 private void run() {
// 1. 方便系统调试
702 TimingsTraceAndSlog t = new TimingsTraceAndSlog();
703 try {
704 t.traceBegin("InitBeforeStartServices");
715 // Default the timezone property to GMT if not set.
716 // 2. 设置默认时区，GMT
717 String timezoneProperty = SystemProperties.get("persist.sys.timezone");
721 SystemProperties.set("persist.sys.timezone", "GMT");
722 }
751
752 // 3. Here we go! 进入Android SystemServer！
753 Slog.i(TAG, "Entered the Android system server!");
795
796 // Prepare the main looper thread (this thread).
// 4.设置主线程Looper
800 Looper.prepareMainLooper();
801 Looper.getMainLooper().setSlowLogThresholdMs(
802 SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
805
806 // 5.Initialize native services. 加载动态库
807 System.loadLibrary("android_servers");
808
820 // 6. 创建系统Context
821 // Initialize the system context.
822 createSystemContext();
830
831 // 7. Create the system service manager 创建system service manager.
832 mSystemServiceManager = new SystemServiceManager(mSystemContext);
867 } finally {
868 t.traceEnd(); // InitBeforeStartServices
869 }
873
874 // Start services.
875 try {
876 t.traceBegin("StartServices");
// 8. 引导服务启动AMS
877 startBootstrapServices(t);
878 startCoreServices(t);
879 startOtherServices(t);
880 } catch (Throwable ex) {
881 Slog.e("System", "******************************************");
882 Slog.e("System", "************ Failure starting system services", ex);
883 throw ex;
884 } finally {
885 t.traceEnd(); // StartServices
886 }
902 // Loop forever.
903 Looper.loop();
904 throw new RuntimeException("Main thread loop unexpectedly exited");
905 }
首先初始化了TimingsTraceAndSlog， 方便在进行ROM开发的时候调试系统， 2 设置了默认时区为GMT（格林尼治所在地的标准时间），4处设置了主线程Looper，5处加载了动态库android_servers，6处创建了系统的Context, 7处初始化system service manager，在8处启动引导服务，其中就初始化了WatchDog 和 AMS等服务。
/frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
// Start the watchdog as early as possible so we can crash the system server
995 // if we deadlock during early boot
996 t.traceBegin("StartWatchdog");
997 final Watchdog watchdog = Watchdog.getInstance();
998 watchdog.start();
999 t.traceEnd();
// Activity manager runs the show.
1058 t.traceBegin("StartActivityManager");
1059 // TODO: Might need to move after migration to WM.
1060 ActivityTaskManagerService atm = mSystemServiceManager.startService(
1061 ActivityTaskManagerService.Lifecycle.class).getService();
1062 mActivityManagerService = ActivityManagerService.Lifecycle.startService(
1063 mSystemServiceManager, atm);
1064 mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
1065 mActivityManagerService.setInstaller(installer);
1066 mWindowManagerGlobalLock = atm.getGlobalLock();
1067 t.traceEnd();
1068
}
可以看到启动AMS 均是通过 SystemServiceManager.startService方法启动， 看一下
frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
Manages creating, starting, and other lifecycle events of
* {@link com.android.server.SystemService system services}.
public final class SystemServiceManager implements Dumpable {
// Services that should receive lifecycle events.
// 管理的所有继承SystemService的类的集合
78 private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();
79
80 // Map of paths to PathClassLoader, so we don't load the same path multiple times.
81 private final ArrayMap<String, PathClassLoader> mLoadedPaths = new ArrayMap<>();
..............................
/**
106 * Starts a service by class name.
107 *
108 * @return The service instance.
109 */
110 public SystemService startService(String className) {
111 final Class<SystemService> serviceClass = loadClassFromLoader(className,
112 this.getClass().getClassLoader());
113 return startService(serviceClass);
114 }
/*
137 * Loads and initializes a class from the given classLoader. Returns the class.
其中最重要的一个函数为startService，这里传入的是一个String类型的className，然后通过反射的方法得到具体的类
138 */
139 @SuppressWarnings("unchecked")
140 private static Class<SystemService> loadClassFromLoader(String className,
141 ClassLoader classLoader) {
142 try {
143 return (Class<SystemService>) Class.forName(className, true, classLoader);
144 } catch (ClassNotFoundException ex) {
// 注意这里的异常提示信息，从这里的异常信息我们可以看出，如果当前设备有些featrue不支
// 持的话，对应的Service类很可能不存在，如果直接引用的话编译就会报错。这里
// 用反射的话，就可以避免因为编译报错而去修改代码，这样适配性也高。
145 throw new RuntimeException("Failed to create service " + className
146 + " from class loader " + classLoader.toString() + ": service class not "
147 + "found, usually indicates that the caller should "
148 + "have called PackageManager.hasSystemFeature() to check whether the "
149 + "feature is available on this device before trying to start the "
150 + "services that implement it. Also ensure that the correct path for the "
151 + "classloader is supplied, if applicable.", ex);
152 }
// 调用泛型函数
startService(service);
193 return service;
153 }
/**
156 * Creates and starts a system service. The class must be a subclass of
157 * {@link com.android.server.SystemService}.
158 *
159 * @param serviceClass A Java class that implements the SystemService interface.
160 * @return The service instance, never null.
161 * @throws RuntimeException if the service fails to start.
162 */
163 public <T extends SystemService> T startService(Class<T> serviceClass) {
164 try {
165 final String name = serviceClass.getName();
166 Slog.i(TAG, "Starting " + name);
167 Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
168
169 // Create the service.
// isAssignableFrom函数的作用是判断是否为子类
170 if (!SystemService.class.isAssignableFrom(serviceClass)) {
171 throw new RuntimeException("Failed to create " + name
172 + ": service must extend " + SystemService.class.getName());
173 }
174 final T service;
175 try {
// 通过反射构造类的实例
176 Constructor<T> constructor = serviceClass.getConstructor(Context.class);
177 service = constructor.newInstance(mContext);
178 } catch (InstantiationException ex) {
179 throw new RuntimeException("Failed to create service " + name
180 + ": service could not be instantiated", ex);
181 } catch (IllegalAccessException ex) {
182 throw new RuntimeException("Failed to create service " + name
183 + ": service must have a public constructor with a Context argument", ex);
184 } catch (NoSuchMethodException ex) {
185 throw new RuntimeException("Failed to create service " + name
186 + ": service must have a public constructor with a Context argument", ex);
187 } catch (InvocationTargetException ex) {
188 throw new RuntimeException("Failed to create service " + name
189 + ": service constructor threw an exception", ex);
190 }
191 // 这里就是真正执行启动service了
192 startService(service);
193 return service;
194 } finally {
195 Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
196 }
197 }
public void startService(@NonNull final SystemService service) {
// Register it.
// 将要启动的service加到mService列表中
mServices.add(service);
// Start it.
long time = System.currentTimeMillis(); // 记录开始操作的时间
try {
service.onStart(); // 调用要启动的service的 onStart方法
} catch (RuntimeException ex) {
throw new RuntimeException("Failed to start service " + service.getClass().getName()
+ ": onStart threw an exception", ex);
}
// 记录上述操作执行的时间，如果超时，会有warning提示
warnIfTooLong(System.currentTimeMillis() - time, service, "onStart");
}
// 可以看到，如果对Service的某个操作超过了SERVICE_CALL_WARN_TIME_MS（50ms)，Log中就会有warning提示
private void warnIfTooLong(long duration, SystemService service, String operation) {
if (duration > SERVICE_CALL_WARN_TIME_MS) {
Slog.w(TAG, "Service " + service.getClass().getName() + " took " + duration + " ms in "
+ operation);
}
SystemServiceManager是管理SystemService的，这么说还不够严谨，应该说是管理继承了SystemService的类的，这个从SystemServiceManager开头的注释中可以看到。这个类在SystemServer中被大量用到，主要用于开机时的各种系统服务的初始化和配置工作。对我们要启动的AMS。
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
其中ActivityTaskManagerService.Lifecycle.class正是继承了
public static final class Lifecycle extends SystemService {
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context, sAtm);
}
public ActivityManagerService getService() {
return mService;
}
@Override
public void onStart() {
mService.start();
}
// 分阶段初始化
@Override
public void onBootPhase(int phase) {
mService.mBootPhase = phase;
if (phase == PHASE_SYSTEM_SERVICES_READY) {
mService.mBatteryStatsService.systemServicesReady();
mService.mServices.systemServicesReady();
} else if (phase == PHASE_ACTIVITY_MANAGER_READY) {
mService.startBroadcastObservers();
} else if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) {
mService.mPackageWatchdog.onPackagesReady();
}
}
@Override
public void onUserStopped(@NonNull TargetUser user) {
mService.mBatteryStatsService.onCleanupUser(user.getUserIdentifier());
}
}
为什么要引入LifeCycle呢，生命周期管理，因为AMS不是一次性初始化完成，需要依赖很多其他的服务，需要分不同阶段初始（phase）。
接下来就到了 AMS的构造方法，其中伴随着大量的服务启动
// Note: This method is invoked on the main thread but may need to attach various
// handlers to other threads. So take care to be explicit about the looper.
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
// 锁屏相关的
2227 LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
2228 mInjector = new Injector(systemContext);
2229 mContext = systemContext;
2230
.......................
2236 // 创建了大量的handler线程
2237 mHandlerThread = new ServiceThread(TAG,
2238 THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
2239 mHandlerThread.start();
2240 mHandler = new MainHandler(mHandlerThread.getLooper());
2241 mUiHandler = mInjector.getUiHandler(this);
2242
2243 mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
2244 THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
2245 mProcStartHandlerThread.start();
2246 mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
.............................
2258
2259 // Broadcast policy parameters
2260 final BroadcastConstants foreConstants = new BroadcastConstants(
2261 Settings.Global.BROADCAST_FG_CONSTANTS);
2262 foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
2263
2264 final BroadcastConstants backConstants = new BroadcastConstants(
2265 Settings.Global.BROADCAST_BG_CONSTANTS);
2266 backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
2267
2268 final BroadcastConstants offloadConstants = new BroadcastConstants(
2269 Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
2270 offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
2271 // by default, no "slow" policy in this queue
2272 offloadConstants.SLOW_TIME = Integer.MAX_VALUE;
2273
2274 mEnableOffloadQueue = SystemProperties.getBoolean(
2275 "persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);
2276 // 创建前台和后台广播
2277 mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
2278 "foreground", foreConstants, false);
2279 mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
2280 "background", backConstants, true);
2281 mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
2282 "offload", offloadConstants, true);
2283 mBroadcastQueues[0] = mFgBroadcastQueue;
2284 mBroadcastQueues[1] = mBgBroadcastQueue;
2285 mBroadcastQueues[2] = mOffloadBroadcastQueue;
2286 // 创建了ActivityServices
2287 mServices = new ActiveServices(this);
2288 mCpHelper = new ContentProviderHelper(this, true);
2289 mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
2290 mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
2291 mUidObserverController = new UidObserverController(mUiHandler);
2292
2293 final File systemDir = SystemServiceManager.ensureSystemDir();
2294 // 电量统计的服务
2295 // TODO: Move creation of battery stats service outside of activity manager service.
2296 mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
2297 BackgroundThread.get().getHandler());
2298 mBatteryStatsService.getActiveStatistics().readLocked();
2299 mBatteryStatsService.scheduleWriteToDisk();
2300 mOnBattery = DEBUG_POWER ? true
2301 : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
2302 mBatteryStatsService.getActiveStatistics().setCallback(this);
2303 mOomAdjProfiler.batteryPowerChanged(mOnBattery);
2304 // 进程统计相关的服务
2305 mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
2306 // information about and control over application operations
2307 mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
2308
2309 mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
2310
2311 mUserController = new UserController(this);
2312
2313 mPendingIntentController = new PendingIntentController(
2314 mHandlerThread.getLooper(), mUserController, mConstants);
2315
2316 mUseFifoUiScheduling = SystemProperties.getInt("sys.use_fifo_ui", 0) != 0;
2317
2318 mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
2319 mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
2320
2321 mActivityTaskManager = atm;
2322 mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
2323 DisplayThread.get().getLooper());
2324 mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class)。
.............................
}
AMS 初始化后还会在SystemServer中启动很多其他服务
/frameworks/base/services/java/com/android/server/SystemServer.java
mActivityManagerService.initPowerManagement();
// Set up the Application instance for the system process and get started.
t.traceBegin("SetSystemProcess");
mActivityManagerService.setSystemProcess();
// Tracks application usage stats.
mActivityManagerService.setUsageStatsManager(LocalServices.getService(UsageStatsManagerInternal.class));
// 设置SettingsProvider
t.traceBegin("InstallSystemProviders");
mActivityManagerService.getContentProviderHelper().installSystemProviders();
//SetWindowManagerService
mActivityManagerService.setWindowManager(wm);
...................
mActivityManagerService.systemReady()
AMS 和 WMS 建立关联
mActivityManagerService.setWindowManager(wm);
ActivityManagerService
public void setWindowManager(WindowManagerService wm) {
1846 synchronized (this) {
1847 mWindowManager = wm;
1848 mWmInternal = LocalServices.getService(WindowManagerInternal.class);
1849 mActivityTaskManager.setWindowManager(wm);
1850 }
1851 }
wm/ActivityTaskManagerService.java
public void setWindowManager(WindowManagerService wm) {
974 synchronized (mGlobalLock) {
975 mWindowManager = wm;
976 mRootWindowContainer = wm.mRoot;
977 mTempConfig.setToDefaults();
978 mTempConfig.setLocales(LocaleList.getDefault());
979 mConfigurationSeq = mTempConfig.seq = 1;
980 mRootWindowContainer.onConfigurationChanged(mTempConfig);
981 mLockTaskController.setWindowManager(wm);
982 mTaskSupervisor.setWindowManager(wm);
983 mRootWindowContainer.setWindowManager(wm);
984 }
985 }
最后执行到 mActivityManagerService.systemReady(), 意味着80多个服务差不多启动完成了。
2673 // We now tell the activity manager it is okay to run third party
2674 // code. It will call back into us once it has gotten to the state
2675 // where third party code can really run (but before it has actually
2676 // started launching the initial applications), for us to complete our
2677 // initialization.
2678 mActivityManagerService.systemReady(() -> {
2679 Slog.i(TAG, "Making services ready");
2680 t.traceBegin("StartActivityManagerReadyPhase");
2681 mSystemServiceManager.startBootPhase(t, SystemService.PHASE_ACTIVITY_MANAGER_READY);
2682 t.traceEnd();
2683 t.traceBegin("StartObservingNativeCrashes");
2684 try {
2685 mActivityManagerService.startObservingNativeCrashes();
2686 } catch (Throwable e) {
2687 reportWtf("observing native crashes", e);
2688 }
2689 t.traceEnd();
2690
2691 t.traceBegin("RegisterAppOpsPolicy");
2692 try {
2693 mActivityManagerService.setAppOpsPolicy(new AppOpsPolicy(mSystemContext));
2694 } catch (Throwable e) {
2695 reportWtf("registering app ops policy", e);
2696 }
2697 t.traceEnd();
2698
2699 // No dependency on Webview preparation in system server. But this should
2700 // be completed before allowing 3rd party
2701 final String WEBVIEW_PREPARATION = "WebViewFactoryPreparation";
2702 Future<?> webviewPrep = null;
2703 if (!mOnlyCore && mWebViewUpdateService != null) {
2704 webviewPrep = SystemServerInitThreadPool.submit(() -> {
2705 Slog.i(TAG, WEBVIEW_PREPARATION);
2706 TimingsTraceAndSlog traceLog = TimingsTraceAndSlog.newAsyncLog();
2707 traceLog.traceBegin(WEBVIEW_PREPARATION);
2708 ConcurrentUtils.waitForFutureNoInterrupt(mZygotePreload, "Zygote preload");
2709 mZygotePreload = null;
2710 mWebViewUpdateService.prepareWebViewInSystemServer();
2711 traceLog.traceEnd();
2712 }, WEBVIEW_PREPARATION);
2713 }
2714
2715 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
2716 t.traceBegin("StartCarServiceHelperService");
2717 final SystemService cshs = mSystemServiceManager
2718 .startService(CAR_SERVICE_HELPER_SERVICE_CLASS);
2719 if (cshs instanceof Dumpable) {
2720 mDumper.addDumpable((Dumpable) cshs);
2721 }
2722 if (cshs instanceof DevicePolicySafetyChecker) {
2723 dpms.setDevicePolicySafetyChecker((DevicePolicySafetyChecker) cshs);
2724 }
2725 t.traceEnd();
2726 }
2727
2728 // Enable airplane mode in safe mode. setAirplaneMode() cannot be called
2729 // earlier as it sends broadcasts to other services.
2730 // TODO: This may actually be too late if radio firmware already started leaking
2731 // RF before the respective services start. However, fixing this requires changes
2732 // to radio firmware and interfaces.
2733 if (safeMode) {
2734 t.traceBegin("EnableAirplaneModeInSafeMode");
2735 try {
2736 connectivityF.setAirplaneMode(true);
2737 } catch (Throwable e) {
2738 reportWtf("enabling Airplane Mode during Safe Mode bootup", e);
2739 }
2740 t.traceEnd();
2741 }
2742 t.traceBegin("MakeNetworkManagementServiceReady");
2743 try {
2744 if (networkManagementF != null) {
2745 networkManagementF.systemReady();
2746 }
2747 } catch (Throwable e) {
2748 reportWtf("making Network Managment Service ready", e);
2749 }
2750 CountDownLatch networkPolicyInitReadySignal = null;
2751 if (networkPolicyF != null) {
2752 networkPolicyInitReadySignal = networkPolicyF
2753 .networkScoreAndNetworkManagementServiceReady();
2754 }
2755 t.traceEnd();
2756 t.traceBegin("MakeIpSecServiceReady");
2757 try {
2758 if (ipSecServiceF != null) {
2759 ipSecServiceF.systemReady();
2760 }
2761 } catch (Throwable e) {
2762 reportWtf("making IpSec Service ready", e);
2763 }
2764 t.traceEnd();
2765 t.traceBegin("MakeNetworkStatsServiceReady");
2766 try {
2767 if (networkStatsF != null) {
2768 networkStatsF.systemReady();
2769 }
2770 } catch (Throwable e) {
2771 reportWtf("making Network Stats Service ready", e);
2772 }
2773 t.traceEnd();
2774 t.traceBegin("MakeConnectivityServiceReady");
2775 try {
2776 if (connectivityF != null) {
2777 connectivityF.systemReady();
2778 }
2779 } catch (Throwable e) {
2780 reportWtf("making Connectivity Service ready", e);
2781 }
2782 t.traceEnd();
2783 t.traceBegin("MakeVpnManagerServiceReady");
2784 try {
2785 if (vpnManagerF != null) {
2786 vpnManagerF.systemReady();
2787 }
2788 } catch (Throwable e) {
2789 reportWtf("making VpnManagerService ready", e);
2790 }
2791 t.traceEnd();
2792 t.traceBegin("MakeVcnManagementServiceReady");
2793 try {
2794 if (vcnManagementF != null) {
2795 vcnManagementF.systemReady();
2796 }
2797 } catch (Throwable e) {
2798 reportWtf("making VcnManagementService ready", e);
2799 }
2800 t.traceEnd();
2801 t.traceBegin("MakeNetworkPolicyServiceReady");
2802 try {
2803 if (networkPolicyF != null) {
2804 networkPolicyF.systemReady(networkPolicyInitReadySignal);
2805 }
2806 } catch (Throwable e) {
2807 reportWtf("making Network Policy Service ready", e);
2808 }
2809 t.traceEnd();
2810
2811 // Wait for all packages to be prepared
2812 mPackageManagerService.waitForAppDataPrepared();
2813
2814 // It is now okay to let the various system services start their
2815 // third party code...
2816 t.traceBegin("PhaseThirdPartyAppsCanStart");
2817 // confirm webview completion before starting 3rd party
2818 if (webviewPrep != null) {
2819 ConcurrentUtils.waitForFutureNoInterrupt(webviewPrep, WEBVIEW_PREPARATION);
2820 }
2821 mSystemServiceManager.startBootPhase(t, SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
2822 t.traceEnd();
2823
2824 t.traceBegin("StartNetworkStack");
2825 try {
2826 // Note : the network stack is creating on-demand objects that need to send
2827 // broadcasts, which means it currently depends on being started after
2828 // ActivityManagerService.mSystemReady and ActivityManagerService.mProcessesReady
2829 // are set to true. Be careful if moving this to a different place in the
2830 // startup sequence.
2831 NetworkStackClient.getInstance().start();
2832 } catch (Throwable e) {
2833 reportWtf("starting Network Stack", e);
2834 }
2835 t.traceEnd();
2836
2837 t.traceBegin("StartTethering");
2838 try {
2839 // TODO: hide implementation details, b/146312721.
2840 ConnectivityModuleConnector.getInstance().startModuleService(
2841 TETHERING_CONNECTOR_CLASS,
2842 PERMISSION_MAINLINE_NETWORK_STACK, service -> {
2843 ServiceManager.addService(Context.TETHERING_SERVICE, service,
2844 false /* allowIsolated */,
2845 DUMP_FLAG_PRIORITY_HIGH | DUMP_FLAG_PRIORITY_NORMAL);
2846 });
2847 } catch (Throwable e) {
2848 reportWtf("starting Tethering", e);
2849 }
2850 t.traceEnd();
2851
2852 t.traceBegin("MakeCountryDetectionServiceReady");
2853 try {
2854 if (countryDetectorF != null) {
2855 countryDetectorF.systemRunning();
2856 }
2857 } catch (Throwable e) {
2858 reportWtf("Notifying CountryDetectorService running", e);
2859 }
2860 t.traceEnd();
2861 t.traceBegin("MakeNetworkTimeUpdateReady");
2862 try {
2863 if (networkTimeUpdaterF != null) {
2864 networkTimeUpdaterF.systemRunning();
2865 }
2866 } catch (Throwable e) {
2867 reportWtf("Notifying NetworkTimeService running", e);
2868 }
2869 t.traceEnd();
2870 t.traceBegin("MakeInputManagerServiceReady");
2871 try {
2872 // TODO(BT) Pass parameter to input manager
2873 if (inputManagerF != null) {
2874 inputManagerF.systemRunning();
2875 }
2876 } catch (Throwable e) {
2877 reportWtf("Notifying InputManagerService running", e);
2878 }
2879 t.traceEnd();
2880 t.traceBegin("MakeTelephonyRegistryReady");
2881 try {
2882 if (telephonyRegistryF != null) {
2883 telephonyRegistryF.systemRunning();
2884 }
2885 } catch (Throwable e) {
2886 reportWtf("Notifying TelephonyRegistry running", e);
2887 }
2888 t.traceEnd();
2889 t.traceBegin("MakeMediaRouterServiceReady");
2890 try {
2891 if (mediaRouterF != null) {
2892 mediaRouterF.systemRunning();
2893 }
2894 } catch (Throwable e) {
2895 reportWtf("Notifying MediaRouterService running", e);
2896 }
2897 t.traceEnd();
2898 t.traceBegin("MakeMmsServiceReady");
2899 try {
2900 if (mmsServiceF != null) {
2901 mmsServiceF.systemRunning();
2902 }
2903 } catch (Throwable e) {
2904 reportWtf("Notifying MmsService running", e);
2905 }
2906 t.traceEnd();
2907
2908 t.traceBegin("IncidentDaemonReady");
2909 try {
2910 // TODO: Switch from checkService to getService once it's always
2911 // in the build and should reliably be there.
2912 final IIncidentManager incident = IIncidentManager.Stub.asInterface(
2913 ServiceManager.getService(Context.INCIDENT_SERVICE));
2914 if (incident != null) {
2915 incident.systemRunning();
2916 }
2917 } catch (Throwable e) {
2918 reportWtf("Notifying incident daemon running", e);
2919 }
2920 t.traceEnd();
2921
2922 if (mIncrementalServiceHandle != 0) {
2923 t.traceBegin("MakeIncrementalServiceReady");
2924 setIncrementalServiceSystemReady(mIncrementalServiceHandle);
2925 t.traceEnd();
2926 }
2927 }, t);
2928
2929 t.traceBegin("StartSystemUI");
2930 try {
2931 startSystemUi(context, windowManagerF);
2932 } catch (Throwable e) {
2933 reportWtf("starting System UI", e);
2934 }
2935 t.traceEnd();
2936
2937 t.traceEnd(); // startOtherServices
2938 }
主要干了三件事
- startSystemUI 启动系统UI
- 执行一系列的SystemReady
- 执行一系列的SystemRunning
4. AMS 内部数据结构
AMS的启动到这里算是告一段落了， 接下来我们来深入AMS的内部来研究一下
4.1 ProcessRecord
Android系统中用于描述进程的数据结构是ProcessRecord对象，AMS便是管理进程的核心模块。四大组件 （Activity,Service, BroadcastReceiver, ContentProvider）定义在AndroidManifest.xml文件， 每一项都可以用属性android:process指定所运行的进程。同，也可以运行在多个进程， 甚至多个app可以共享同一个进程。
组件启动后，首先需要依赖进程，那么就需要先创建进程，系统需要记录每个进程，这便产生了ProcessRecord。 Android中，对于进程的概念被弱化，通过抽象后的四大组件。让开发者几乎感受不到进程的存在。 当应用退出时，进程也并非马上退出，而是成为cache/empty进程，下次该应用再启动的时候，可以不用 再创建进程直接初始化组件即可，提高启动速度。先来说一说进程。
以一幅图来展示AMS管理进程的相关成员变量以及ProcessRecord对象：
/frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
/**
828 * All of the processes we currently have running organized by pid.
829 * The keys are the pid running the application.
830 *
831 * <p>NOTE: This object is protected by its own lock, NOT the global activity manager lock!
832 */
833 final PidMap mPidsSelfLocked = new PidMap();
834 static final class PidMap {
835 private final SparseArray<ProcessRecord> mPidMap = new SparseArray<>();
836
837 ProcessRecord get(int pid) {
838 return mPidMap.get(pid);
839 }
840
841 int size() {
842 return mPidMap.size();
843 }
844
845 ProcessRecord valueAt(int index) {
846 return mPidMap.valueAt(index);
847 }
848
849 int keyAt(int index) {
850 return mPidMap.keyAt(index);
851 }
852
853 int indexOfKey(int key) {
854 return mPidMap.indexOfKey(key);
855 }
856
857 void doAddInternal(int pid, ProcessRecord app) {
858 mPidMap.put(pid, app);
859 }
860
861 boolean doRemoveInternal(int pid, ProcessRecord app) {
862 final ProcessRecord existingApp = mPidMap.get(pid);
863 if (existingApp != null && existingApp.getStartSeq() == app.getStartSeq()) {
864 mPidMap.remove(pid);
865 return true;
866 }
867 return false;
868 }
869
870 boolean doRemoveIfNoThreadInternal(int pid, ProcessRecord app) {
871 if (app == null || app.getThread() != null) {
872 return false;
873 }
874 return doRemoveInternal(pid, app);
875 }
876 }
877
/frameworks/base/services/core/java/com/android/server/am/ProcessRecord.java
/**
66 * Full information about a particular process that
67 * is currently running.
68 */
69 class ProcessRecord implements WindowProcessListener {
...........................
}
ProcessRecord 数据结构
第一类数据：描述身份的数据
-
ApplicationInfo info：AndroidManifest.xml中定义的Application信息
-
boolean isolated：是不是isolated进程
-
int uid：进程uid
-
int userId：这个是android做的多用户系统id，就像windows可以登录很多用户一样，android 也希望可以实现类似的多用户
-
String processName：进程名字，默认情况下是包名
-
UidRecord uidRecord：记录已经使用的uid
-
IApplicationThread thread：这个很重要，它是ApplicationThread的客户端，AMS就是通过这 个对象给apk进程发送异步消息的（管理四大组件的消息），所以只有这个对象不为空的情况下， 才代表apk进程可是使用了
第二类数据：描述进程中组件的数据
-
pkgList：进程中运行的包
-
ArraySet pkgDeps：进程运行依赖的包
-
ArrayList activities：进程启动的所有的activity组件记录表
-
ArraySet services：进程启动的所有的service组件记录表
-
ArraySet executingServices：正在运行（executing）是怎么定义的？首先需要明确的是系统是 怎么控制组件的？发送消息给apk进程，apk进程处理消息，上报消息完成，这被定义为一个完整 的执行过程，因此正在执行（executing）被定义为发送消息到上报完成这段时间
-
ArraySet connections：绑定service的客户端记录表
第三类数据：描述进程状态的数据
-
int maxAdj：进程的adj上限（adjustment）
-
int curRawAdj：当前正在计算的adj，这个值有可能大于maxAdj
-
int setRawAdj：上次计算的curRawAdj设置到lowmemorykiller系统后的adj
-
int curAdj：当前正在计算的adj，这是curRawAdj被maxAdj削平的值
-
int setAdj：上次计算的curAdj设置到lowmemorykiller系统后的adj
第四类数据：和pss相关的数据 我们先来普及一下一些名词：
VSS- Virtual Set Size 虚拟耗用内存（包含共享库占用的内存） RSS- Resident Set Size 实际使用 物理内存（包含共享库占用的内存） PSS- Proportional Set Size 实际使用的物理内存（比例分配 共享库占用的内存） USS- Unique Set Size 进程独自占用的物理内存（不包含共享库占用的内 存） 一般来说内存占用大小有如下规律：VSS >= RSS >= PSS >= USS
-
long initialIdlePss：初始化pss
-
long lastPss：上次pss
-
long lastSwapPss：上次SwapPss数据
-
long lastCachedPss：上次CachedPss数据
-
long lastCachedSwapPss：上次CachedSwapPss数据
第五类数据：和时间相关的数据
-
long lastActivityTime：上次使用时间
-
long lastPssTime：上次计算pss的时间
-
long nextPssTime：下次计算pss的时间
-
long lastStateTime：上次设置进程状态的时间
-
long curCpuTime：当前最新占用cpu的时长
-
long lastRequestedGc：上次发送gc命令给apk进程的时间
-
long lastLowMemory：上次发送低内存消息给apk进程的时间
-
long lastProviderTime：上次进程中ContentProvider被使用的时间
-
.........................
第六类数据：crash和anr相关的数据
-
IBinder.DeathRecipient deathRecipient：apk进程退出运行的话，会触发这个对象的 binderDied()方法，来回收系统资源
-
boolean crashing：进程已经crash
-
Dialog crashDialog：crash对话框
-
boolean forceCrashReport：强制crash对话框显示
-
boolean notResponding：是否处于anr状态
-
.............
第七类数据：和instrumentation相关的数据
instrumentation 也可以说是apk的一个组件，系统会默认使用Instrumentation.java类，按照我们一般的理解，UI 线程控制activity的生命周期，调用的是instrumentation的方法，由它再调用Activity涉及生命周期的方法，所有如果我们覆写了instrumentation的这些方法，就可以了解所有的Activity的生命周期了
-
ComponentName instrumentationClass：AndroidManifest.xml中定义的instrumentation信 息
-
ApplicationInfo instrumentationInfo：instrumentation应用信息
-
String instrumentationProfileFile：instrumentation配置文件
-
IInstrumentationWatcher instrumentationWatcher：instrumentation监测器
-
IUiAutomationConnection instrumentationUiAutomationConnection：UiAutomation连接器
-
ComponentName instrumentationResultClass：返回结果组件
第八类数据：电源信息和调试信息
-
BatteryStatsImpl mBatteryStats:电量信息
-
BatteryStatsImpl.Uid.Proc curProcBatteryStats：当前进程电量信息
-
boolean debugging:处于调试中
-
boolean waitedForDebugger:等待调试
-
Dialog waitDialog:等待对话框
-
String adjType:adj类型（或者说标示）
-
.......................
4.2 Activity栈管理数据结构
先来张简单的关系图：
- 一个
ActivityRecord对应一个Activity，保存了一个Activity的所有信息;但是一个Activity可能会有多个ActivityRecord,因为Activity可以被多次启动，这个主要取决于其启动模式。 - 一个
TaskRecord由一个或者多个ActivityRecord组成，这就是我们常说的任务栈，具有后进先出的特点。 ActivityStack则是用来管理TaskRecord的，包含了多个TaskRecord。
4.2.1 ActivityRecord
源码中的注释介绍：An entry in the history stack, representing an activity. 翻译：历 史栈中的一个条目，代表一个activity， 它是在启动Activity是被创建，具体是在ActivityStarter的StartActivity方法中被创建， 其存储了Activity的所有信息， 包括AMS的引用， AndroidManifest节点信息， Activity状态， Activity资源信息和Activity进程相关信息等，需要注意的是其中包含有该Activity所在的TaskRecord， 这就将ActivityRecord和TaskRecord关联在一起，他们是Activity任务栈的重要成员。
/frameworks/base/services/core/java/com/android/server/wm/[ActivityRecord.java](http://aospxref.com/android-12.0.0_ r3/xref/frameworks/base/services/core/java/com/android/server/wm/ActivityRecord.java)
/**
* An entry in the history task, representing an activity.
*/
final class ActivityRecord extends WindowToken implements WindowManagerService.AppFreezeListener {
......................
final ActivityManagerService service; // owner
final IApplicationToken.Stub appToken; // window manager token
AppWindowContainerController mWindowContainerController;
final ActivityInfo info; // all about me
final ApplicationInfo appInfo; // information about activity's app
//省略其他成员变量
//ActivityRecord所在的TaskRecord
private TaskRecord task; // the task this is in.
//构造方法，需要传递大量信息
ActivityRecord(ActivityManagerService _service, ProcessRecord _caller, int _launchedFromPid,
int _launchedFromUid, String _launchedFromPackage, Intent _intent, String _resolvedType,
ActivityInfo aInfo, Configuration _configuration,
com.android.server.am.ActivityRecord _resultTo, String _resultWho, int _reqCode,
boolean _componentSpecified, boolean _rootVoiceInteraction,
ActivityStackSupervisor supervisor, ActivityOptions options,
com.android.server.am.ActivityRecord sourceRecord) {
}
}
4.2.2 TaskRecord
TaskRecord，内部维护一个ArrayList<ActivityRecord>用来保存ActivityRecord。
frameworks/base/services/core/java/com/android/server/am/TaskRecord.java
final class TaskRecord extends ConfigurationContainer implements TaskWindowContainerListener {
final int taskId; //任务ID
final ArrayList<ActivityRecord> mActivities; //使用一个ArrayList来保存所有的ActivityRecord
private ActivityStack mStack; //TaskRecord所在的ActivityStack
//构造方法
TaskRecord(ActivityManagerService service, int _taskId, ActivityInfo info, Intent _intent,
IVoiceInteractionSession _voiceSession, IVoiceInteractor _voiceInteractor, int type) {
}
//添加Activity到顶部
void addActivityToTop(com.android.server.am.ActivityRecord r) {
addActivityAtIndex(mActivities.size(), r);
}
//添加Activity到指定的索引位置
void addActivityAtIndex(int index, ActivityRecord r) {
//...
r.setTask(this);//为ActivityRecord设置TaskRecord，就是这里建立的联系
//...
index = Math.min(size, index);
mActivities.add(index, r);//添加到mActivities
//...
}
//其他代码略
}
- 可以看到
TaskRecord中使用了一个ArrayList来保存所有的ActivityRecord。 - 同样，
TaskRecord中的mStack表示其所在的ActivityStack。
4.2.3 ActivityStack
ActivityStack,内部维护了一个ArrayList<TaskRecord>，用来管理TaskRecord
frameworks/base/services/core/java/com/android/server/am/ActivityStack.java
class ActivityStack<T extends StackWindowController> extends ConfigurationContainer implements StackWindowListener {
private final ArrayList<TaskRecord> mTaskHistory = new ArrayList<>();//使用一个ArrayList来保存TaskRecord
final int mStackId;
protected final ActivityStackSupervisor mStackSupervisor;//持有一个ActivityStackSupervisor，所有的运行中的ActivityStacks都通过它来进行管理
//构造方法
ActivityStack(ActivityStackSupervisor.ActivityDisplay display, int stackId,
ActivityStackSupervisor supervisor, RecentTasks recentTasks, boolean onTop) {
}
TaskRecord createTaskRecord(int taskId, ActivityInfo info, Intent intent,
IVoiceInteractionSession voiceSession, IVoiceInteractor voiceInteractor,
boolean toTop, int type) {
//创建一个task
TaskRecord task = new TaskRecord(mService, taskId, info, intent, voiceSession, voiceInteractor, type);
//将task添加到ActivityStack中去
addTask(task, toTop, "createTaskRecord");
//其他代码略
return task;
}
//添加Task
void addTask(final TaskRecord task, final boolean toTop, String reason) {
addTask(task, toTop ? MAX_VALUE : 0, true /* schedulePictureInPictureModeChange */, reason);
//其他代码略
}
//添加Task到指定位置
void addTask(final TaskRecord task, int position, boolean schedulePictureInPictureModeChange,
String reason) {
mTaskHistory.remove(task);//若存在，先移除
//...
mTaskHistory.add(position, task);//添加task到mTaskHistory
task.setStack(this);//为TaskRecord设置ActivityStack
//...
}
//其他代码略
}
- 可以看到
ActivityStack使用了一个ArrayList来保存TaskRecord。 - 另外，
ActivityStack中还持有ActivityStackSupervisor对象，这个是用来管理ActivityStacks的。
ActivityStack是由ActivityStackSupervisor来创建的，实际ActivityStackSupervisor就是用来管理ActivityStack的，继续看下面的ActivityStackSupervisor分析。
4.2.4 ActivityStackSupervisor
ActivityStackSupervisor，顾名思义，就是用来管理ActivityStack的。
frameworks/base/services/core/java/com/android/server/am/ActivityStackSupervisor.java
public class ActivityStackSupervisor extends ConfigurationContainer implements DisplayListener {
ActivityStack mHomeStack;//管理的是Launcher相关的任务
ActivityStack mFocusedStack;//管理非Launcher相关的任务
//创建ActivityStack
ActivityStack createStack(int stackId, ActivityStackSupervisor.ActivityDisplay display, boolean onTop) {
switch (stackId) {
case PINNED_STACK_ID:
//PinnedActivityStack是ActivityStack的子类
return new PinnedActivityStack(display, stackId, this, mRecentTasks, onTop);
default:
//创建一个ActivityStack
return new ActivityStack(display, stackId, this, mRecentTasks, onTop);
}
}
}
ActivityStackSupervisor内部有两个不同的ActivityStack对象：mHomeStack、mFocusedStack，用来管理不同的任务。ActivityStackSupervisor内部包含了创建ActivityStack对象的方法。
AMS初始化时会创建一个ActivityStackSupervisor对象。
所以，实际上，他们的关系应该是这样的：
4.3 从桌面启动一个Activity的栈管理机制
从桌面点击图标启动一个AActivity，可以看到，会多了一个Stack #1，这个Stack #1就是ActivityStackSupervisor中的mFocusedStack，mFocusedStack负责管理的是非Launcher相关的任务。同时也会创建一个新的ActivityRecord和TaskRecord，ActivityRecord放到TaskRecord中，TaskRecord则放进mFocusedStack中。
然后，我们从AActivity中启动一个BActivity,可以看到会创建一个新的ActivityRecord然后放到已有的TaskRecord栈顶。
5. Activity启动过程整体调用流程
代补充APP启动整体流程的源码
5.1 APP 到 AMS 阶段
5.2 AMS到APP阶段
5.3 APP内部
参考资料：
《Android 进阶解密》
《ActivityRecord、TaskRecord、ActivityStack以及Activity启动模式详解 - 简书 (jianshu.com)》
