Android源码解析--ActivityManagerService详解(一)：从开机启动的角度解析AMS

ActivityManagerService是Android系统中一个特别重要的系统服务，也是我们上层APP打交道最多的系统服务之一。ActivityManagerService（以下简称AMS） 主要负责四大组件的启动、切换、调度以及应用进程的管理和调度工作。所有的APP应用都需要
与AMS打交道。

本文将从Android系统启动的过程中，去理解在系统启动时，AMS如何启动并完成初始化的，以及在启动AMS时到底做了些什么工作。

1、ActivityManagerService的直系血亲

所有的Service服务都是继承了Binder的，因为Android上层应用的所有IPC跨进程操作都是通过Binder来完成。从上图看到，

• AMS继承自ActivityManagerNative，ActivityManagerNative则继承了Binder并实现了IActivityManager接口。
• ActivityManagerProxy实现了IActivityManager
• ActivityManager作为Binder通信的客户端， 实际上通过ActivityManagerNative.getDefault()获得一个ActivityManagerProxy对象，然后与AMS进行通信。

2、ActivityManagerService的启动过程

AMS一样是在SystemServer中被添加的， 所以先到SystemServer中查看初始化：

public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
	...
	 //注释2.1、创建SystemServer的Context上下文，这个Context是在SystemServer中独有的一个Context对象
    createSystemContext();
	...
	//注释2.2、创建管理系统Service的管理器，传入的mSystemContext在前面 注释2.1、 创建
   mSystemServiceManager = new SystemServiceManager(mSystemContext);
   LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
   ...
    try {
        startBootstrapServices();//注释2.3、开机引导服务
        startCoreServices();//注释2.4、核心服务
        startOtherServices();//注释2.5、其他服务
        SystemServerInitThreadPool.shutdown();
    }
	...
}

在SystemServer中，在startBootstrapServices()中去启动了AMS:

private void startBootstrapServices() {
    Installer installer = mSystemServiceManager.startService(Installer.class);
	...
	//启动了AMS
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
...
}

AMS是通过SystemServiceManager.startService去启动的，参数是ActivityManagerService.Lifecycle.class， 首先看看startService方法：

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);
			//此处的mContext就是SystemServer中的mContext
            service = constructor.newInstance(mContext);
        } catch (InstantiationException ex) {
     	 ...
		}
        startService(service);//启动服务
        return service;
    } 
}

public void startService(@NonNull final SystemService service) {
    mServices.add(service);
    long time = System.currentTimeMillis();
    try {
        service.onStart(); //调用 onStart方法
    } catch (RuntimeException ex) {
     ...
    }
}

startService方法很简单，是通过传进来的class然后反射创建对应的service服务。所以此处创建的是Lifecycle的实例， 然后通过startService启动了AMS服务

那我们再去看看ActivityManagerService.Lifecycle这个类的构造方法：

 public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;

    public Lifecycle(Context context) {
        super(context);
        mService = new ActivityManagerService(context);//注释2.6、创建AMS
    }

    @Override
    public void onStart() {
        mService.start();//注释2.7、启动AMS
    }

    public ActivityManagerService getService() {
        return mService;//注释2.8、返回AMS实例
    }
}

综上， 通过Lifecycle这个AMS的内部类， 完成了AMS的启动。

不过，其中还有一些细节，需要我们一一梳理清楚。

4、AMS的初始化过程–AMS初始化到底做了些什么

上述第一节讲了AMS的整体启动过程，注释2.6 处创建了AMS实例， 注释2.7启动了AMS.接下来就看看AMS的这些初始化具体做了些什么，首先从构造方法看起。

4.1 AMS的构造方法

public ActivityManagerService(Context systemContext) {
    LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
    mInjector = new Injector();
    mContext = systemContext;//赋值mContext

    mFactoryTest = FactoryTest.getMode();
    mSystemThread = ActivityThread.currentActivityThread();//获取当前的ActivityThread
    mUiContext = mSystemThread.getSystemUiContext();//赋值mUiContext

    mPermissionReviewRequired = mContext.getResources().getBoolean(
            com.android.internal.R.bool.config_permissionReviewRequired);
	//注释4.1.1 创建Handler线程，用来处理handler消息
    mHandlerThread = new ServiceThread(TAG,
            THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
    mHandlerThread.start();
    mHandler = new MainHandler(mHandlerThread.getLooper());
    mUiHandler = mInjector.getUiHandler(this);//处理ui相关msg的Handler

    mConstants = new ActivityManagerConstants(this, mHandler);//管理AMS的一些常量，厂商定制系统就可能修改此处
	...

	//初始化管理前台、后台广播的队列， 系统会优先遍历发送前台广播
    mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "foreground", BROADCAST_FG_TIMEOUT, false);
    mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
            "background", BROADCAST_BG_TIMEOUT, true);
    mBroadcastQueues[0] = mFgBroadcastQueue;
    mBroadcastQueues[1] = mBgBroadcastQueue;

	//初始化管理Service的 ActiveServices对象
    mServices = new ActiveServices(this);
	//初始化Provider的管理者
    mProviderMap = new ProviderMap(this);
	//初始化APP错误日志的打印器
    mAppErrors = new AppErrors(mUiContext, this);

    //创建电池统计服务， 并输出到指定目录
    File dataDir = Environment.getDataDirectory();
    File systemDir = new File(dataDir, "system");
    systemDir.mkdirs();
    mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
    mBatteryStatsService.getActiveStatistics().readLocked();
    mBatteryStatsService.scheduleWriteToDisk();
    mOnBattery = DEBUG_POWER ? true
            : mBatteryStatsService.getActiveStatistics().getIsOnBattery();
    mBatteryStatsService.getActiveStatistics().setCallback(this);
	//创建进程统计分析服务，追踪统计哪些进程有滥用或不良行为
    mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));

    mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
    mAppOpsService.startWatchingMode(AppOpsManager.OP_RUN_IN_BACKGROUND, null,
            new IAppOpsCallback.Stub() {
                @Override public void opChanged(int op, int uid, String packageName) {
                    if (op == AppOpsManager.OP_RUN_IN_BACKGROUND && packageName != null) {
                        if (mAppOpsService.checkOperation(op, uid, packageName)
                                != AppOpsManager.MODE_ALLOWED) {
                            runInBackgroundDisabled(uid);
                        }
                    }
                }
            });

	//加载Uri的授权文件
    mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));

	//负责管理多用户
    mUserController = new UserController(this);
	//vr功能的控制器
    mVrController = new VrController(this);
	//初始化OpenGL版本号
    GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
        ConfigurationInfo.GL_ES_VERSION_UNDEFINED);

    if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
        mUseFifoUiScheduling = true;
    }

    mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
    mTempConfig.setToDefaults();
    mTempConfig.setLocales(LocaleList.getDefault());
    mConfigurationSeq = mTempConfig.seq = 1;
	//管理ActivityStack的重要类，这里面记录着activity状态信息，是AMS中的核心类
    mStackSupervisor = createStackSupervisor();
    mStackSupervisor.onConfigurationChanged(mTempConfig);
	//根据当前可见的Activity类型，控制Keyguard遮挡，关闭和转换。 Keyguard就是我们的锁屏相关页面    
	mKeyguardController = mStackSupervisor.mKeyguardController;

	/*
	管理APK的兼容性配置
    解析/data/system/packages-compat.xml文件，该文件用于存储那些需要考虑屏幕尺寸的APK信息，
    可以参考AndroidManifest.xml中的compatible-screens相关说明，
    当APK所运行的设备不满足要求时，AMS会根据设置的参数以采用屏幕兼容的方式运行它
     */
    mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
	//Intent防火墙，Google定义了一组规则，来过滤intent，如果触发了，则intent会被系统丢弃，且不会告知发送者
    mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
	//Activity任务栈变化通知处理
    mTaskChangeNotificationController =
            new TaskChangeNotificationController(this, mStackSupervisor, mHandler);
	//这是activity启动的处理类，这里管理者activity启动中用到的intent信息和flag标识，也和stack和task有重要的联系
    mActivityStarter = new ActivityStarter(this, mStackSupervisor);
    mRecentTasks = new RecentTasks(this, mStackSupervisor);

	//启动一个线程专门跟进cpu当前状态信息，AMS对当前cpu状态了如指掌，可以更加高效的安排其他工作
    mProcessCpuThread = new Thread("CpuTracker") {
        @Override
        public void run() {
            synchronized (mProcessCpuTracker) {
                mProcessCpuInitLatch.countDown();
                mProcessCpuTracker.init();
            }
            while (true) {
                try {
                    try {
                        synchronized(this) {
                            final long now = SystemClock.uptimeMillis();
                            long nextCpuDelay = (mLastCpuTime.get()+MONITOR_CPU_MAX_TIME)-now;
                            long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now;
                            //Slog.i(TAG, "Cpu delay=" + nextCpuDelay
                            //        + ", write delay=" + nextWriteDelay);
                            if (nextWriteDelay < nextCpuDelay) {
                                nextCpuDelay = nextWriteDelay;
                            }
                            if (nextCpuDelay > 0) {
                                mProcessCpuMutexFree.set(true);
                                this.wait(nextCpuDelay);
                            }
                        }
                    } catch (InterruptedException e) {
                    }
                    updateCpuStatsNow();
                } catch (Exception e) {
                }
            }
        }
    };

	//看门狗，监听进程。这个类每分钟调用一次监视器。 如果进程没有任何返回就杀掉
    Watchdog.getInstance().addMonitor(this);
    Watchdog.getInstance().addThread(mHandler);
}

AMS相较于早期版本有了较多改动，去掉了AMS中的main()方法，将其中的工作移到了AMS构造函数里面。

4.2 AMS的start()方法

private void start() {
    removeAllProcessGroups();
    mProcessCpuThread.start();

    mBatteryStatsService.publish(mContext);
    mAppOpsService.publish(mContext);
    LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    //等待mProcessCpuThread完成初始化后， 释放锁，初始化期间禁止访问
    try {
        mProcessCpuInitLatch.await();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}

可以看到此方法中并没有太多的处理。

至此， AMS的启动流程就在整体上梳理完闭了，在这个过程中的一些细节，在需要的时候在进行展开。

总结

参考《深入理解Android》

分析源码为（Android 8.0）