android12 ActivityManagerService开机启动分析

ActivityManagerService (AMS) 是系统最核心的服务之一，运行在 system_server 进程。可以把它理解为 Android 系统的“大总管”，负责统一调度所有应用组件（Activity、Service、BroadcastReceiver、ContentProvider）的生命周期，并管理应用进程与系统内存。

AMS 的启动流程

启动前奏：SystemServer 的准备

1. main() -> run() ：SystemServer 的入口从 main() 方法开始，它创建一个 SystemServer 实例并调用 run() 方法。
2. 准备主线程：run() 方法首先调用 Looper.prepareMainLooper() 为该进程准备消息队列，使其能处理后续的异步事务。
3. 加载 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();
}

核心启动：startBootstrapServices

这是启动 AMS 最关键的一步，在 startBootstrapServices() 方法中完成。

1. 先启动 ATMS：ActivityTaskManagerService 作为 AMS 的依赖，必须率先启动。它的 Lifecycle 类通过 SystemServiceManager 反射创建并启动。它负责管理所有与 Activity 任务栈相关的复杂逻辑。

2. 再启动 AMS：随后通过 ActivityManagerService.Lifecycle.startService() 创建 AMS 实例。关键之处在于，正在创建的 ATMS 实例会作为参数传递给 AMS 的构造函数，建立起依赖关系。

   • AMS 构造函数内部：会进行一系列初始化，如创建 "ActivityManager" 和 "android.ui" 线程、初始化前台/后台广播队列 (BroadcastQueue)、ActiveServices、ProcessList 等核心数据结构。

3. setSystemProcess() ：这是让 AMS “持证上岗”的关键一步。它向系统的 ServiceManager 注册 "activity" 等一系列 Binder 服务，使得其他进程可以通过 Binder 机制与 AMS 通信。

4. installSystemProviders() ：为 system_server 自身安装核心的 SettingsProvider，确保系统服务能访问设置数据库。

//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 void setSystemProcess() {
    try {
        // 1. 注册核心服务 "activity"，这是 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);
    }

   ...
}

//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);
    }
}

就绪与收尾

1. 启动其他服务：AMS 启动后，SystemServer 会继续启动 startCoreServices() 和 startOtherServices() 中定义的其他大量系统服务。
2. systemReady() ：当所有服务准备就绪，会调用 AMS 的 systemReady() 方法，这标志着系统进入就绪状态。在此方法中，系统会启动 SystemUI 并最终启动 Launcher 桌面应用，完成整个开机流程。