系统启动流程分析之AMS服务启动流程分析（上）

每个片段都值得深刻纪念
802 阅读7分钟

「这是我参与2022首次更文挑战的第9天，活动详情查看：2022首次更文挑战」。

ActivityManagerService服务启动流程分析

ActivityManagerService服务是系统服务的核心服务之一，和四大组件的启动、生命周期、调度都有很大的关联。

我们都知道，init进程在fork一个zygote进程后，启动了一个Java世界，而在这个Java世界中，有SystemServer类承担了加载Java世界服务和属性的重任，而我们今天要分析的ActivityManagerService服务的启动流程就是从这边开始的

SystemServer服务启动后，在其run函数中会调用一个startBootstrapServices函数，而在这个函数中会启动我们今天的主角ActivityManagerService服务

SystemServer.java
// 1. 初始化一个ActivityTaskManagerService对象
ActivityTaskManagerService atm = mSystemServiceManager.startService(
        ActivityTaskManagerService.Lifecycle.class).getService();
// 2. 初始化ActivityManagerServive对象
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
        mSystemServiceManager, atm);
// 设置SystemServiceManager和Installer
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);

ActivityManagerService.java
public void setSystemServiceManager(SystemServiceManager mgr) {
    mSystemServiceManager = mgr;
}

public void setInstaller(Installer installer) {
    mInstaller = installer;
}

接下来我们一步步地来分析一下这个流程

ActivityTaskManagerService对象初始化

从前述我们在SystemServiceManager的startService函数分析一文中有说明过，SystemServiceManager.startService函数主要有三个步骤

  1. 初始化对应的SystemService，并且调用其以Context对象为参数的单参构造函数，而传递的参数是在SystemServer中通过createSystemContext创建的Context对象
  2. 将传入参数SystemService对象添加到SystemServiceManager.mServices中保存，mServices是一个SystemService对象组成的ArrayList对象
  3. 调用传入参数SystemService对象的onStart函数

因此，接下来我们一一查看

ActivityTaskManagerService.Lifecycle的单参（Context）构造函数调用

public Lifecycle(Context context) {
    super(context);
    mService = new ActivityTaskManagerService(context);
}

public ActivityTaskManagerService(Context context) {
    mContext = context;
    mFactoryTest = FactoryTest.getMode();
    // 这个函数会返回一个ActivityThread对象，这个对象在SystemServer.createSystemContext函数调用的时候
    // 通过ActivityThread构造函数进行初始化的
    mSystemThread = ActivityThread.currentActivityThread();
    // 获取ActivityThread.mSystemUiContext参数，它是一个ContextImpl对象
    mUiContext = mSystemThread.getSystemUiContext();
    // 初始化一个ClientLifecycleManager对象
    // 此对象管理所有客户端的生命周期，回调函数等
    mLifecycleManager = new ClientLifecycleManager();
    // LocalService继承自ActivityTaskManagerInternal类
    mInternal = new LocalService();
    GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
    // 控制视图显示的类
    mWindowOrganizerController = new WindowOrganizerController(this);
    mTaskOrganizerController = mWindowOrganizerController.mTaskOrganizerController;
}

首先先看下其类图

classDiagram
ActivityTaskManagerService o-- Context
ActivityTaskManagerService o-- ActivityThread
ActivityTaskManagerService o-- ClientLifecycleManager
ActivityTaskManagerService o-- ActivityTaskManagerInternal
ActivityTaskManagerService o-- WindowOrganizerController
ActivityTaskManagerInternal <|-- LocalService
ActivityThread o-- ContextImpl
WindowOrganizerController o-- ActivityTaskManagerService
WindowOrganizerController o-- TaskOrganizerController
ActivityTaskManagerService o-- TaskOrganizerController
WindowOrganizerController o-- DisplayAreaOrganizerController
TaskOrganizerController o-- ActivityTaskManagerService
Context <|-- ContextImpl
ActivityTaskManagerService o-- WindowManagerGlobalLock
WindowOrganizerController o-- WindowManagerGlobalLock
Stub <|-- WindowOrganizerController
IWindowOrganizerController *-- Stub
class ActivityTaskManagerService {
    #Context:mContext
    #ActivityThread:mSystemThread
    #Context:mUiContext
    -ClientLifecycleManager:mLifecycleManager
    #ActivityTaskManagerInternal:mInternal
    #WindowOrganizerController:mWindowOrganizerController
    #TaskOrganizerController:mTaskOrganizerController
    #WindowManagerGlobalLock:mGlobalLock
}
class ActivityThread {
    -ContextImpl:mSystemUiContext
}
class WindowOrganizerController {
    -ActivityTaskManagerService:mService
    #TaskOrganizerController:mTaskOrganizerController
    #DisplayAreaOrganizerController:mDisplayAreaOrganizerController
    -WindowManagerGlobalLock:mGlobalLock
}
class TaskOrganizerController {
    -ActivityTaskManagerService:mService
}

ActivityTaskManagerService服务启动

接下来会调用ActivityTaskManagerService.Lifecycle的onStart函数

public void onStart() {
    // 将ActivityTaskManagerService对象注册到ServiceManager中
    publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
    // 调用ActivityTaskManagerService的start函数
    mService.start();
}

private void start() {
    // 分析可知，这边会将ActivityTaskManagerInternal.class, 和ActivityTaskManagerInternal对象mInternal组成键值对，注册到LocalServices.sLocalServiceObjects中
    LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}

总结

在ActivityTaskManagerService的初始化过程中，主要是初始化了一些参数，然后将ActivityTaskManagerService对象注册到ServiceManager中，并且将ActivityTaskManagerInternal.class 和ActivityTaskManagerInternal对象mInternal组成键值对，注册到LocalServices.sLocalServiceObjects

ActivityManagerService对象初始化

mActivityManagerService = ActivityManagerService.Lifecycle.startService(
        mSystemServiceManager, atm);
        
public static ActivityManagerService startService(
        SystemServiceManager ssm, ActivityTaskManagerService atm) {
    sAtm = atm;
    return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
}

同样地，在此处会调用到SystemServiceManager的startService函数，据如上的分析可知

ActivityManagerService.Lifecycle的单参（Context）构造函数调用

public Lifecycle(Context context) {
    super(context);
    mService = new ActivityManagerService(context, sAtm);
}

public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
    LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
    // 初始化Injector对象
    mInjector = new Injector(systemContext);
    mContext = systemContext;

    mFactoryTest = FactoryTest.getMode();
    // 获取SystemServer.createSystemContext函数中初始化的ActivityThread
    mSystemThread = ActivityThread.currentActivityThread();
    // 获取ActivityThread.mSystemUiContext参数对象，
    mUiContext = mSystemThread.getSystemUiContext();
    // ...... 日志打印，省略
    // 初始化ServiceThread对象，该类继承自HandlerThread
    mHandlerThread = new ServiceThread(TAG,
            THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    // Mainhandler是ActivityManagerService的内部类
    // 通过上述mHandlerThread的Looper跟mHandlerThread关联在一起
    mHandler = new MainHandler(mHandlerThread.getLooper());
    // 初始化一个UiHandler对象，其继承自Handler
    mUiHandler = mInjector.getUiHandler(this);

    // 初始化一个参数名为mProcStartHandlerThread的ServiceThread
    // 并且新建一个Handler和其关联
    mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
            THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
    mProcStartHandlerThread.start();
    mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
    // 主要注册和收集改变ActivityManager状态的常量
    mConstants = new ActivityManagerConstants(mContext, this, mHandler);
    // 运行中进程的有效UIDS的存储和操作
    final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
    // SystemService收集和报告兼容性变化的API
    mPlatformCompat = (PlatformCompat) ServiceManager.getService(
            Context.PLATFORM_COMPAT_SERVICE);
    // 获取ProcessList对象并初始化该对象
    // 该类主要用作处理ActivityManager进程方面的事情
    mProcessList = mInjector.getProcessList(this);
    mProcessList.init(this, activeUids, mPlatformCompat);
    // LowMemDetector对象初始化，低内存监控
    // 对这个类的解释是：使用PSI来监控低内存，如果kernel不支持PSI，则此类不可用
    // PSI是Android Q上新引入的一个功能，后续有机会可以研究一下
    mLowMemDetector = new LowMemDetector(this);
    // 监控进程的OOM
    mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
    // 监控BROADCAST_GF_CONSTANTS
    // Broadcast policy parameters
    final BroadcastConstants foreConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_FG_CONSTANTS);
    foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;

    final BroadcastConstants backConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_BG_CONSTANTS);
    backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;

    final BroadcastConstants offloadConstants = new BroadcastConstants(
            Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
    offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
    // by default, no "slow" policy in this queue
    offloadConstants.SLOW_TIME = Integer.MAX_VALUE;

    mEnableOffloadQueue = SystemProperties.getBoolean(
            "persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);

    // 初始化广播队列
    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;
    // 初始化ActiveServices对象
    // 管理后台有效的服务
    mServices = new ActiveServices(this);
    // 初始化ProviderMap对象
    // 这个对象主要对于ContentProvider进行分类整理，以便于可以很方便地被有权限的进程或者类追踪
    // 它能够将被用户追踪或者不被特定用户追踪的ContentProvider进行区分
    mProviderMap = new ProviderMap(this);
    // 初始化PackageWatchdog对象
    // 这个对象主要作用是：监控系统中应用的运行状况，当出现错误或者异常的时候，通知对应的关联的观察者
    // 一旦应用出现错误的时候，注册的观察者会使用对用户侧影响最小的方式来处理或者缓解错误或者异常
    mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
    // 处理应用程序的错误信息
    mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
    // 初始化和确认/data/system/目录被创建，并返回这个额目录的File信息
    final File systemDir = SystemServiceManager.ensureSystemDir();

    // TODO: Move creation of battery stats service outside of activity manager service.
    // 初始化BatteryStatsService对象
    // 这个对象主要收集影响手机使用寿命的所有事件
    mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
            BackgroundThread.get().getHandler());
    mBatteryStatsService.getActiveStatistics().readLocked();
    mBatteryStatsService.scheduleWriteToDisk();
    mOnBattery = DEBUG_POWER ? true
            : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
    mBatteryStatsService.getActiveStatistics().setCallback(this);
    mOomAdjProfiler.batteryPowerChanged(mOnBattery);
    // 收集进程信息的服务
    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
    // 初始化AppOpsService对象
    mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
    // 获取UriGrantsManagerInternal对象
    mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
    // 初始化UserController对象，为ActivityManagerService管理多用户进程
    mUserController = new UserController(this);
    // 初始化PendingIntentController对象，为ActivityManagerService管理PendingIntent
    mPendingIntentController = new PendingIntentController(
            mHandlerThread.getLooper(), mUserController, mConstants);
    
    // ...... 功能无关代码，省略
    
    mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
    mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);

    // ActivityTaskManagerService对象配置初始化
    mActivityTaskManager = atm;
    mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
            DisplayThread.get().getLooper());
    // 获取LocalService对象，该类继承自ActivityTaskManagerInternal
    // 加载位置在ActivityTaskManagerService中
    mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
    // 初始化一个线程，追踪CPU的运行状态
    mProcessCpuThread = new Thread("CpuTracker") {
        @Override
        public void run() {
            // ...... 此处暂不分析，代码暂时省略
        }
    };

    mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
    // 初始化Watchdog，且添加ActivityManagerService监听
    // 此处Watchdog添加监听AMS中是否有发生死锁
    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);

    // bind background threads to little cores
    // this is expected to fail inside of framework tests because apps can't touch cpusets directly
    // make sure we've already adjusted system_server's internal view of itself first
    updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
    try {
        Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
                Process.THREAD_GROUP_SYSTEM);
        Process.setThreadGroupAndCpuset(
                mOomAdjuster.mCachedAppOptimizer.mCachedAppOptimizerThread.getThreadId(),
                Process.THREAD_GROUP_SYSTEM);
    } catch (Exception e) {
        Slog.w(TAG, "Setting background thread cpuset failed");
    }

    mInternal = new LocalService();
    mPendingStartActivityUids = new PendingStartActivityUids(mContext);
}

对于这个构造函数来说，主要初始化一些对应的对象和初始化一些对应的对象，此处仅生成一个ActivityManagerService的类图

classDiagram
Stub <|-- ActivityManagerService
IActivityManager *-- Stub
Watchdog *-- Monitor
<<interface>> Monitor
Monitor <|.. ActivityManagerService
BatteryStatsImpl *-- BatteryCallback
<<interface>> BatteryCallback
BatteryCallback <|.. ActivityManagerService
ActivityManagerService --> Injector : mInjector
ActivityManagerService --> Context : mContext
ActivityManagerService --> ActivityThread : mSystemThread
ActivityManagerService --> ServiceThread
ActivityManagerService --> MainHandler : mHandler
ActivityManagerService --> UiHandler : mUiHandler
ActivityManagerService --> Handler : mProcStartHandler
ActivityManagerService --> ActivityManagerConstants : mConstants
ActivityManagerService --> ProcessList : mProcessList
ActivityManagerService --> LowMemDetector : mLowMemDetector
ActivityManagerService --> OomAdjuster : mOomAdjuster
ActivityManagerService --> ActiveServices:mServices
ActivityManagerService --> ProviderMap:mProviderMap
ActivityManagerService --> PackageWatchdog:mPackageWatchdog
ActivityManagerService --> AppErrors:mAppErrors
ActivityManagerService --> BatteryStatsService:mBatteryStatsService
ActivityManagerService --> OomAdjProfiler:mOomAdjProfiler
ActivityManagerService --> ProcessStatsService:mProcessStats
ActivityManagerService --> AppOpsService:mAppOpsService
ActivityManagerService --> UriGrantsManagerInternal:mUgmInternal
ActivityManagerService --> UserController:mUserController
ActivityManagerService --> PendingIntentController:mPendingIntentController
ActivityManagerService --> ActivityTaskManagerService:mActivityTaskManager
ActivityManagerService --> IntentFirewall:mIntentFirewall
ActivityManagerService --> ActivityTaskManagerInternal:mAtmInternal
ActivityManagerService --> HiddenApiSettings:mHiddenApiBlacklist
ActivityManagerService --> PendingStartActivityUids:mPendingStartActivityUids
ActivityManagerService --> LocalService:mInternal
ActivityManagerInternal <|-- LocalService
class ActivityManagerService {
    #mProcStartHandlerThread:ServiceThread
    #mHandlerThread:mHandlerThread
    #mFgBroadcastQueue:BroadcastQueue
    #mBgBroadcastQueue:BroadcastQueue
    #mOffloadBroadcastQueue:BroadcastQueue
    #mBroadcastQueues:BroadcastQueue[]
    +mProcessCpuThread:Thread
}
class ActivityThread {
    +currentActivityThread()
    +getSystemUiContext()
}
class Injector {
    +getUiHandler(ActivityManagerService)
    +getProcessList(ActivityManagerService)
    +getAppOpsService(File, MainHandler)
}
class ProcessList {
    +init(ActivityManagerService, ActiveUids, PlatformCompat)
}
class BatteryStatsService {
    +getActiveStatistics()
    +scheduleWriteToDisk()
}
class OomAdjProfiler {
    +batteryPowerChanged(boolean)
}
class ActivityTaskManagerService {
    +initialize(IntentFirewall, PendingIntentController, Looper)
}

同时，关于AMS构造函数的时序图

图片.png

此处时序图仅做流程记录，暂不做展开分析

ActivityManagerService.Lifecycle的onStart函数调用

public void onStart() {
    mService.start();
}

private void start() {
    removeAllProcessGroups();
    // while无限循环，更新当前CPU状态信息
    mProcessCpuThread.start();
    // 将BatteryStatsService.LocalService注册到LocalServices.sLocalServiceObjects，LocalService继承自BatteryStatsInternal类
    // 将BatteryStatsService对象注册到服务管理器中
    mBatteryStatsService.publish();
    // 将AppOpsService.AppOpsManagerInternalImpl注册到LocalServices.sLocalServiceObjects中
    // 将AppOpsService对象注册到服务管理器中
    mAppOpsService.publish();
    Slog.d("AppOps", "AppOpsService published");
    // 将ActivityManagerInternal对象mInternal注册到LocalServices.sLocalServiceObjects中
    LocalServices.addService(ActivityManagerInternal.class, mInternal);
    // 上述注册LocalServices完成后，在ActivityTaskManagerService中获取该对象
    mActivityTaskManager.onActivityManagerInternalAdded();
    // 上述注册LocalServices完成后，在PendingIntentController中获取该对象
    mPendingIntentController.onActivityManagerInternalAdded();
    // Wait for the synchronized block started in mProcessCpuThread,
    // so that any other access to mProcessCpuTracker from main thread
    // will be blocked during mProcessCpuTracker initialization.
    // 此处主要是加锁等待mProcessCpuTracker加载完成
    try {
        mProcessCpuInitLatch.await();
    } catch (InterruptedException e) {
        Slog.wtf(TAG, "Interrupted wait during start", e);
        Thread.currentThread().interrupt();
        throw new IllegalStateException("Interrupted wait during start");
    }
}

可以看到，在AMS的start函数中主要将注册服务到ServiceManager和LocalServices中

总结

在AMS的子类Lifecycle通过SystemServiceManager启动的时候，

  1. 首先调用了AMS的构造函数对AMS进行初始化，在构造函数中，初始化了AMS的一些必要的参数和类对象,在构造函数调用期间，同时会调用ActivityTaskManagerService的initialize函数做一些初始化操作
  2. 其次调用AMS的start函数启动对CPU的监控，然后将一些必要的服务注册到LocalServices和ServiceManager中 主要是： 将BatteryStatsInternal.class和BatteryStatsService.LocalService组成键值对注册到LocalServices.sLocalServiceObjects中 将"batterystats"和BatteryStatsService对象组成键值对注册到ServiceManager中 将"appops"和AppOpsService对象组成键值对注册到ServiceManager中 将AppOpsManagerInternal.class和AppOpsService.mAppOpsManagerInternal组成键值对注册到LocalServices.sLocalServiceObjects中
avatar
文章
阅读
粉丝