ActivityManagerService (AMS) 是系统最核心的服务之一，运行在 system_server 进程。可以把它理解为 Android 系统的“大总管”，负责统一调度所有应用组件（Activity、Service、BroadcastReceiver、ContentProvider）的生命周期，并管理应用进程与系统内存。
AMS 的启动流程
启动前奏：SystemServer 的准备
main()->run()：SystemServer的入口从main()方法开始，它创建一个SystemServer实例并调用run()方法。- 准备主线程：
run()方法首先调用Looper.prepareMainLooper()为该进程准备消息队列，使其能处理后续的异步事务。 - 加载 Native 库：
System.loadLibrary("android_servers")加载系统服务所需的本地代码。
//frameworks/base/services/java/com/android/server/SystemServer.java
private void run() {
...
// 1. 创建Lopper
Looper.prepareMainLooper();
...
//2. 加载 native 库
System.loadLibrary("android_servers");
...
// 3. 创建系统 Context
createSystemContext();
try {
// 4. 启动引导服务、核心服务、其他服务
startBootstrapServices(t);
startCoreServices(t);
startOtherServices(t);
} catch (Throwable ex) {
throw ex;
} finally {
}
...
Looper.loop();
}
SystemServer.createSystemContext()：为系统进程自身创建“上下文”（Context）环境的关键步骤。它让SystemServer这个特殊的进程，也能像普通应用一样，方便地获取系统资源和执行组件操作。
//frameworks/base/services/java/com/android/server/SystemServer.java
private void createSystemContext() {
//创建并启动主线程的 `ActivityThread` 实例（如果尚未创建）。
ActivityThread activityThread = ActivityThread.systemMain();
//获取系统 Context
mSystemContext = activityThread.getSystemContext();
//为系统 Context 设置默认主题（通常为 `Theme.DeviceDefault` 或 `Theme.Holo`）。
//当系统服务需要 inflate 布局（如状态栏、导航栏）时，会使用此主题。如果不设置，
//可能会因缺少主题属性而崩溃。
mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
//与 `getSystemContext` 的区别**：
- **资源覆盖**：它可能包含 **Overlay 资源**（如厂商定制的 UI 样式）。
- **独立配置**：它的 `Configuration` 可能与 `mSystemContext` 不同（例如，针对屏幕密度、语言或 UI 模式做了调整）。
- **用途**：专门用于 SystemUI（状态栏、锁屏、通知栏）等系统级 UI 组件，避免与纯后台系统服务混用资源。
final Context systemUiContext = activityThread.getSystemUiContext();
systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}
//frameworks/base/core/java/android/app/ActivityThread.java
public static ActivityThread systemMain() {
...
ActivityThread thread = new ActivityThread();
//第一个参数为true，`true` 标志着这是一个系统进程
thread.attach(true, 0);
return thread;
}
private void attach(boolean system, long startSeq) {
...
if (!system) {
...
} else {
//设置 DDMS 应用名称system_process
android.ddm.DdmHandleAppName.setAppName("system_process",
UserHandle.myUserId());
try {
//创建 `Instrumentation`
mInstrumentation = new Instrumentation();
mInstrumentation.basicInit(this);
//为系统进程创建 Context
ContextImpl context = ContextImpl.createAppContext(
this, getSystemContext().mPackageInfo);
//创建Application 对象
mInitialApplication = context.mPackageInfo.makeApplication(true, null);
//调用`Application.onCreate()`
mInitialApplication.onCreate();
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate Application():" + e.toString(), e);
}
}
...
}
public ContextImpl getSystemContext() {
synchronized (this) {
if (mSystemContext == null) {
mSystemContext = ContextImpl.createSystemContext(this);
}
return mSystemContext;
}
}
这个 Context 对应framework-res.apk中的资源
- 它的 `Resources` 对象加载的是系统级资源（如 `@android:drawable/...`）。
- 没有关联任何 Activity，因此不能用于启动 UI 组件（如 `startActivity`），
但可用于获取系统服务（`getSystemService`）
//frameworks/base/core/java/android/app/ContextImpl.java
static ContextImpl createSystemContext(ActivityThread mainThread) {
//创建一个 `LoadedApk` 对象，代表一个已加载的 APK（这里是系统框架本身）
LoadedApk packageInfo = new LoadedApk(mainThread);
//第一个参数是 `null`（无 Activity），第二个是 `null`（无 ContentProvider 等），
//说明这是一个纯系统级 Context。
//关键字段：`ContextParams.EMPTY` 表示没有额外的参数（如 `display`、
//`session` 等），默认使用主显示屏。
ContextImpl context = new ContextImpl(null, mainThread, packageInfo,
ContextParams.EMPTY, null, null, null, null, null, 0, null, null);
//将 `LoadedApk` 中的 `Resources` 对象设置给 Context。
//`packageInfo.getResources()` 此时会调用
//用 `ResourcesManager.getResources()`，可能复用已经加载的系统资源实例
//（如果之前已有），避免重复创建
context.setResources(packageInfo.getResources());
//将 `Resources` 的配置（`Configuration`）和显示指标（`DisplayMetrics`）
//同步为 `ResourcesManager` 中的当前系统配置。
context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
context.mResourcesManager.getDisplayMetrics());
context.mContextType = CONTEXT_TYPE_SYSTEM_OR_SYSTEM_UI;
return context;
}
//创建LoadedApk
LoadedApk(ActivityThread activityThread) {
mActivityThread = activityThread;
mApplicationInfo = new ApplicationInfo();
//包名是android
mApplicationInfo.packageName = "android";
mPackageName = "android";
mAppDir = null;
mResDir = null;
...
//内部加载 /system/framework/framework-res.apk
mResources = Resources.getSystem();
...
}
public static Resources getSystem() {
synchronized (sSync) {
Resources ret = mSystem;
if (ret == null) {
//创建系统Resources
ret = new Resources();
mSystem = ret;
}
return ret;
}
}
//frameworks/base/core/java/android/content/res/Resources.java
private Resources() {
...
//调用AssetManager.getSystem()
mResourcesImpl = new ResourcesImpl(AssetManager.getSystem(), metrics, config,
new DisplayAdjustments());
}
//frameworks/base/core/java/android/content/res/AssetManager.java
public static AssetManager getSystem() {
synchronized (sSync) {
// FRAMEWORK_APK_PATH = "/system/framework/framework-res.apk"
createSystemAssetsInZygoteLocked(false, FRAMEWORK_APK_PATH);
return sSystem;
}
}
核心启动：startBootstrapServices
这是启动 AMS 最关键的一步，在 startBootstrapServices() 方法中完成。
-
先启动 ATMS：
ActivityTaskManagerService作为 AMS 的依赖，必须率先启动。它的Lifecycle类通过SystemServiceManager反射创建并启动。它负责管理所有与 Activity 任务栈相关的复杂逻辑。 -
再启动 AMS：随后通过
ActivityManagerService.Lifecycle.startService()创建 AMS 实例。关键之处在于，正在创建的 ATMS 实例会作为参数传递给 AMS 的构造函数，建立起依赖关系。- AMS 构造函数内部：会进行一系列初始化，如创建
"ActivityManager"和":procStart"线程、初始化前台/后台广播队列 (BroadcastQueue)、ActiveServices、ProcessList等核心数据结构。
- AMS 构造函数内部：会进行一系列初始化，如创建
//frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
...
//1. 先启动 ATMS
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
// 2. 再启动 AMS，并将 ATMS 实例作为参数传入
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm);
// 3. 设置 SystemServiceManager 引用
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
// 4. 设置 Installer 引用
//`Installer` 是与 `installd` 守护进程通信的接口，负责应用的安装、卸载、
//目录创建等底层操作。AMS 需要它来在应用安装/卸载时更新进程管理相关的状态
mActivityManagerService.setInstaller(installer);
...
//注册一系列 Binder 服务
mActivityManagerService.setSystemProcess();
}
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
//AOSP 中的死锁检测工具
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
//依赖注入容器
//持有 `systemContext`，用于后续创建 `ProcessList`、`AppOpsService`
//等依赖对象。这样做的好处是方便单元测试（可以注入 Mock 对象）
mInjector = new Injector(systemContext);
//systemContext,来自 createSystemContext()
mContext = systemContext;
//判断当前是否处于工厂测试模式（0=关闭，1=工厂测试，2=完整工厂测试）。
//影响某些系统行为的开关
mFactoryTest = FactoryTest.getMode();
//获取当前系统进程的 `ActivityThread` 实例
mSystemThread = ActivityThread.currentActivityThread();
//获取系统 UI Contex，后续用于显示对话框等 UI 操作
mUiContext = mSystemThread.getSystemUiContext();
//创建名为 "ActivityManager" 的后台线程，优先级为前台级别，
//**不允许 I/O 操作**（`allowIo=false` 意味着这个线程不应执行磁盘 I/O，避免
//阻塞）。这个线程用于处理 AMS 内部的消息队列
mHandlerThread = new ServiceThread(TAG,
THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
//获取 UI 线程的 Handler
mUiHandler = mInjector.getUiHandler(this);
//创建一个专门用于启动应用进程的线程。进程启动是耗时操作，分离到独立线程避免
//阻塞主 Handler 的消息处理。
mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
mProcStartHandlerThread.start();
mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
//从 `Settings.Global` 读取可运行时调整的系统参数（如后台进程数、缓存大小等），
//并监听设置变化自动更新
mConstants = new ActivityManagerConstants(mContext, this, mHandler);
//维护当前活跃的 UID 列表。`postChangesToAtm=true` 表示 UID 状态变化时
//要通知 `ActivityTaskManagerService`（如进程优先级变化影响任务栈）
final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
//获取平台兼容性服务，用于管理应用的兼容性策略（如针对旧版应用的兼容性处理）
mPlatformCompat = (PlatformCompat) ServiceManager.getService(
Context.PLATFORM_COMPAT_SERVICE);
//负责所有正在运行的进程的管理（创建、销毁、优先级调整等）。
//通过 Injector 创建便于测试。
mProcessList = mInjector.getProcessList(this);
mProcessList.init(this, activeUids, mPlatformCompat);
//应用性能分析器：监控应用 CPU 使用率、内存使用情况，与低内存检测器
//(`LowMemDetector`) 配合，在内存紧张时触发清理策略。
mAppProfiler = new AppProfiler(this, BackgroundThread.getHandler().getLooper(),
new LowMemDetector(this));
//幽灵进程列表：管理那些已经死亡但仍在 Binder 缓存中存在的进程引用，防止内存泄漏。
mPhantomProcessList = new PhantomProcessList(this);
//**OOM 调整器**：核心组件！根据应用状态（前台/后台/服务等）动态调整进程的
//OOM_adj 值，决定在内存紧张时哪些进程被优先杀死
mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
//前台广播常量：从 `Settings.Global` 读取配置，并设置超时时间为 10 秒。
//前台广播有严格的超时限制。
final BroadcastConstants foreConstants = new BroadcastConstants(
Settings.Global.BROADCAST_FG_CONSTANTS);
foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
//**后台广播常量**：超时时间 60 秒，比前台广播宽松
final BroadcastConstants backConstants = new BroadcastConstants(
Settings.Global.BROADCAST_BG_CONSTANTS);
backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
...
//创建三个广播队列
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", foreConstants, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", backConstants, true);
mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
"offload", offloadConstants, true);
mBroadcastQueues[0] = mFgBroadcastQueue; //高优先级，立即处理
mBroadcastQueues[1] = mBgBroadcastQueue; //低优先级，允许延迟
mBroadcastQueues[2] = mOffloadBroadcastQueue;
//管理所有正在运行的 `Service` 的生命周期（启动、绑定、停止等
mServices = new ActiveServices(this);
//管理 ContentProvider 的发布、获取和权限控制。`true` 参数表示启
//用 `ActivityManagerService` 的权限控制
mCpHelper = new ContentProviderHelper(this, true);
//**包看门狗**：监控应用程序的稳定性，如果某个应用频繁崩溃，会触发恢复策略（
//如清除数据或禁用）。注意这里使用的是 **`mUiContext`**，因为它可能需要显示系统对话框
//提示用户
mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
//**应用错误处理器**：处理应用崩溃、ANR 等错误，显示"应用已停止"等对话框。
//同样使用 `mUiContext` 来显示 UI。
mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
//管理 UID 状态变化（如进程被杀死、UID 被移除）的回调通知
mUidObserverController = new UidObserverController(mUiHandler);
final File systemDir = SystemServiceManager.ensureSystemDir();
//**电池统计服务**：从磁盘读取历史电池数据，并调度定期写入任务。
//使用 `systemContext`（非 UI Context）
mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
BackgroundThread.get().getHandler());
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.scheduleWriteToDisk();
...
//记录每个进程的 CPU 使用时间、内存使用量等统计数据，用于 `dumpsys procstats` 命令。
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
...
//Intent 防火墙：根据系统配置的规则文件（如 `/system/etc/intent-
//firewall.xml`），过滤或阻止某些 Intent 的发送。
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
...
//隐藏 API 黑名单：加载Android隐藏 API 访问限制策略，控制应用对非公开 API 的访问。
mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
//看门狗,检查 AMS 是否死锁
Watchdog.getInstance().addMonitor(this);
//监控 AMS 的主 Handler 是否卡住（长时间未处理消息）
Watchdog.getInstance().addThread(mHandler);
//立即执行一次 OOM 调整，初始化所有正在运行进程的优先级
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
...
}
setSystemProcess()：这是让 AMS “持证上岗”的关键一步。它向系统的ServiceManager注册"activity"等一系列 Binder 服务，使得其他进程可以通过 Binder 机制与 AMS 通信。
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void setSystemProcess() {
try {
// 1. 注册核心服务AMS
//`allowIsolated=true`：允许隔离进程（如 WebView 渲染进程）
//访问 `activity` 服务。Android 8.0+ 引入了隔离进程，默认无法访问系统服务，
//这里显式放行
//`DUMP_FLAG_PRIORITY_*`：控制 `dumpsys` 命令的输出优先级，
//`CRITICAL` 级别的信息在系统负载高时仍会输出
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
// 2. 注册一系列辅助调试和服务管理的 Binder 服务
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_HIGH);
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
...
//通过PMS查询 "android" 包的 ApplicationInfo
//`"android"` 是系统框架包，对应 `/system/framework/framework-res.apk`
//，包含了系统级别的资源（如 `android.R` 中的资源）。
//`STOCK_PM_FLAGS` 通常包含 `GET_SHARED_LIBRARY_FILES` 等标志
//`MATCH_SYSTEM_ONLY` 确保只匹配系统应用，防止第三方包名冲突
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
//为 system_server 进程安装 ApplicationInfo
//`mSystemThread` 是 `ActivityThread` 实例，代表 system_server
//进程的主线程。 这个方法将查询到的 `ApplicationInfo` 注入到
//系统 Context 中，完成系统进程的 Context 初始化。
//之后，system_server 就能正确访问 `android` 包中的资源文件了
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
synchronized (this) {
//为 system_server 进程创建 ProcessRecord 并加入管理
//new HostingRecord("system")标记这个进程是由系统直接托管的，
//而不是由某个应用组件（如 Activity）触发的
ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
false,
0,
new HostingRecord("system"));
//设置为持久化进程，系统会永远保留它，不会被 Low Memory Killer 杀死
app.setPersistent(true);
//`MY_PID` 是 `Process.myPid()`，即 system_server 自身的 PID
app.setPid(MY_PID);
//设置进程的最大 OOM 调整值为 `SYSTEM_ADJ`（约 -900），这是极高的优先级
app.mState.setMaxAdj(ProcessList.SYSTEM_ADJ);
//将进程标记为活跃状态，关联其 `ApplicationThread`
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
//将 PID 加入 AMS 的 PID 映射表，用于快速查找进程
addPidLocked(app);
//将 system_server 加入 LRU 管理列表
updateLruProcessLocked(app, false, null);
//立即计算一次所有进程的 OOM 优先级，确保 system_server 处于最高优先级
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
}
} catch (PackageManager.NameNotFoundException e) {
throw new RuntimeException(
"Unable to find android system package", e);
}
...
}
//将之前那个“空壳”的系统 Context，与从 `PackageManagerService` 查询到的真实“android”
//包信息(`framework-res.apk`)进行关联，完成系统运行环境的最终初始化
//frameworks/base/core/java/android/app/ActivityThread.java
public void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
synchronized (this) {
//调用ContextImpl.installSystemApplicationInfo();
getSystemContext().installSystemApplicationInfo(info, classLoader);
...
}
}
//frameworks/base/core/java/android/app/ContextImpl.java
void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
//mPackageInfo是LoadedApk实例
mPackageInfo.installSystemApplicationInfo(info, classLoader);
}
//frameworks/base/core/java/android/app/LoadedApk.java
void installSystemApplicationInfo(ApplicationInfo info, ClassLoader classLoader) {
//进行断言检查，确保传入的 `ApplicationInfo` 的包名是 `"android"`。
//这保证了此方法只用于系统框架本身
assert info.packageName.equals("android");
//将传入的 `ApplicationInfo` 对象赋值给 `LoadedApk` 内部
//的 `mApplicationInfo` 字段，替换掉之前在 `new LoadedApk(mainThread)` 构造
//时创建的简易 `ApplicationInfo`
mApplicationInfo = info;
//将传入的 `ClassLoader` 保存为 `mClassLoader`，为后续加载系统框架中的类做准备
mDefaultClassLoader = classLoader;
mAppComponentFactory = createAppFactory(info, mDefaultClassLoader);
mClassLoader = mAppComponentFactory.instantiateClassLoader(mDefaultClassLoader,
new ApplicationInfo(mApplicationInfo));
}
installSystemProviders()：为system_server自身安装核心的SettingsProvider，确保系统服务能访问设置数据库。
//frameworks/base/services/java/com/android/server/SystemServer.java
private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
...
//getContentProviderHelper = `ContentProviderHelper`
//查找需要安装的Provider，即SettingsProvider，将 Provider 注册到 AMS 中
mActivityManagerService.getContentProviderHelper().installSystemProviders();
...
}
//frameworks/base/services/core/java/com/android/server/am/ContentProviderHelper.java
public final void installSystemProviders() {
List<ProviderInfo> providers;
synchronized (mService) {
//查找名为 `"system"`、UID 为 `SYSTEM_UID`（1000）的 `ProcessRecord`
ProcessRecord app = mService.mProcessList
.getProcessNamesLOSP().get("system", SYSTEM_UID);
//遍历该进程安装的所有 APK，查询其中声明的 `ContentProvider`，
//返回 `ProviderInfo` 列表
providers = generateApplicationProvidersLocked(app);
if (providers != null) {
for (int i = providers.size() - 1; i >= 0; i--) {
ProviderInfo pi = providers.get(i);
//只安装标记为系统应用（`FLAG_SYSTEM`）的 APK 中的 Provider。
//这是安全措施，防止非系统应用意外在 system_server 中发布 Provider
//实际被安装的 Provider 只有一个——`SettingsProvider`。
//它位于 `/system/framework/framework-res.apk` 中，是系统设置
//数据的唯一提供者
if ((pi.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
providers.remove(i);
}
}
}
}
if (providers != null) {
//mSystemThread = ActivityThread
//安装 Provider 到系统进程中
mService.mSystemThread.installSystemProviders(providers);
}
synchronized (this) {
//标志位表示系统 Provider 已经安装完毕
mSystemProvidersInstalled = true;
}
mService.mConstants.start(mService.mContext.getContentResolver());
//监听核心设置（如 `Settings.Global.DEVICE_PROVISIONED`），
//当系统首次配置完成时，AMS 需要据此更新状态
mService.mCoreSettingsObserver = new CoreSettingsObserver(mService);
//**ATMS 也需要安装自己的系统 Provider**。它内部会
//查询 `ActivityTaskManagerInternal` 相关的设置，
//如窗口动画缩放比例、过渡动画开关等
mService.mActivityTaskManager.installSystemProviders();
...
//**Rescue Party（救援小队）** 是 Android 8.0 引入的一个**系统自救机制**。
//当系统服务（如 SystemUI、SystemServer）连续崩溃多次时，
//它会采取逐步升级的恢复措施：
//1.轻度恢复：重启发生崩溃的服务。
//2.中度恢复：如果问题持续，重启 SystemUI。
//3.重度恢复：如果依然无效，触发设备进入恢复模式（Recovery Mode）或执行出厂重置。
RescueParty.onSettingsProviderPublished(mService.mContext);
}
安装系统Provider(SettingsProvider)
ContentProviderHolder：在 ActivityThread 和 AMS 间传递 Provider 信息
ProviderClientRecord：缓存 Provider 完整信息，供查询复用
ProviderRefCount：管理外部 Provider 的引用计数
IContentProvider：跨进程 Binder 接口，定义 CRUD 操作的 AIDL 接口
ContentProvider.Transport：Binder 服务端实现，接收 IPC 请求
LoadedApk：LoadedApk 是 Android 框架中一个至关重要的类。当一个应用进程被创建时，系统就会为它生成一个全局唯一的 LoadedApk 对象，这个对象几乎包含了运行一个 APK 所需的一切，是其得以存在和运行的“根”。
//frameworks/base/core/java/android/app/ActivityThread.java
//安装系统Provider
public final void installSystemProviders(List<ProviderInfo> providers) {
if (providers != null) {
installContentProviders(mInitialApplication, providers);
}
}
//frameworks/base/core/java/android/app/ActivityThread.java
private void installContentProviders(
Context context, List<ProviderInfo> providers) {
...
for (ProviderInfo cpi : providers) {
...
//遍历安装Provider
ContentProviderHolder cph = installProvider(context, null, cpi,
false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
...
}
try {
//发步到AMS
ActivityManager.getService().publishContentProviders(
getApplicationThread(), results);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
//frameworks/base/core/java/android/app/ActivityThread.java
private ContentProviderHolder installProvider(Context context,
ContentProviderHolder holder, ProviderInfo info,
boolean noisy, boolean noReleaseNeeded, boolean stable) {
ContentProvider localProvider = null;
IContentProvider provider;
if (holder == null || holder.provider == null) {
Context c = null;
//创建Context
ApplicationInfo ai = info.applicationInfo;
//Provider 与当前进程属于同一个包
if (context.getPackageName().equals(ai.packageName)) {
//直接复用当前 Context
c = context;
} else if (mInitialApplication != null &&
mInitialApplication.getPackageName().equals(ai.packageName)) {
//Provider 属于应用的主包,使用应用的 Application Context
c = mInitialApplication;
} else {
try {
//Provider 来自其他 APK（如系统进程加载 SettingsProvider）
//**创建新的 Package Context**，加载目标 APK 的资源和代码
c = context.createPackageContext(ai.packageName,
Context.CONTEXT_INCLUDE_CODE);
} catch (PackageManager.NameNotFoundException e) {
// Ignore
}
}
if (c == null) {
return null;
}
if (info.splitName != null) {
try {
//Android 支持 APK 拆分（如基础 APK + 配置 APK），
//如果 Provider 位于某个 Split 中，需要创建对应的 Context
c = c.createContextForSplit(info.splitName);
} catch (NameNotFoundException e) {
throw new RuntimeException(e);
}
}
//Attribution Tag：Android 12 引入的新特性，用于标识资源访问的来源
//（如相机、定位），便于系统追踪和权限管理
if (info.attributionTags != null && info.attributionTags.length > 0) {
final String attributionTag = info.attributionTags[0];
c = c.createAttributionContext(attributionTag);
}
try {
final java.lang.ClassLoader cl = c.getClassLoader();
//从 `ActivityThread` 的缓存中获取 `LoadedApk`（已加载的 APK 信息）
LoadedApk packageInfo = peekPackageInfo(ai.packageName, true);
if (packageInfo == null) {
// System startup case.
//如果缓存中没有（系统启动时的首次加载），
//则使用系统 Context 的 `LoadedApk`
packageInfo = getSystemContext().mPackageInfo;
}
//反射实例化 Provider
localProvider = packageInfo.getAppFactory()
.instantiateProvider(cl, info.name);
//返回 Provider 内部的 `Transport` 对象，
//这是一个继承自 `ContentProviderNative` 的 Binder 服务端对象
provider = localProvider.getIContentProvider();
if (provider == null) {
return null;
}
//内部会调用 `Provider.onCreate()`，完成业务初始化（如打开数据库）
localProvider.attachInfo(c, info);
} catch (java.lang.Exception e) {
return null;
}
} else {
provider = holder.provider;
}
ContentProviderHolder retHolder;
synchronized (mProviderMap) {
IBinder jBinder = provider.asBinder();
//已存在，使用已有的
if (localProvider != null) {
ComponentName cname = new ComponentName(info.packageName, info.name);
//从缓存中查找ProviderClientRecord
ProviderClientRecord pr = mLocalProvidersByName.get(cname);
if (pr != null) {
provider = pr.mProvider;
} else {
//创建 ContentProviderHolder
holder = new ContentProviderHolder(info);
holder.provider = provider;
holder.noReleaseNeeded = true;
//将 `"settings"` 注册到 `mProviderMap`
pr = installProviderAuthoritiesLocked(provider, localProvider, holder);
mLocalProviders.put(jBinder, pr);
mLocalProvidersByName.put(cname, pr);
}
retHolder = pr.mHolder;
} else {
ProviderRefCount prc = mProviderRefCountMap.get(jBinder);
//已存在，增加引用计数
if (prc != null) {
if (!noReleaseNeeded) {
incProviderRefLocked(prc, stable);
try {
//移除旧的引用
ActivityManager.getService().removeContentProvider(
holder.connection, stable);
} catch (RemoteException e) {
//do nothing content provider object is dead any way
}
}
} else {
ProviderClientRecord client = installProviderAuthoritiesLocked(
provider, localProvider, holder);
//永远不被释放，计数极高
if (noReleaseNeeded) {
prc = new ProviderRefCount(holder, client, 1000, 1000);
} else {
//stable = true 持有稳定引用，Provider 进程不会被回收
//stable = false 持有不稳定引用，Provider 进程可能被回收
//稳定引用：持有方会阻止 Provider 所在进程被杀死
//（如长期持有 Cursor 的场景）。
//不稳定引用：持有方不会阻止进程回收（如短时查询操作）。
prc = stable
? new ProviderRefCount(holder, client, 1, 0)
: new ProviderRefCount(holder, client, 0, 1);
}
mProviderRefCountMap.put(jBinder, prc);
}
retHolder = prc.holder;
}
}
return retHolder;
}
//应用进程将ContentProvider发布到AMS，使其对外可用
//frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public final void publishContentProviders(IApplicationThread caller,
List<ContentProviderHolder> providers) {
...
//mCpHelper = ContentProviderHelper
mCpHelper.publishContentProviders(caller, providers);
...
}
//frameworks/base/services/core/java/com/android/server/am/ContentProviderHelper.java
void publishContentProviders(IApplicationThread caller, List<ContentProviderHolder> providers) {
if (providers == null) {
return;
}
//拒绝隔离进程（如 WebView 渲染进程）发布 Provider，防止恶意发布
mService.enforceNotIsolatedCaller("publishContentProviders");
synchronized (mService) {
//查找发起请求的进程
final ProcessRecord r = mService.getRecordForAppLOSP(caller);
//如果找不到，说明发起请求的进程可能已经死亡或不存在，抛出安全异常
if (r == null) {
throw new SecurityException("Unable to find app for caller " + caller
+ " (pid=" + Binder.getCallingPid()
+ ") when publishing content providers");
}
//清除Binder调用的调用者 UID/PID
//发布 Provider 的过程中，AMS 需要执行一些需要系统权限的操作（
//如更新 `mProviderMap`、发送系统消息等）。如果不清除调用者身份，
//系统可能会因为调用者权限不足而拒绝操作
final long origId = Binder.clearCallingIdentity();
boolean providersPublished = false;
//遍历并发布 Provider
for (int i = 0, size = providers.size(); i < size; i++) {
ContentProviderHolder src = providers.get(i);
//src.provider == null Binder 引用为空，说明 Provider 实例化失败，跳过
if (src == null || src.info == null || src.provider == null) {
continue;
}
ContentProviderRecord dst = r.mProviders.getProvider(src.info.name);
//查找AMS中预创建的 `ContentProviderRecord`
//应用进程在启动时，AMS 的 `generateApplicationProvidersLocked()`
//已经解析了该应用声明 `AndroidManifest.xml` 中的 Provider，并创建了
//对应的 `ContentProviderRecord`。这里只是将 Binder 引用绑定到
//已有记录上。
if (dst == null) {
continue;
}
providersPublished = true;
ComponentName comp = new ComponentName(dst.info.packageName, dst.info.name);
//通过组件名缓存
mProviderMap.putProviderByClass(comp, dst);
String[] names = dst.info.authority.split(";");
for (int j = 0; j < names.length; j++) {
//通过 URI 的 authority缓存
mProviderMap.putProviderByName(names[j], dst);
}
boolean wasInLaunchingProviders = false;
//mLaunchingProviders存储正在启动中但尚未发布的 Provider
//当客户端请求一个 Provider 时，如果该 Provider 尚未发布，
//AMS 会将该 Provider 添加到 `mLaunchingProviders` 列表中。
//同时，AMS 会发送一个超时消息（`WAIT_FOR_CONTENT_PROVIDER_TIMEOUT_MSG`）
//如果 Provider 在规定时间内未发布，系统会认为该进程发生死锁或崩溃，
//主动清理。
//当 Provider 成功发布后，需要：从 `mLaunchingProviders` 中移除
//删除超时消息，避免误触发
for (int j = 0, numLaunching = mLaunchingProviders.size(); j < numLaunching; j++) {
if (mLaunchingProviders.get(j) == dst) {
//从 `mLaunchingProviders` 移除
mLaunchingProviders.remove(j);
wasInLaunchingProviders = true;
j--;
numLaunching--;
}
}
if (wasInLaunchingProviders) {
mService.mHandler.removeMessages(
ActivityManagerService.WAIT_FOR_CONTENT_PROVIDER_TIMEOUT_MSG, dst);
mService.mHandler.removeMessages(
ActivityManagerService.CONTENT_PROVIDER_PUBLISH_TIMEOUT_MSG, r);
}
//将 Provider 所在的包名与进程关联（防御性编程，通常已存在）
r.addPackage(dst.info.applicationInfo.packageName,
dst.info.applicationInfo.longVersionCode, mService.mProcessStats);
synchronized (dst) {
//将 Binder 引用绑定到 `ProviderRecord`，Provider 正式对外可用
dst.provider = src.provider;
//设置 Provider 所在的进程记录
dst.setProcess(r);
//唤醒所有等待此 Provider 发布的线程（见第五步中的等待场景）
dst.notifyAll();
//触发发布状态回调，更新统计信息
dst.onProviderPublishStatusLocked(true);
}
//重置重启计数，表示 Provider 已成功发布
dst.mRestartCount = 0;
}
// update the app's oom adj value and each provider's usage stats
if (providersPublished) {
//重新计算该进程的 OOM 优先级
mService.updateOomAdjLocked(r, OomAdjuster.OOM_ADJ_REASON_GET_PROVIDER);
...
}
//恢复Binder调用的调用者 UID/PID
Binder.restoreCallingIdentity(origId);
}
}
就绪与收尾
- 启动其他服务：AMS 启动后，
SystemServer会继续启动startCoreServices()和startOtherServices()中定义的其他大量系统服务。 systemReady()：当所有服务准备就绪，会调用 AMS 的systemReady()方法，这标志着系统进入就绪状态。在此方法中，系统会启动 SystemUI 并最终启动 Launcher 桌面应用，完成整个开机流程。
