1.1 ActivityManger的组成

ActivityManger的功能：

• 启动管理应用进程
• 启动调度Activity、Service的生命周期
• 注册BroadcastReceiver、接收和分发广播
• 启动发布ContentProvider
• 调整进程调度优先级

ActivityManger的组成：
Android8.0之后，ActivityManagerNative已经被delete，ActivityManger使用IActivityManger.aidl文件，生成Binder通信的代理端和服务端。

• Client端，由ActivityManger封装接口供client调用，通过 IActivityManagerSingleton.get()获取服务的代理对象。
• Service端，由ActivityMangerService实现，继承了IActivityManager.Stub 接口，提供Server端的系统服务

public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
    }

private static final Singleton<IActivityManager> IActivityManagerSingleton =
         new Singleton<IActivityManager>() {
                @Override
                protected IActivityManager create() {
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
         };

1.2 系统如何启动ActivityMangerService

AMS的启动是在SystemServer(系统进程)中进行启动的，android所有的进程都是由zygote fork出来的，SystemServer也不例外。

private void run() {
        try {
            (1)
            Looper.prepareMainLooper();
          
            // Initialize native services.
            System.loadLibrary("android_servers");

            (2)
            // Initialize the system context.
            createSystemContext();
            (3)
            // Create the system service manager.
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setStartInfo(mRuntimeRestart,
                    mRuntimeStartElapsedTime, mRuntimeStartUptime);
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
            // Prepare the thread pool for init tasks that can be parallelized
            SystemServerInitThreadPool.get();
        } finally {
            traceEnd();  // InitBeforeStartServices
        }
        (4)
        // Start services.
        try {
            traceBeginAndSlog("StartServices");
            startBootstrapServices();
            startCoreServices();
            startOtherServices();
            SystemServerInitThreadPool.shutdown();
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            traceEnd();
        }
        // Loop forever.
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

• （1） Looper.prepareMainLooper()
  初始化MainLooper，ThreadLocal 线程本地存储区，每个线程都有自己私有的本地存储区，不同线程彼此不能访问对方的ThreadLocal。Looper.prepare() 新建一个Looper存入static的sThreadLocal，Looper内部维护一个MessageQueue。

public static void prepareMainLooper() {
      prepare(false);
      synchronized (Looper.class) {
          if (sMainLooper != null) {
              throw new IllegalStateException("The main Looper has already been prepared.");
          }
          sMainLooper = myLooper();
      }
}

• （2）createSystemContext方法
  创建一个ActivityThread对象，代表当前进程 (系统进程) 的主线程，创建一个Context对象，对于SystemServer而言，它包含的Application运行环境与framework-res.apk有关。

private void createSystemContext() {
        ActivityThread activityThread = ActivityThread.systemMain();
        mSystemContext = activityThread.getSystemContext();
        mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
        final Context systemUiContext = activityThread.getSystemUiContext();
        systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
}

• （3）创建SystemServiceManager
  它会对系统的服务进行创建、启动和生命周期管理。

• （4） 启动service，startBootstrapServices ()方法是初始化AMS的

 private void startBootstrapServices() {
        ....
        Installer installer = mSystemServiceManager.startService(Installer.class);
        ....
        // Activity manager runs the show.
        //真正启动AMS的地方
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        ....
       //注册一些系统服务
       //将framework-res.apk的信息加入到SystemServer对应的LoadedApk中，
       //同时构建SystemServer进程对应的ProcessRecord， 以将SystemServer进程纳入到AMS的管理中。
        mActivityManagerService.setSystemProcess();
        mActivityManagerService.systemReady();
....
    }

ActivityManagerService是使用SystemServiceManager(SSM)启动的，SSM启动的service必须继承自final Class<SystemService> serviceClass;，因为AMS并不是，所以使用ActivityManagerService.Lifecycle.class类。

public static final class Lifecycle extends SystemService {
        private final ActivityManagerService mService;
        public Lifecycle(Context context) {
            super(context);
            mService = new ActivityManagerService(context);
        }
        public ActivityManagerService getService() {
            return mService;
        }
 }

1.3 ActivityManagerService启动细节

1.3.1 第一阶段：创建ActivityThread

ActivityThread负责管理应用程序所在进程的主线程（UI线程）的执行、调度和运行activity、broadcasts等操作。

systemMain首先创建一个ActivityThread类型的thread对象，该对象返回后保存到AMS的mSystemThread对象中，传入true继续调用attach方法。

public static ActivityThread systemMain() {
        if (!ActivityManager.isHighEndGfx()) {
            ThreadedRenderer.disable(true);
        } else {
            ThreadedRenderer.enableForegroundTrimming();
        }
        ActivityThread thread = new ActivityThread();
        thread.attach(true);
        return thread;
    }

attach方法会区分系统进程和应用进程，传入参数true代表了系统进程，包括system_server以及AndroidManifest.xml中声明了android:shareUserId="android.uid.system"的apk（frameworks_res.apk、SettingsProvider.apk）

private void attach(boolean system, long startSeq) {
        sCurrentActivityThread = this;
        mSystemThread = system;
        if (!system) {
          ...
        } else {
            // Don't set application object here -- if the system crashes,
            // we can't display an alert, we just want to die die die.
            android.ddm.DdmHandleAppName.setAppName("system_process",
                    UserHandle.myUserId());
            try {
                mInstrumentation = new Instrumentation();
                mInstrumentation.basicInit(this);
                ContextImpl context = ContextImpl.createAppContext(
                        this, getSystemContext().mPackageInfo);
                mInitialApplication = context.mPackageInfo.makeApplication(true, null);
                mInitialApplication.onCreate();
            } catch (Exception e) {
                throw new RuntimeException(
                        "Unable to instantiate Application():" + e.toString(), e);
            }
        }
         ...    
    }

（1）系统Context的创建和初始化

getSystemContext的作用是创建一个系统Context的单例，并初始化。

 public ContextImpl getSystemContext() {
        synchronized (this) {
            if (mSystemContext == null) {
                //创建系统Context
                mSystemContext = ContextImpl.createSystemContext(this);
            }
            return mSystemContext;
        }
}

static ContextImpl createSystemContext(ActivityThread mainThread) {
        LoadedApk packageInfo = new LoadedApk(mainThread);
        ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
                null);
        context.setResources(packageInfo.getResources());
        context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(),
                context.mResourcesManager.getDisplayMetrics());
        return context;
}

LoadApk的构造方法，通过mActivityThread成员变量关联当前ActivityThread，setResources将一个可以访问framework中定义的系统资源的Resources对象，设置到context。这样才能通过ContextImpl访问系统Resources。
ContextImpl的构造函数主要是完成一些变量的初始化，建立起ContextImpl与ActivityThread、LoadedApk、ContentResolver之间的关系。ApplicationContentResolver是ContetResover的子类，用于访问ContentProvider。

（2）创建Application对象

public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
        ...
        Application app = null;
        try {
            java.lang.ClassLoader cl = getClassLoader();
            ...
            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
        } catch (Exception e) {
            ...
        }
        mActivityThread.mAllApplications.add(app);
        mApplication = app;

        if (instrumentation != null) {
            try {
                instrumentation.callApplicationOnCreate(app);
            } catch (Exception e) {
                if (!instrumentation.onException(app, e)) {
                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
                    throw new RuntimeException(
                        "Unable to create application " + app.getClass().getName()
                        + ": " + e.toString(), e);
                }
            }
        }
        ...
        return app;
}

newApplication通过反射机制创建Application对象，将其与系统Context关联在一起。

static public Application newApplication(Class<?> clazz, Context context)
            throws InstantiationException, IllegalAccessException,
            ClassNotFoundException {
        Application app = (Application)clazz.newInstance();
        app.attach(context);
        return app;
}

Application继承自ContextWrapper，attach调用attachBaseContext将系统context保存到ContextWrapper.mBase成员变量中，然后读取Context保存的LoadedApk，并将其存入mLoadedApk中。

    final void attach(Context context) {
        attachBaseContext(context);
        mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
    }

1.3.2 第二阶段：AMS.setSystemProcess()

public void setSystemProcess() {
        try {
            ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
            ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
            ServiceManager.addService("meminfo", new MemBinder(this));
            ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
            ServiceManager.addService("dbinfo", new DbBinder(this));
            if (MONITOR_CPU_USAGE) {
                ServiceManager.addService("cpuinfo", new CpuBinder(this));
            }
            ServiceManager.addService("permission", new PermissionController(this));
            ServiceManager.addService("processinfo", new ProcessInfoService(this));

            ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                    "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
            mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

            synchronized (this) {
                ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
                app.persistent = true;
                app.pid = MY_PID;
                app.maxAdj = ProcessList.SYSTEM_ADJ;
                app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
                synchronized (mPidsSelfLocked) {
                    mPidsSelfLocked.put(app.pid, app);
                }
                updateLruProcessLocked(app, false, null);
                updateOomAdjLocked();
            }
        } catch (PackageManager.NameNotFoundException e) {
            throw new RuntimeException(
                    "Unable to find android system package", e);
        }
 }

主要做了这几件事
1、注册了一些其他服务，meminfo，gfxinfo用于调试，permission用于检查进程权限，
2、通过PM获取package名为“android”的应用的ApplicationInfo；
3、调用ActivityThread的installSystemApplicationInfo；
4、创建并处理ProcessRecord。

installSystemApplicationInfo ()方法：它主要处理了将package名为“android”的应用的ApplicationInfo;(即framework-res.apk，资源apk)赋值给LoadedApk。
在SystemServer.run()下startOtherServices();方法中有一类似的代码mActivityManagerService.installSystemProviders();此方法是加载运行在SystemServer进程中的ContentProvider，即SettingsProvider.apk (定义于frameworks/base/packages/SettingsProvider)。最终ContentProvider信息都将注册到AMS中的mProviderMap集合中。

1.3.3 第三阶段：AMS.systemReady()

public void systemReady(final Runnable goingCallback, BootTimingsTraceLog traceLog) {
...
//通知一些服务可以进行systemReady相关的工作，并进行启动服务或应用进程的工作
...
//开启HomeActivity
startHomeActivityLocked(currentUserId, "systemReady");
...
}