android 系统是否boot unlocked 代码安卓bootmanager

转载

数据分析家 2023-10-11 16:36:44

文章标签 android java android studio Android ide 文章分类 Android 移动开发

文章大纲

引言
一、ActivitityManagerService 概述
二、ActivityManagerService 体系结构概述

1、android.app.IActivityManager
2、IActivityManager.Stub/android.app.ActivityManagerNative.java
3、android.app.ActivityManagerProxy
4、com.android.server.am.ActivityManagerService
5、android.app.ActivityManager

三、ActivityManagerService 相关的重要类概述

1、ProcessRecord
2、四大组件的内存映射信息类
3、Activity 管理相关的类

2.1、ActivityRecord
2.2、TaskRecord
2.3、ActivityStarter
2.4、ActivityStack
2.5、ActivityStackSupervisor

四、ActivityManagerService 启动前的环境初始化
五、ActivityManagerService 服务的启动和运行。

1、SystemServer#mian方法中通过ActivityManagerService #main方法触发AMS启动
2、com.android.server.SystemServer#startBootstrapServices 方法触发创建和注册到ServiceManager
3、在com.android.server.SystemServiceManager#startService方法里反射AMS 对象并启动

3.1、ActivityManagerService 的构造方法
3.2、ActivityManagerService#start 方法

4、AMS 对象调用setSystemProcess 方法把SystemServer进程纳入管理
5、com.android.server.SystemServer#startOtherServices方法触发AMS#systemReady方法
6、AMS#systemReady方法
7、AMS# 启动HomeLauncher

引言

前文章介绍到Zygote进程会把SystemServer进程启动，在SystemServer的启动过程中会把Java层系统服务都一一启动，ActivitityManagerService 就是在这时候被启动的

这里只分析与AMS相关的启动流程。

初始化 SystemContext
创建SystemServiceManager 对象，用来启动后面的服务
启动系统服务，共分为三种系统服务：系统引导服务（Boot Service）、核心服务（Core Service）和其他服务（Other Service）
在引导服务（Boot Service）中启动ATM、AMS服务
在其他服务（Other Service）中完成AMS的最后工作systemReady

基于Android 28 ，为了阅读，本文约定方法表示Java的，而函数表示Native层概念，本章只涉及到AMS 的启动相关知识，其他AMS相关的敬请关注后续文章，仅供参考

一、ActivitityManagerService 概述

ActivitityManagerService（AMS）服务由SystemServer在启动过程中去启动的，是运行在SystemServer进程中，负责管理Android 四大组件以及所有用户进程管理和调度。AMS 和Zygote 通过sokect 通信完成用户进程的创建，在Framework 内部通过Binder 与其他用户进程进行通信。总之，AMS 管理Android 系统中所有的非Zygote的应用进程。

二、ActivityManagerService 体系结构概述

从一定程度上来说Android 就是一个微服务体系的操作系统，即Android =Linux + Framework 定制各种服务。而在Android 中系统核心服务都是采用Binder 服务的架构，当某个进程需要访问某个系统服务时首先得通过ServiceManager 获取其对应的Binder对象，从而调用对应的方法，至于中间的通信细节全部由Binder 通信去完成。

Android 应用层我们使用Binder 有两种方式：一种是通过AIDL 自动生成，另一种则是自己去继承Binder实现具体的通信框架代码，核心服务都是采用后者。

android 系统是否boot unlocked 代码安卓bootmanager_ide

1、android.app.IActivityManager

IActivityManager 是AMS的核心功能接口，定义了AMS 的所有功能，由于需要支持跨进程调用，因而继承了IInterface接口。

2、IActivityManager.Stub/android.app.ActivityManagerNative.java

Android低版本实现是ActivityManagerNative，高版本8.0后是以标准AIDL 语法自动生成的IActivityManager.Stub

IActivityManager.Stub/ActivityManagerNative 是一个抽象类除了实现AMS 的核心功能之外，还需要实现Binder 通信框架的功能。它提供了服务接口和Binder接口的相互转化功能，并在内部存储服务代理对像，并提供了getDefault方法返回服务代理对象。

3、android.app.ActivityManagerProxy

Android低版本是单独实现，高版本8.0后是以标准AIDL 语法自动生成的。

ActivityManagerProxy 是作为ActivityManagerNative 的嵌入类（非内部类）实现，是IActivityManager的代理Binder对象，用于与Server端提供的系统服务进行进程间通信

4、com.android.server.am.ActivityManagerService

ActivityManagerService继承自ActivityManagerNative 是提供给其他类调用的功能入口，提供Server端的系统服务。

5、android.app.ActivityManager

ActivityManager 相当于是对ActivityManagerProxy 的封装，间接持有了IActivityManager 引用，通过延迟初始化的方式来得到ActivityManagerProxy 的引用，从而通过这个引用调用其对应的方法。ActivityManager内部通过调用ActivityManagerNative的getDefault方法，可以得到一个ActivityManagerProxy对像的引用，进而通过该代理对像调用远程服务的方法

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;
                }
            };

延迟单例的实现：

public abstract class Singleton<T> {    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

三、ActivityManagerService 相关的重要类概述

1、ProcessRecord

ApplicationInfo info——AndroidManifest.xml中定义的Application信息
boolean isolated——是否是分离进程
int uid——进程uid
int userId——android多用户机制时系统用户的id，类似windows可以登录很多用户一样
String processName——进程名字，默认情况下是包名
IApplicationThread thread——是ApplicationThread的客户端，AMS就是通过这
个对象给apk进程发送异步消息的（管理四大组件的消息），所以只有这个对象不为空的情况下，
才代表apk进程可以使用了
int pid——进程的pid
ArraySet < String > pkgList——进程中运行的包
ArraySet < String > pkgDeps——进程运行依赖的包
ArrayList< ActivityRecord > activities——进程启动的所有的activity组件记录表
ArraySet< ServiceRecord >services——进程启动的所有的service组件记录表
ArraySet< ServiceRecord > receivers——广播接收器的记录表
ArraySet< ConnectionRecord > connections——进程里所有的Bind service的客户端信息
ArrayMap<String, ContentProviderRecord> pubProviders——进程发布到AMS 的ContentProvider和名字的映射

pub即publish（发布）的意思，ContentProvider需要安装然后把自己发布到系统（AMS）中后，才能使用，安装指的是apk进程加载ContentProvider子类、初始化、创建数据库等过程，发布是将ContentProvider的binder客户端注册到AMS中。

ArrayList< ContentProviderConnection > conProviders ——ContentProviderConnection容器，使用ContentProvider的客户端记录表
BroadcastRecord curReceiver——当前进程正在执行的广播
int maxAdj——进程的adj上限（adjustment）
int curRawAdj——当前正在计算的adj，这个值有可能大于maxAdj
int setRawAdj——上次计算的curRawAdj设置到lowmemorykiller系统后的adj
int curAdj——当前正在计算的adj，这是curRawAdj被maxAdj削平的值
int pssProcState——pss进程状态

VSS( Virtual Set Size )虚拟耗用内存（包含共享库占用的内存）
RSS(Resident Set Size )实际使用物理内存（包含共享库占用的内存）
PSS(Proportional Set Size )实际使用的物理内存（比例分配共享库占用的内存）
USS-(Unique Set Size )进程独自占用的物理内存（不包含共享库占用的内存）
一般来说内存占用大小是VSS >= RSS >= PSS >= USS

.long initialIdlePss——初始化pss
.long lastPss——上次pss
.long lastSwapPss——上次SwapPss数据
long lastCachedPss——上次CachedPss数据
long lastCachedSwapPss——上次CachedSwapPss数据
long lastActivityTime——上次使用时间
long lastStateTime——上次设置进程状态的时间
long fgInteractionTime——变成前台的时间
IBinder.DeathRecipient deathRecipient——apk进程退出运行的话，会触发这个对象的
binderDied()方法，来回收系统资源
boolean crashing——进程已经crash
Dialog crashDialog——crash对话框
Dialog anrDialog——anr显示对话框
String waitingToKill:后台进程被kill原因

Instrumentation 也可以说是apk的一个组件，如果我们不提供的话，系统会默认使用Instrumentation.java类，按照我们一般的理解，UI 线程控制activity的生命周期，是是直接调用Activity类的方法，实质上缺少UI线程调用的是Instrumentation的方法，由它在调用Activity涉及生命周期的方法，所有如果我们覆写了Instrumentation的这些方法，就可以了解所有的Activity的生命周期了.

ComponentName instrumentationClass——AndroidManifest.xml中定义的instrumentation信息
ApplicationInfo instrumentationInfo——instrumentation应用信息
String instrumentationProfileFile——instrumentation配置文件
IInstrumentationWatcher instrumentationWatcher——instrumentation监测器
BatteryStatsImpl mBatteryStats——电量信息
BatteryStatsImpl.Uid.Proc curProcBatteryStats——当前进程电量信息
boolean debugging——处于调试中
boolean waitedForDebugger——等待调试
Dialog waitDialog——等待对话框
ArraySet< ServiceRecord > executingServices：正在运行（executing）的ServiceRecord是怎么定义的？首先需要明确的是系统是怎么控制组件的？发送消息给apk进程，apk进程处理消息，上报消息完成，这被定义为一个完整的执行过程，因此正在执行（executing）被定义为发送消息到上报完成这段时间

2、四大组件的内存映射信息类

在Android 中进程的概念被弱化了，传统的Linux下进程是程序执行的再提，进程退出也意味着应用关闭，但是在Android中，进程只是组件运行的一个容器，当系统需要运行一个组件时，才启动包含它的进程，而当组件不再使用，进程也会被关闭，组件运行才是进程存在的意义，由于Android系统进程间的无缝结合，所以系统需要控制到组件级别，所有的组件信息都需要映射到系统。

ActivityRecord记录对应一个Activity的信息
ServiceRecord记录对应一个Service的信息
ConnectionRecord记录对应一个Bind service的客户端信息
ReceiverList对应处理同一事件的一组广播
ContentProviderRecord记录对应一个ContentProvider信息
ContentProviderConnection对应一个进程中的所有ContentProvider客户端.

3、Activity 管理相关的类

ActivityStackSupervisor 管理ActivityStack，ActivityStack 内部包含多个TaskRecord 列表，TaskRecord内部包含报个ActivityRecord。

2.1、ActivityRecord

ActivityRecord（An entry in the history stack, representing an activity）Activity栈栈中的一个条目，代表一个Activity的内存对象，ActivityRecord中存在着大量的成员变量描述一个Activity的所有信息。其中ActivityRecord中的成员变量task表示其所在的TaskRecord。

\frameworks\base\services\core\java\com\android\server\am\ActivityStarter.java

2.2、TaskRecord

TaskRecord内部维护一个 ArrayList< ActivityRecord > 用来保存ActivityRecord，其中TaskRecord中的mStack表示其所在的ActivityStack， startActivity()时也会创建一个TaskRecord，代表一个任务的的内存对象。

\frameworks\base\services\core\java\com\android\server\am\TaskRecord.java

2.3、ActivityStarter

Activity 的管理类。

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

2.4、ActivityStack

ActivityStack内部通过 ArrayList维护了 TaskRecord 列表，还持有ActivityStackSupervisor对象，ActivityStack是由ActivityStackSupervisor来创建的，实际ActivityStackSupervisor就是用来管理ActivityStack的。

2.5、ActivityStackSupervisor

ActivityStackSupervisor（Run all ActivityStacks through this ）就是用来管理ActivityStack。ActivityStackSupervisor内部有两个不同的ActivityStack对象——mHomeStack、mFocusedStack，用来管理不同的任务。 ActivityStackSupervisor内部包含了创建ActivityStack对象的方法。 AMS初始化时会创建一个ActivityStackSupervisor对象.

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

四、ActivityManagerService 启动前的环境初始化

而在SystemServer的run函数中，在启动AMS之前，还做了其他的环境初始化工作：

创建初始化Looper
加载android_servers本地库初始化和启动本地服务
调用了createSystemContext方法，主要用于初始化 System Context和SystemUi Context，并设置主题当SystemServer ，当调用createSystemContext()完毕后：

得到了一个ActivityThread对象，它代表当前进程 (此时为系统进程) 的主线程；
得到了一个Context对象，对于SystemServer而言，它包含的Application运行环境与framework-res.apk有关。

创建了一个SystemServiceManager 对象管理系统服务的创建、启动和处理生命周期事件。

private void run() {
        try {
             // 设置虚拟机的路径
            SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
          	...
           ...
               //初始化Looper
            Looper.prepareMainLooper();

            // Initialize native services.
            System.loadLibrary("android_servers");
            ...
            // Initialize the system context.
            createSystemContext();

            // Create the system service manager.
            mSystemServiceManager = new SystemServiceManager(mSystemContext);
            mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
            LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
        } 
    	...
    }

在SystemServer的run函数中，在启动AMS之前，调用了createSystemContext函，主要用来是初始化 System Context和SystemUi Context，并设置主题.

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);
}

五、ActivityManagerService 服务的启动和运行。

1、SystemServer#mian方法中通过ActivityManagerService #main方法触发AMS启动

/**
     * The main entry point from zygote.
     */
    public static void main(String[] args) {
        new SystemServer().run();
    }
    private void run() {
        try {
        // Start services.
        try {
            Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartServices");
            startBootstrapServices();
            startCoreServices();
            startOtherServices();
        } catch (Throwable ex) {
            Slog.e("System", "************ Failure starting system services", ex);
        }
        ...
        Looper.loop();
    }

2、com.android.server.SystemServer#startBootstrapServices 方法触发创建和注册到ServiceManager

private void startBootstrapServices() {
        // 通过Socket去与Linux 底层installd 进程去通信完成安装任务
        Installer installer = mSystemServiceManager.startService(Installer.class);

        // Activity manager runs the show.
        mActivityManagerService = mSystemServiceManager.startService(ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
        ...
        // Initialize attribute cache used to cache resources from packages.
        AttributeCache.init(mSystemContext);
        // Set up the Application instance for the system process and get started.
        mActivityManagerService.setSystemProcess();
         ...

3、在com.android.server.SystemServiceManager#startService方法里反射AMS 对象并启动

SystemServiceManager 是管理com.android.server.SystemService 系统服务的创建、启动和处理生命周期事件的管理里类，而ServiceManager 是Binder 体系里管理服务端的服务类，位于\frameworks\base\services\core\java\com\android\server\SystemServiceManager.java。

在startBootstrapServices 方法里传入的并不直接是ActivityManagerService.class 而是传入了一个名为Systemcom.android.server.am.ActivityManagerService.Lifecycle的class，

public <T extends SystemService> T startService(Class<T> serviceClass) {
    try {
        final String name = serviceClass.getName();
        // Create the service.
        final T service;
        try {
            Constructor<T> constructor = serviceClass.getConstructor(Context.class);
            service = constructor.newInstance(mContext);
        } 
   		  //{@link final ArrayList<SystemService> mServices = new ArrayList<SystemService>();} 把SystemService 对象缓存起来
        mServices.add(service);
        // Start it.
        try {
            // AMS#onStart
            service.onStart();
        } catch (RuntimeException ex) {
            throw new RuntimeException("Failed to start service " + name
                    + ": onStart threw an exception", ex);
        }
        return service;
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
    }
}

是通过反射调用ActivityManagerService.Lifecycle的构造函数，在其构造函数内部调用了AMS的构造方法直接new出了AMS对象。

为什么不直接反射AMS 的构造函数呢？可以好好思考一下！

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

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

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

    public ActivityManagerService getService() {
        return mService;
    }
}

3.1、ActivityManagerService 的构造方法

\frameworks\base\services\core\java\com\android\server\am\ActiveServices.java
\frameworks\base\services\core\java\com\android\server\am\BroadcastQueue.java
\frameworks\base\services\core\java\com\android\server\am\ProviderMap.java

ActivityManagerService 构造方法里主要是完成了四大基础组件的管理对象和线程通信相关初始化工作：

获取SystemServer 进程中的ActivityThread对象
创建通过消息处理机制与其他线程通信的Handler对象
创建Handler和Handler 对象用于线程间通信
创建广播的管理对象BroadcastQueue，主要就是几个List集合、数组存储广播
创建Service 服务的管理对象ActiveServices
创建内容提供者的管理对象ProviderMap，ContentProviderRecord 封装了IContentProvider Binder接口并被Provider 管理。
创建/data/system/目录
创建Activity 的管理对象
把AMS 对象添加到Android 自己实现的WatchDog 机制中监控

PMS的构造函数主要初始化一些成员变量并在/data/system下面建立一些文件(夹)供系统统计数据用，现将一些文件及其作用列在下面的表格中：
Service文件路径说明BatteryStatsService/data/system/batterystats.bin管理电池使用状态ProcessStatsService/data/system/procstats管理进程状态UsageStatsService/data/system/usagestats管理用户使用状态AppOpsService/data/system/appops.xml管理进程状态AtomicFile/data/system/urigrants.xml管理系统URI权限

public ActivityManagerService(Context systemContext) {
        mContext = systemContext;
        ...
        // 获取在当前线程（即SystemServer进程）中的ActivityThread 对象
        mSystemThread = ActivityThread.currentActivityThread();
    	 //创建通过消息处理机制与其他线程通信的Handler对象
        mHandlerThread = new ServiceThread(TAG,android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        mHandler = new MainHandler(mHandlerThread.getLooper());
        //专门处理展示UI相关的Handler对象
        mUiHandler = new UiHandler();
    	  //创建广播管理数据结构，创建 BroadcastQueue 前台广播对象，处理超时时长是 10s
        mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "foreground", BROADCAST_FG_TIMEOUT, false);
    // BroadcastQueue 后台广播对象，处理超时时长是 60s
        mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
                "background", BROADCAST_BG_TIMEOUT, true);
    	//{@link final BroadcastQueue[] mBroadcastQueues = new BroadcastQueue[2];}
        mBroadcastQueues[0] = mFgBroadcastQueue;
        mBroadcastQueues[1] = mBgBroadcastQueue;
// 创建 ActiveServices 对象，用于管理 ServiceRecord 对象
        mServices = new ActiveServices(this);
    //创建 ProviderMap 对象，用于管理 ContentProviderRecord 对象
        mProviderMap = new ProviderMap(this);
        mAppErrors = new AppErrors(mContext, this);

        // 获取/data/的路径
        File dataDir = Environment.getDataDirectory();
    	// 创建data/system/目录
        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);
			//进程状态保存在data/system/procstats/pid/目录下，提供dump服务的基础
        mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
    		...
        mGrantFile = new AtomicFile(new File(systemDir, "urigrants.xml"));

        mUserController = new UserController(this);
		 //从系统属性系统中获取对应的OpenGLES的版本
        GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",
            ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
        mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
			//创建Activity 管理对象
        mActivityStarter = new ActivityStarter(this, mStackSupervisor);
    		//创建最近打开任务对象
        mRecentTasks = new RecentTasks(this, mStackSupervisor);
		  //统计CPU ，如果写入太频繁就wait 
        mProcessCpuThread = new Thread("CpuTracker") {
            @Override
            public void run() {
                    ...
                }
            }
        };
		//把AMS 服务加到Android 自己实现的软件WatchDog 监控中
        Watchdog.getInstance().addMonitor(this);
        Watchdog.getInstance().addThread(mHandler);
            ...
      }
    }

3.2、ActivityManagerService#start 方法

AMS 对象被反射创建完毕之后，通过ActivityManagerService.Lifecycle触发ActivityManagerService#start方法执行。

private void start() {
        Process.removeAllProcessGroups();
        mProcessCpuThread.start();
			//发布电池服务等其他服务
        mBatteryStatsService.publish(mContext);
        //发布 管理系统URI权限
        mAppOpsService.publish(mContext);
        LocalServices.addService(ActivityManagerInternal.class, new LocalService());
    }

至此AMS 启动完成。

4、AMS 对象调用setSystemProcess 方法把SystemServer进程纳入管理

前面SystemServer 反射创建完AMS对象之后，会在其他一些系统核心服务（PowerManagerService、DisplayManagerService、PackageManagerService、UserManagerService等）调用AMS#setSystemProcess方法将framework-res.apk的信息加入到SystemServer进程的LoadedApk中，构建SystemServer进程的ProcessRecord，保存到AMS中，以便AMS进程统一管理

android.os.ServiceManager 是Binder 机制下管理服务端所有服务的对象（此服务并非Service 组件）

把AMS和相应的提供dump信息等服务注册到ServiceManager
通过PKMS 服务获取package名为“android”的应用的对应的ApplicationInfo
为ActivityThread 安装 system application相关信息，将framework-res.apk对应的ApplicationInfo安装到LoadedApk中的mApplicationInfo
为SystemServer 主进程开辟一个ProcessRecord来维护进程的相关信息
纳入AMS 进程管理中

从一定程度上来说SystemServer进程相当于是android.apk 运行后的应用进程

public void setSystemProcess() {
        try {
        		//AMS 注册到ServiceManager 供后续Binder通信
            ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
            //注册dump 进程信息的服务
            ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
            //注册每隔进程的内存使用状态的服务
            ServiceManager.addService("meminfo", new MemBinder(this));
            //注册dump 每个进程使用显卡的状态服务
            ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
            //注册dump 每隔进程的db 数据库状态的服务
            ServiceManager.addService("dbinfo", new DbBinder(this));
            if (MONITOR_CPU_USAGE) {
                ServiceManager.addService("cpuinfo", new CpuBinder(this));
            }
            //注册管理Binder 调用权限相关的服务
            ServiceManager.addService("permission", new PermissionController(this));
            // 注册进程信息服务
            ServiceManager.addService("processinfo", new ProcessInfoService(this));
				//通过PKMS获取指定apk（framework-res.apk）中的ApplicationInfo,即SystemServer进程对应的ApplicationInfo
            ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                    "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
            mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
            synchronized (this) {
                //出创建SystemServer进程对应的ProcessRecord对象
                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);
                }
                //调整期Adj 主要就是为了让他不易被误杀
                updateLruProcessLocked(app, false, null);
                updateOomAdjLocked();
            }
        } catch (PackageManager.NameNotFoundException e) {
            throw new RuntimeException("Unable to find android system package", e);
        }
    }

5、com.android.server.SystemServer#startOtherServices方法触发AMS#systemReady方法

在SystemServer#startBootstrapServices和SystemServer#startCoreServices执行完毕之后，SystemServer#startOtherServices方法跟着执行，然后在startOtherServices里触发AMS#systemReady方法前进行其他服务的初始化创建和启动以及触发对应的systemReady 方法执行。简而言之，许多服务或应用进程必须等待AMS完成启动工作后，才能启动或进行一些后续工作；AMS就是在systemReady中，通知或者启动这些等待的服务和应用进程，例如启动桌HomeLaucher等。

启动CameraService、AccountManagerService、ContentService等其他系统服务
ActivityManagerService#installSystemProviders 安装SystemServer进程中的SettingsProvider.apk
初始化WatchDog机制
初始化启动WindowManagerService 并调用WMS#systemReady方法

这里还涉及到其他系统服务WMS、PowerManagerService等，此处由于篇幅和主题的关系不再扩展

初始化NetworkPolicyManagerService网络策略管理服务
触发PowerManagerService#systemReady(mActivityManagerService.getAppOpsService())
触发PackageManagerService#systemReady()
最后触发AMS#systemReady 方法执行，在其传入的Runnable被回调时这些WebView、网络管理、网络策略、网络连接才真正就绪，同时启动SystemUI。

private void startOtherServices(){
    ...   
       mActivityManagerService.systemReady(new Runnable() {
                @Override
                public void run() 
                    Slog.i(TAG, "Making services ready");
    mActivityManagerService.startObservingNativeCrashes();
if (!mOnlyCore) 
                        Slog.i(TAG, "WebViewFactory preparation");
                        mWebViewUpdateService.prepareWebViewInSystemServer();

                        startSystemUi(context);
...
    if (networkManagementF != null) networkManagementF.systemReady();

                        if (networkStatsF != null) networkStatsF.systemReady();
 
                        if (networkPolicyF != null) networkPolicyF.systemReady();

                        if (connectivityF != null) connectivityF.systemReady();
 Watchdog.getInstance().start();
 mSystemServiceManager.startBootPhase(SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);

    if (locationF != null) locationF.systemRunning();
...
                        if (countryDetectorF != null) countryDetectorF.systemRunning();
                        if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
                        if (commonTimeMgmtServiceF != null) 
                            commonTimeMgmtServiceF.systemRunning();            
                        if (atlasF != null) atlasF.systemRunning();                  
                        // TODO(BT) Pass parameter to input manager
                        if (inputManagerF != null) inputManagerF.systemRunning();                
                        if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();                  
                        if (mediaRouterF != null) mediaRouterF.systemRunning();
                        if (mmsServiceF != null) mmsServiceF.systemRunning();                       if (networkScoreF != null) networkScoreF.systemRunning();
            });

6、AMS#systemReady方法

SystemServer 基本算是在启动完所有系统服务之后，触发AMS#systemReady方法的执行

主要是调用一些关键服务的初始化函数，然后标记mSystemReady为true
清理进程，主要是杀死那些没有FLAG_PERSISTENT却在AMS启动完成前已经存在的Java进程。(因为只有Java进程才会向AMS注册，而一般的Native进程不会向AMS注册），目的是确保在启动HomeLauncher前清理出一个干净的环境。

Android 自5.0 后支持带有persistent 标记的task，系统在关机时，这类task的信息会被自动保存在/data/system/recent_tasks目录下的taskId_task.xml里，当下一次系统重启时，通过读取这些文件的保存信息重建对应的task。换言之，如果系统应用希望在Home 启动前启动，那么可以加入FLAG_PERSITENT 标志，而接收ACTION_BOOT_COMPLETED的应用只能在HomeLauncher 启动后再启动。

读取配置信息，
执行goingCallback的处理,调用参数传入的Runnable对象，主要就是监控Native的crash，启动WebView，执行一些服务的systemReady 和systemRunning方，以及启动SystemUI 服务

com.android.systemui/.SystemUIService

在调用所有系统服务的onStartUser接口
启动persistent为1的application所在的进程
启动Home Activity，当启动结束，并发送ACTION_BOOT_COMPLETED广播时，AMS的启动过程告一段落

public void systemReady(final Runnable goingCallback) {
        synchronized(this) {
            //首次进来mSystemReady为false
            if (mSystemReady) {
                if (goingCallback != null) {
                    goingCallback.run();
                }
                return;
            }

            mLocalDeviceIdleController
                    = LocalServices.getService(DeviceIdleController.LocalService.class);

            // Make sure we have the current profile info, since it is needed for security checks.
            mUserController.onSystemReady();
            mRecentTasks.onSystemReadyLocked();
            mAppOpsService.systemReady();
            mSystemReady = true;
        }
		//两个代码块用于清理进程，把不允许在开机阶段运行的进程都结束掉，如果应用程序的AM配置文件是否有配置android:persistent属性。
        ArrayList<ProcessRecord> procsToKill = null;
        synchronized(mPidsSelfLocked) {
            for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
                ProcessRecord proc = mPidsSelfLocked.valueAt(i);
                if (!isAllowedWhileBooting(proc.info)){//检查进程是否有persssistent标志
                    if (procsToKill == null) {
                        procsToKill = new ArrayList<ProcessRecord>();
                    }
                    //采集
                    procsToKill.add(proc);
                }
            }
        }

        synchronized(this) {
            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);
                    //清理
                    removeProcessLocked(proc, true, false, "system update done");
                }
            }

            // Now that we have cleaned up any update processes, we are ready to start launching real processes and know that  we won't trample on them any more.
            mProcessesReady = true;
        }

        Slog.i(TAG, "System now ready");
			...
        retrieveSettings();
        final int currentUserId;
        synchronized (this) {
            currentUserId = mUserController.getCurrentUserIdLocked();
            readGrantedUriPermissionsLocked();
        }
//调用参数传入的runnable对象
       if (goingCallback != null) goingCallback.run();
    //调用所有系统服务的onStartUser接口
        mSystemServiceManager.startUser(currentUserId);

        synchronized (this) {
            // 启动persistent为1的application所在的进程
            startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_AWARE);
            // Start up initial activity.
            mBooting = true;
            // Enable home activity for system user, so that the system can always boot
            if (UserManager.isSplitSystemUser()) {
                ComponentName cName = new ComponentName(mContext, SystemUserHomeActivity.class);
                try {
                    AppGlobals.getPackageManager().setComponentEnabledSetting(cName,
                            PackageManager.COMPONENT_ENABLED_STATE_ENABLED, 0,
                            UserHandle.USER_SYSTEM);
                } 
            }
            //启动Home Acticity，如果系统只有一个Home Acticity的话没有歧义，但是如果有多个的话，这里实际是去启动ResolveActivity。
            startHomeActivityLocked(currentUserId, "systemReady");
				...
                    
  //2.发送一些广播消息
  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);
      }
    }

private void startPersistentApps(int matchFlags) {
...
  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 */);
              }
          }
      } 
  }
}

7、AMS# 启动HomeLauncher

当HomeLauncher被启动完成后，会回调到AMS中，再由AMS 发送ACTION_BOOT_COMPLETED 广播，篇幅问题，预知后事如何请听下回分解。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：java的堆栈线程大小怎么设置 jvm线程堆栈

下一篇：android view 强制刷新 android 刷新控件

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯