android AMS服务的解析

AMS和ATMS

AMS是ActivityManagerService的简称，在Android 10 之前，AMS主要负责对四大组件进行管理和调度，同时，AMS也 对进程、电池、内存、权限等进行管理。但在Android 10开始，系统发现AMS要承载的事务太多，就将Activity的管理迁移到了ActivityTaskManagerService中，ActivityTaskManagerService也被缩写为ATMS。所以本篇我们把AMS和ATMS放在一起分析。

AMS与ATMS都是SystemServer进程中的系统服务，他们并不是独立的进程，所以，他们的启动和管理全部都是在 SystemServer进程中进行的。

ATMS的启动

从前面的android启动流程-SystemServer一文中可知，SystemServer最终会调用三个启动服务的方法：

private void run() { 
 
        try { 
            // 3.使用SystemServiceManager启动引导服务 
            startBootstrapServices(t); 
            // 4.启动核心服务 
            startCoreServices(t); 
            // 5.启动其他服务 
            startOtherServices(t); 
        } 
 
} 

上面这3个方法会启动android系统中的90多种服务，其中就包括AMS的启动和ATMS的启动。

startBootstrapServices

我们先来看看ATMS是如何启动的，在startBootstrapServices方法中，ATMS并不是直接启动，而是SystemServiceManager通过 Lifecycle类来间接实现。

Lifecycle 是 ATMS 里的静态内部类，静态内部类不依赖于外部类，它封装 了ATMS对象，同时实现了SystemService接口。Lifecycle 构造方法调用时，会初始化内部成员变量 mService，即调用ATMS的构造方法，构造方法中会执行一些初始化操作。

private void startBootstrapServices() { 
    //...... 
    //1、启动ATMS服务 
    ActivityTaskManagerService atm = mSystemServiceManager.startService( 
    ActivityTaskManagerService.Lifecycle.class).getService(); 
    //2、启动AMS服务 
    mActivityManagerService = ActivityManagerService.Lifecycle.startService( 
    mSystemServiceManager, atm); 
    //3、将SystemServiceManager设置给AMS 
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager); 
    //3、将installer设置给AMS 
    mActivityManagerService.setInstaller(installer); 
    //4、初始化电源管理功能 
    mActivityManagerService.initPowerManagement(); 
    //5、设置系统进程 
    mActivityManagerService.setSystemProcess(); 
    //6、初始化看门狗 
    watchdog.init(mSystemContext, mActivityManagerService); 
} 



// ActivityTaskManagerService的内部类
public static final class Lifecycle extends SystemService { 
    private final ActivityTaskManagerService mService; 

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


} 

然后在SystemManagerService中执行startService方法。

SystemServiceManager是一个辅助类，它用于辅助SystemServer进程启动和管理SystemServer进程中的各类服务 Service。由于需要管理的服务非常多，所以SystemServiceManager是通过管理所有实现了SystemService接口的类的方式来统一的运用反射启动这些服务。这个类通过反射获取到ATMS，然后调用startService方法执行到service.onStart()。

public <T extends SystemService> T startService(Class<T> serviceClass) { 
    try { 
        final String name = serviceClass.getName(); 
        ... 

        final T service; 
        try { 
            Constructor<T> constructor = serviceClass.getConstructor(Context.class); 
            service = constructor.newInstance(mContext); 
        } catch (InstantiationException ex) { 
            ... 
        } 
        startService(service); 
        return service;   
    } finally { 
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER); 
    } 
} 

/*通过上面的代码我们不难发现，startService()方法内部是运用了反射获取到了serviceClass类的对象实 
 */例service，然后再调用startService（service）如下所示：
public void startService(@NonNull final SystemService service) {
    // 注册服务
    mServices.add(service);
    // 开启服务
    long time = SystemClock.elapsedRealtime();
    try {
        service.onStart();
    } catch (RuntimeException ex) {
        throw new RuntimeException("Failed to start service " + service.getClass().getName()
                                   + ": onStart threw an exception", ex);
    }
    warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
}

上面代码通过反射获取到AMS，调用service.onStart()就是走Lifecycle中实现的方法onStart()，然后最终走到start()，启动服务。

// ActivityManagerService的内部类
public static final class Lifecycle extends SystemService {
    
    ...

    @Override
    public void onStart() {
        publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
        mService.start();
    }

    ...
}


private void start() {
    LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}

我们看一下，在onStart和start方法中，其实都只是执行了一句代码，那么这两句代码什么意思呢？

我们先看一下publishBinderService():

protected final void publishBinderService(String name, IBinder service,
        boolean allowIsolated, int dumpPriority) {
    ServiceManager.addService(name, service, allowIsolated, dumpPriority);
}

这个方法的主要目的就是ATMS将自己的binder 发布到了ServcieManager这个进程上面，方便后期其他进程 调用ATMS的服务。

再看start()方法：

private void start() {
    LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}

实际上，start函数就是在将ATMS的本地服务保存到LocalServices列表中，将来进程内别的服务需要使用他们的时候 可以去LocalServices中找到。当然，ATMS的本地服务大家理解为就是 ATMS的服务就好了。

AMS的启动

其实，AMS的启动基本和ATMS一致，但是在发布binder服务的时候，AMS通过setSystemProcess来发布。

public void setSystemProcess() {
    try {
             ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
                      DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
        }
}
 

其他的逻辑基本一致：

// ActivityManagerService的内部类
public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;
    private static ActivityTaskManagerService sAtm;

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

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

}

// ActivityManagerService的内部类
public static final class Lifecycle extends SystemService {

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

}


private void start() {
    mBatteryStatsService.publish();
    mAppOpsService.publish();
    mProcessStats.publish();
    Slog.d("AppOps", "AppOpsService published");
    LocalServices.addService(ActivityManagerInternal.class, mInternal);
    LocalManagerRegistry.addManager(ActivityManagerLocal.class,
        (ActivityManagerLocal) mInternal);
    mActivityTaskManager.onActivityManagerInternalAdded();
    mPendingIntentController.onActivityManagerInternalAdded();
    mAppProfiler.onActivityManagerInternalAdded();
    CriticalEventLog.init()
}

总结

首先，他们都是SystemServer进程中的服务，都是在SystemServer进程启动的时候进行启动；

其次，在他们启动的过程中，并不是直接自己启动的，而是由SystemServer进程通过SystemServiceManager对象 进行统一的启动；

然后，ATMS&AMS 启动后会将自己的本地服务公布到LocalServices列表，将来进程内别的服务需要使用他们的时候可以去LocalServices中找到；

最后，ATMS&AMS 会将自己的binder 公布给ServiceManager进程，由这个进程去进程存储，方便后面其他进程获取AMS和ATMS的binder 代理。