Android Framework重要服务之ActivityManagerService(一) AMS启动流程

wise丰
1,726 阅读13分钟

ActivityManagerService(简称AMS)是Android系统中一个特别重要的系统服务，也是我们上层APP打交道最多的系统服务之一，AMS主要负责四大组件的启动、切换、调度以及应用进程的管理和调度工作。所有的APP应用都需要与AMS打交道，本章将结合Android11源码分析AMS的启动流程。

一、启动AMS服务

AMS作为系统核心服务之一，其启动流程位于frameworks/base/services/java/com/android/server/SystemServer.java，相关代码如下：

private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    ...
    
    // 开始启动AMS
    t.traceBegin("StartActivityManager");
    
    //启动ActivityTaskManagerService服务，简称ATM,Android 10+新引入功能，用来管理Activity的启动、调度等功能
    ActivityTaskManagerService atm = mSystemServiceManager.startService(
            ActivityTaskManagerService.Lifecycle.class).getService();
            
    //启动服务 ActivityManagerService，简称AMS
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(
            mSystemServiceManager, atm);
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    mWindowManagerGlobalLock = atm.getGlobalLock();
    t.traceEnd();
    ...
    
    // 设置系统进程
    t.traceBegin("SetSystemProcess");
    mActivityManagerService.setSystemProcess();
    t.traceEnd();
}

从上述代码可知，在android 10+的版本中引入了一个新的功能，简称ATM，稍后会分析该功能。

二、AMS启动流程

1. System Context初始化

SystemServer的run函数中，在启动AMS之前，调用了createSystemContext方法，主要用来是初始化 System Context和SystemUi Context，并设置主题。
当SystemServer 调用createSystemContext()完毕后，完成以下两个内容：

  1. 得到了一个ActivityThread对象，它代表当前进程 (此时为系统进程) 的主线程；
  2. 得到了一个Context对象，对于SystemServer而言，它包含的Application运行环境与framework-res.apk有关。 frameworks/base/services/java/com/android/server/SystemServer.java
private void createSystemContext() {
    ActivityThread activityThread = ActivityThread.systemMain();
    
    //获取system context
    mSystemContext = activityThread.getSystemContext();
    //设置系统主题
    mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
 
    //获取systemui context
    final Context systemUiContext = activityThread.getSystemUiContext();
    //设置systemUI 主题
    systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}

（1）systemMain()

systemMain函数主要作用是创建ActivityThread对象，然后调用该对象的attach方法。 frameworks/base/core/java/android/app/ActivityThread.java

public static ActivityThread systemMain() {
    ThreadedRenderer.initForSystemProcess();
    // 获取ActivityThread对象
    ActivityThread thread = new ActivityThread();
    thread.attach(true, 0);
    return thread;
}

(1.a) ActivityThread 对象创建

ActivityThread是Framework层中一个非常重要的类，它代表一个应用进程的主线程，其职责就是调度及执行在该线程中运行的四大组件,相关源码在frameworks/base/services/java/com/android/server/SystemServer.java下。

public final class ActivityThread extends ClientTransactionHandler {
    ...
    
    // 定义了AMS与应用通信的接口，初始化ApplicationThread的对象
    @UnsupportedAppUsage
    final ApplicationThread mAppThread = new ApplicationThread();

    // 拥有自己的looper，说明ActivityThread确实可以代表事件处理线程
    @UnsupportedAppUsage
    final Looper mLooper = Looper.myLooper();

    // Hadndle初始化,ActivityThread中大量事件处理依赖此Handler
    @UnsupportedAppUsage
    final H mH = new H();
    final Executor mExecutor = new HandlerExecutor(mH);
    
    // 用于保存该进程的ActivityRecord
    final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
 
    //用于保存进程中的Service
    final ArrayMap<IBinder, Service> mServices = new ArrayMap<>();
 
    //用于保存进程中的Application
    final ArrayList<Application> mAllApplications
        = new ArrayList<Application>();
    // 构造函数
    @UnsupportedAppUsage
    ActivityThread() {
        // 使用单例模式获得一个ResourcesManager实例
        mResourcesManager = ResourcesManager.getInstance();
    }

注意到此处的ActivityThread创建于SystemServer进程中。
由于SystemServer中也运行着一些系统APK，例如framework-res.apk、SettingsProvider.apk等，因此也可以认为SystemServer是一个特殊的应用进程。
AMS负责管理和调度进程，因此AMS需要通过Binder机制和应用进程通信。
为此，Android提供了一个IApplicationThread接口，该接口定义了AMS和应用进程之间的交互函数。

(1.b) attach方法

ActivityThread的attach方法将进程分为应用进程、系统进程2个部分进行处理，其中对于系统进程，最重要的工作就是创建了Instrumentation、Application和Context三个重要成员，这三个成员的职责依次为：

  • Instrumentation: Android中的一个工具类，当该类被启用时，它将优先于应用中其它的类被初始化。
  • Context: Android中的一个抽象类，用于维护应用运行环境的全局信息,通过Context可以访问应用的资源和类，甚至进行系统级的操作，例如启动Activity、发送广播等。
  • Application: 用于保存应用的全局状态。 该部分代码位于frameworks/base/core/java/android/app/ActivityThread.java。
private void attach(boolean system, long startSeq) {
    sCurrentActivityThread = this;
    mConfigurationController = new ConfigurationController(this);
    mSystemThread = system;
    
    if (!system) {
        // 处理应用进程
        ...
        
    } else {
        // 系统进程的处理流程，该情况只在SystemServer中处理
        android.ddm.DdmHandleAppName.setAppName("system_process",
                UserHandle.myUserId());
        try {
            // 创建ActivityThread中的重要成员：Instrumentation、 Application 和 Context

            // 初始化Instrumentation,它是Android中的一个工具类，当该类被启用时，它将优先于应用中其它的类被初始化
            mInstrumentation = new Instrumentation();
            mInstrumentation.basicInit(this);

            // 创建系统的Context
            ContextImpl context = ContextImpl.createAppContext(
                    this, getSystemContext().mPackageInfo);

            // 调用LoadedApk的makeApplication函数,Application类用于保存应用的全局状态
            mInitialApplication = context.mPackageInfo.makeApplication(true, null);
            mInitialApplication.onCreate();
        } catch (Exception e) {
            throw new RuntimeException(
                    "Unable to instantiate Application():" + e.toString(), e);
        }
    }

(2) getSystemContext()

在SystemServer#createSystemContext()中调用的getSystemContext()方法用于创建并返回一个System Context，在这个方法中调用了ContextImpl.createSystemContext方法，该方法会创建一个LoadedApk，然后初始化一个ContextImpl对象。
注意到createSystemContext函数中，创建的LoadApk对应packageName为”android”，也就是framwork-res.apk，由于该APK仅供SystemServer进程使用，因此创建的Context被定义为System Context,由于PMS还未启动，所以现在该LoadedApk还没有得到framwork-res.apk实际的信息，当PMS启动，完成对应的解析后，AMS将重新设置这个LoadedApk。

frameworks/base/services/java/com/android/server/SystemServer.java

public ContextImpl getSystemContext() {
    synchronized (this) {
        if (mSystemContext == null) {
            // 调用ContextImpl的createSystemContext方法
            mSystemContext = ContextImpl.createSystemContext(this);
        }
        return mSystemContext;
    }
}

// [frameworks/base/core/java/android/app/ContextImpl.java]
static ContextImpl createSystemContext(ActivityThread mainThread) {
    //创建LoadedApk类，代表一个加载到系统中的APK,由于PMS还没有启动，所以此时的LoadedApk没有任何内容
    LoadedApk packageInfo = new LoadedApk(mainThread);

    // 获取ContextImpl对象
    ContextImpl context = new ContextImpl(null, mainThread, packageInfo,
            ContextParams.EMPTY, null, null, null, null, null, 0, null, null);
    
    // 初始化资源信息
    context.setResources(packageInfo.getResources());
    context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
            context.mResourcesManager.getDisplayMetrics());
    context.mContextType = CONTEXT_TYPE_SYSTEM_OR_SYSTEM_UI;
    return context;
}

2. ActivityTaskManagerService(ATM) 服务启动

ActivityTaskManagerService简称ATM，是Andorid 10+引入的一个新功能,用来管理Activity的启动、调度等功能，其先于AMS启动，下面来分析ATM的启动流程。 frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

public static final class Lifecycle extends SystemService {
        private final ActivityTaskManagerService mService;
        ...
        
        public Lifecycle(Context context) {
            super(context);
            // 初始化ActivityTaskManagerService对象
            mService = new ActivityTaskManagerService(context);
        }
 
        @Override
        public void onStart() {
            publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
            // 启动ATM服务
            mService.start();
        }
        ...
        
    }
    
public ActivityTaskManagerService(Context context) {
        //拿到System Context
        mContext = context;  
        mFactoryTest = FactoryTest.getMode();
 
        //取出的是ActivityThread的静态变量sCurrentActivityThread
        //这意味着mSystemThread与SystemServer中的ActivityThread一致
        mSystemThread = ActivityThread.currentActivityThread();
        
        //拿到System UI Context
        mUiContext = mSystemThread.getSystemUiContext();
        mLifecycleManager = new ClientLifecycleManager();
        //拿到LocalService的对象
        mInternal = new LocalService();
        GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
    }

private void start() {
    // 将 ActivityTaskManagerInternal添加到本地服务的全局注册表中
    LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}

从以上代码可以看出，AMT的启动分为两个部分：

  • 创建ActivityTaskManagerService: 这一步初始化了ActivityTaskManagerService对象，这一对象以前是属于AMS的，用于Activity的管理，现在被移动到了ATM中，同时，该对象所在的路径也被移动到frameworks/base/services/core/java/com/android/server/wm路径中,这个路径原先归WindowManagerService控制，从这也可以看出，谷歌的目的也是希望在将来把activity和window融合在一起，减少冗余代码以及AMS和WMS的协调工作。
  • start： start方法较为简单，将ActivityTaskManagerInternal添加到本地服务的全局注册表中 至此ATM启动完成。

3. ActivityManagerService(AMS) 服务启动

在Android 11中,AMS负责service,broadcast,provider的管理和调度。
AMS的启动代码位于frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java,需要注意的是，AMS启动方法所在类名也为Lifecycle，这与ATM启动方法所在的类名相同，不同点在于：

  • ATM位于frameworks/base/services/core/java/com/android/server/wm,而AMS位于rameworks/base/services/core/java/com/android/server/am
public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;
    private static ActivityTaskManagerService sAtm;
 
    public Lifecycle(Context context) {
        super(context);
        // 初始化ActivityManagerService，传入ATM的对象
        mService = new ActivityManagerService(context, sAtm);
    }
 
    @Override
    public void onStart() {
        // 启动AMS服务
        mService.start();
    }
    ...

(1) 初始化AMS对象

Android 11中,Activity的管理和调度放入到ATM中执行，AMS中保留service,broadcast,provider的管理和调度。
构造函数初始化主要工作就是初始化一些变量，供之后的service,broadcast,provider的管理和调度。 frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
        ...
        
        //AMS的运行上下文与SystemServer一致
        mContext = systemContext;
        ...
        
        //取出的是ActivityThread的静态变量sCurrentActivityThread, 这意味着mSystemThread与SystemServer中的ActivityThread一致
        mSystemThread = ActivityThread.currentActivityThread();
        mUiContext = mSystemThread.getSystemUiContext();
 
        mHandlerThread = new ServiceThread(TAG,
                THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        
        //AMS消息处理器
        mHandler = new MainHandler(mHandlerThread.getLooper());
        
        //UiHandler对应于Android中的UiThread
        mUiHandler = mInjector.getUiHandler(this);
        ...
        
        //创建 BroadcastQueue 前台广播对象，处理超时时长是 10s
        mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "foreground", foreConstants, false);
        //创建 BroadcastQueue 后台广播对象，处理超时时长是 60s
        mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "background", backConstants, true);
        //创建 BroadcastQueue 分流广播对象，处理超时时长是 60s
        mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
                "offload", offloadConstants, true);
        mBroadcastQueues[0] = mFgBroadcastQueue;
        mBroadcastQueues[1] = mBgBroadcastQueue;
        mBroadcastQueues[2] = mOffloadBroadcastQueue;
        
        // 创建 ActiveServices 对象，用于管理 ServiceRecord 对象
        mServices = new ActiveServices(this);
        ...
        
        // 得到ATM的对象，调用ATM.initialize
        mActivityTaskManager = atm;
        mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
                DisplayThread.get().getLooper());
        // 得到ATM的服务信息
        mAtmInternal = LocalServices.getService(
ActivityTaskManagerInternal.class);
 
        //加入Watchdog监控
        Watchdog.getInstance().addMonitor(this);
        Watchdog.getInstance().addThread(mHandler);
        ...
        
    }
}

(2) start()

start中做了两件事

  • 进程复位
  • 注册电池状态服务和权限管理服务 frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
private void start() {
    // 移除所有的进程组
    removeAllProcessGroups();

    // 电池状态服务
    mBatteryStatsService.publish();
    // 权限管理服务
    mAppOpsService.publish();
    Slog.d("AppOps", "AppOpsService published");
    LocalServices.addService(ActivityManagerInternal.class, mInternal);
    LocalManagerRegistry.addManager(ActivityManagerLocal.class,
            (ActivityManagerLocal) mInternal);
    mActivityTaskManager.onActivityManagerInternalAdded();
    mPendingIntentController.onActivityManagerInternalAdded();
    mAppProfiler.onActivityManagerInternalAdded();
}

4. mActivityManagerService.setSystemProcess()

在frameworks/base/services/java/com/android/server/SystemServer.java#startOtherServices中调用了AMS的setSystemProcess方法，setSystemProcess方法主要有五个功能：

  • 注册一些服务:包括 activity、procstats、meminfo、gfxinfo、dbinfo、permission、processinfo
  • 获取package名为“android”的应用的 ApplicationInfo
  • 为ActivityThread 安装 system application相关信息,将framework-res.apk对应的ApplicationInfo安装到LoadedApk中的mApplicationInfo
  • 为systemserver 主进程开辟一个ProcessRecord来维护进程的相关信息
  • AMS进程管理相关的操作。
private void startOtherServices() {
    ...
    
    // 为系统进程设置应用程序实例并开始使用
    t.traceBegin("SetSystemProcess");
    mActivityManagerService.setSystemProcess();
    t.traceEnd();
    ...
    
 }
 
// [frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java]
public void setSystemProcess() {
  try {
      // 服务注册
      ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
              DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
      ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
      ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
              DUMP_FLAG_PRIORITY_HIGH);
      ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
      ServiceManager.addService("dbinfo", new DbBinder(this));
      mAppProfiler.setCpuInfoService();
      ServiceManager.addService("permission", new PermissionController(this));
      ServiceManager.addService("processinfo", new ProcessInfoService(this));
 
      // 通过解析framework-res.apk里的AndroidManifest.xml获得ApplicationInfo
      ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
              "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
      // 为ActivityThread 安装 system application相关信息,将framework-res.apk对应的ApplicationInfo安装到LoadedApk中的mApplicationInfo
      mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
 
       // 为systemserver 主进程开辟一个ProcessRecord来维护进程的相关信息
      synchronized (this) {
          ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
                  false,
                  0,
                  new HostingRecord("system"));
          // 设置进程常驻
          app.setPersistent(true); 
          // 设置进程ID，即system_server进程ID
          app.pid = MY_PID;  
          app.getWindowProcessController().setPid(MY_PID);
          app.maxAdj = ProcessList.SYSTEM_ADJ;
          app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
          // 将ProcessRecord放到mPidSelfLocked里统一管理
          addPidLocked(app);
          updateLruProcessLocked(app, false, null);
          updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
      }
  } catch (PackageManager.NameNotFoundException e) {
      throw new RuntimeException(
              "Unable to find android system package", e);
  }
  ...
  
}

5. systemReady()

AMS启动完毕后，还需要调用一个systemReady()方法，相关代码如下： frameworks/base/services/java/com/android/server/SystemServer.java

mActivityManagerService.systemReady(() -> {
    ...
    
})

该方法分为三个阶段

  1. 主要是调用一些关键服务的初始化函数， 然后杀死那些没有FLAG_PERSISTENT却在AMS启动完成前已经存在的进程， 同时获取一些配置参数。 需要注意的是，由于只有Java进程才会向AMS注册，而一般的Native进程不会向AMS注册，因此此处杀死的进程是Java进程。

  2. 执行goingCallback的处理，主要的工作就是通知一些服务可以进行systemReady、systemRunning相关的工作，并进行启动服务或应用进程的工作

  3. 启动Home Activity，当启动结束，并发送ACTION_BOOT_COMPLETED广播时，AMS的启动过程告一段落 下面结合具体代码对这三个阶段进行探究。

(1) 关键服务初始化

该阶段主要是调用一些关键服务的初始化函数，然后杀死那些没有FLAG_PERSISTENT却在AMS启动完成前已经存在的进程， 同时获取一些配置参数。 需要注意的是，由于只有Java进程才会向AMS注册，而一般的Native进程不会向AMS注册，因此此处杀死的进程是Java进程。

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    synchronized(this) {
        // 第一次进入mSystemReady 为false，不走该流程
        if (mSystemReady) {
            if (goingCallback != null) {
                goingCallback.run();
            }
            t.traceEnd();
            return;
        }
 
        //这一部分主要是调用一些关键服务SystemReady相关的函数，
        //进行一些等待AMS初始完，才能进行的工作
        t.traceBegin("controllersReady");
        mLocalDeviceIdleController =
                LocalServices.getService(DeviceIdleInternal.class);
        mActivityTaskManager.onSystemReady();
        mUserController.onSystemReady();
        mAppOpsService.systemReady();
        mProcessList.onSystemReady();
        mSystemReady = true;
        t.traceEnd();
    }
 
    try {
        sTheRealBuildSerial = IDeviceIdentifiersPolicyService.Stub.asInterface(
                ServiceManager.getService(Context.DEVICE_IDENTIFIERS_SERVICE))
                .getSerial();
    } catch (RemoteException e) {}
 
    ArrayList<ProcessRecord> procsToKill = null;
    synchronized(mPidsSelfLocked) {
        // mPidsSelfLocked 中保存当前正在运行的所有进程的信息
        for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
            ProcessRecord proc = mPidsSelfLocked.valueAt(i);
            // 在AMS启动完成前，如果没有FLAG_PERSISTENT标志的进程已经启动了，
            // 就将这个进程加入到procsToKill中
            if (!isAllowedWhileBooting(proc.info)){
                if (procsToKill == null) {
                    procsToKill = new ArrayList<ProcessRecord>();
                }
                procsToKill.add(proc);
            }
        }
    }
 
    // 收集已经启动的进程并杀死，排除persistent常驻进程
    synchronized(this) {
        // 利用removeProcessLocked关闭procsToKill中的进程
        if (procsToKill != null) {
            for (int i=procsToKill.size()-1; i>=0; i--) {
                ProcessRecord proc = procsToKill.get(i);
                Slog.i(TAG, "Removing system update proc: " + proc);
                mProcessList.removeProcessLocked(proc, true, false, "system update done");
            }
        }
        // 系统准备完毕
        mProcessesReady = true;
    }
    ...
    
    mUgmInternal.onSystemReady();
}

(2) 执行goingCallback处理

该阶段主要的工作就是通知一些服务可以进行systemReady相关的工作，并进行启动服务或应用进程的工作。 frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
    ...
    
    // 调用参数传入的runnable对象，SystemServer中有具体的定义
    if (goingCallback != null) goingCallback.run();
    ...
    
    // 启动系统服务(在这里主要是电池状态管理服务)
    t.traceBegin("ActivityManagerStartApps");
    mBatteryStatsService.onSystemReady();
    mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_RUNNING_START,
            Integer.toString(currentUserId), currentUserId);
    mBatteryStatsService.noteEvent(BatteryStats.HistoryItem.EVENT_USER_FOREGROUND_START,
        Integer.toString(currentUserId), currentUserId);

    final boolean bootingSystemUser = currentUserId == UserHandle.USER_SYSTEM;

    if (bootingSystemUser) {
        mSystemServiceManager.onUserStarting(t, currentUserId);
    }
    synchronized (this) {
        //启动persistent为1的application所在的进程
        startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
        
        // Start up initial activity.
        mBooting = true;
        ...
    }
        
}

(2.a) goingCallback.run()

该方法主体在frameworks/base/services/java/com/android/server/SystemServer.java#startOtherServices下，之前看到systemReady()下有一个Lambda 表达式，这个表达式的主体既为goingCallback.run()的内容，主要用于监控Native的crash，启动WebView，执行一些服务的systemReady 和systemRunning方法。

private void startOtherServices() {
  mActivityManagerService.systemReady(() -> {
  // 阶段 550  Acitvity Manager启动完成
  mSystemServiceManager.startBootPhase(
              SystemService.PHASE_ACTIVITY_MANAGER_READY);
  ...
  
  // 监控Native的crash
  mActivityManagerService.startObservingNativeCrashes();
  , BOOT_TIMINGS_TRACE_LOG);
  ...
  
  //启动WebView
  mWebViewUpdateService.prepareWebViewInSystemServer();
  
  // 执行一系列服务的systemReady方法
  networkManagementF.systemReady();
  ipSecServiceF.systemReady();
  networkStatsF.systemReady();
  connectivityF.systemReady();
  networkPolicyF.systemReady(networkPolicyInitReadySignal);
  ...
  
  //阶段 600 第三方应用程序可以启动
  mSystemServiceManager.startBootPhase(
              SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
  
  //执行一系列服务的systemRunning方法
  locationF.systemRunning();
  countryDetectorF.systemRunning();
  networkTimeUpdaterF.systemRunning();
  inputManagerF.systemRunning();
  telephonyRegistryF.systemRunning();
  mediaRouterF.systemRunning();
  mmsServiceF.systemRunning();
  ...
  
}

(2.b) startPersistentApps()

该方法用于启动persistent为1的application所在的进程。 frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

void startPersistentApps(int matchFlags) {
  if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) return;
  
  synchronized (this) {
      try {
           //从PKMS中得到persistent为1的ApplicationInfo
          final List<ApplicationInfo> apps = AppGlobals.getPackageManager()
                  .getPersistentApplications(STOCK_PM_FLAGS | matchFlags).getList();
          for (ApplicationInfo app : apps) {
               //由于framework-res.apk已经由系统启动，所以此处不再启动它
              if (!"android".equals(app.packageName)) {
                   //addAppLocked中将启动application所在进程 
                  addAppLocked(app, null, false, null /* ABI override */);
              }
          }
      } catch (RemoteException ex) {
      }
  }
}

(3) 完成AMS启动

在该阶段启动Home Activity，当启动结束，并发送ACTION_BOOT_COMPLETED广播时，AMS启动完成。 frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public  void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
  ...
  // 通过ATM，启动Home Activity
  mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");
  ...
  // 发送广播消息
  try {
      // system发送广播 ACTION_USER_STARTED = "android.intent.action.USER_STARTED";
      Intent intent = new Intent(Intent.ACTION_USER_STARTED);
      intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY
              | Intent.FLAG_RECEIVER_FOREGROUND);
      intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
      broadcastIntentLocked(null, null, intent,
              null, null, 0, null, null, null, OP_NONE,
              null, false, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
              currentUserId);
      //system发送广播 ACTION_USER_STARTING= "android.intent.action.USER_STARTING";
      intent = new Intent(Intent.ACTION_USER_STARTING);
      intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
      intent.putExtra(Intent.EXTRA_USER_HANDLE, currentUserId);
      broadcastIntentLocked(null, null, intent,
              null, new IIntentReceiver.Stub() {
                  @Override
                  public void performReceive(Intent intent, int resultCode, String data,
                          Bundle extras, boolean ordered, boolean sticky, int sendingUser)
                          throws RemoteException {
                  }
              }, 0, null, null,
              new String[] {INTERACT_ACROSS_USERS}, OP_NONE,
              null, true, false, MY_PID, SYSTEM_UID, callingUid, callingPid,
              UserHandle.USER_ALL);
      } catch (Throwable t) {
          Slog.wtf(TAG, "Failed sending first user broadcasts", t);
      } finally {
          Binder.restoreCallingIdentity(ident);
  }
}

(3.a) 启动Home Activity

安卓的Luncher其实就是在这里启动的，启动完成后，我们就可以看见安卓系统的主界面了。 frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java

public boolean startHomeOnAllDisplays(int userId, String reason) {
    synchronized (mGlobalLock) {
        //调用RootActivityContainer的startHomeOnAllDisplays()，最终到startHomeOnDisplay()
        return mRootWindowContainer.startHomeOnAllDisplays(userId, reason);
    }
}

// [frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java]
boolean startHomeOnAllDisplays(int userId, String reason) {
    boolean homeStarted = false;
    for (int i = getChildCount() - 1; i >= 0; i--) {
        final int displayId = getChildAt(i).mDisplayId;
        homeStarted |= startHomeOnDisplay(userId, reason, displayId);
    }
    return homeStarted;
}

// [frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java]
boolean startHomeOnDisplay(int userId, String reason, int displayId, boolean allowInstrumenting,
        boolean fromHomeKey) {
    // Fallback to top focused display or default display if the displayId is invalid.
    if (displayId == INVALID_DISPLAY) {
        final Task rootTask = getTopDisplayFocusedRootTask();
        displayId = rootTask != null ? rootTask.getDisplayId() : DEFAULT_DISPLAY;
    }

    final DisplayContent display = getDisplayContent(displayId);
    return display.reduceOnAllTaskDisplayAreas((taskDisplayArea, result) ->
                    result | startHomeOnTaskDisplayArea(userId, reason, taskDisplayArea,
                            allowInstrumenting, fromHomeKey),
            false /* initValue */);
}

// [frameworks/base/services/core/java/com/android/server/wm/RootWindowContainer.java]
boolean startHomeOnTaskDisplayArea(int userId, String reason, TaskDisplayArea taskDisplayArea,
        boolean allowInstrumenting, boolean fromHomeKey) {
        ...
        
    // 启动Home Activity--Luncher
    mService.getActivityStartController().startHomeActivity(homeIntent, aInfo, myReason,
        taskDisplayArea);
    return true;
}

三、总结

本章详细探究了AMS的启动流程，值得注意的是，Android 9.0 及以前版本，Acitivity 管理由AMS 和WMS 协作完成，导致在AMS 和WMS 中都有相似功能的实体，除了大量的代码冗余之外，二者之间的协作也非常困难，从Android 11 的代码变更看，google 最终的目的是把activity 和window融合，其实activity和window的融合早在Android 10就开始了，但目前只是简单的把代码整理到一起了，还属于中间状态，按android文档介绍，完全融合在Andorid 12甚至更靠后的版本才能完成。

avatar
文章
阅读
粉丝