- 概述
- ActivityManagerService启动流程
- 参考资料
概述
ActivityManagerService（以后简称AMS）Android中最核心的服务 ， 主要负责系统中四大组件的启动、切换、调度及应用进程的管理和调度等工作，其职责与操作系统中的进程管理和调度模块类似，因此它在Android中非常重要
AMS的家族类图如下
ActivityManagerService启动流程
AMS和其他系统服务一样，在SystemServer进程里启动
[–＞SystemServer.java：ServerThread的run函数]：
Slog.i( TAG , "Activity Manager" );
//【1】调用ActivityManagerService.main设置context
context=ActivityManagerService.main(factoryTest);
//【2】setSystemProcess：这样system_server进程可加到AMS中，并被它管理
ActivityManagerService.setSystemProcess();
//【3】将SettingsProvider放到system_server进程中来运行
ActivityManagerService.installSystemProviders();
//【4】在内部保存WindowManagerService
ActivityManagerService.self().setWindowManager(wm);
//【5】AMS是系统的核心，只有它准备好后，才能调用其他服务的systemReady（少量服务除外）
ActivityManagerService.self().systemReady( new Runnable() {
public void run() {
startSystemUi(contextF); //启动systemUi。如此，状态栏就准备好了
//...
Watchdog.getInstance().start(); //启动Watchdog
//...
}
});1.ActivityManagerService.main(int factoryTest)函数分析
[–＞ActivityManagerService.java：ActivityManagerService的main函数]：
public static final Context main(int factoryTest) {
AThread thr = new AThread();
thr.start();//【1】创建一个名为“ActivityManager”线程，进行构造ActivityManagerService
synchronized (thr) {
while (thr.mService == null) {
try {
thr.wait();//等待AThread线程thr把thr.mService -> ActivityManagerService构造完成
} catch (InterruptedException e) {
}
}
}
ActivityManagerService m = thr.mService;
mSelf = m;//mSelf = m = thr.mService -> ActivityManagerService
ActivityThread at = ActivityThread.systemMain();//【2】构造和初始化ActivityThread，systemMain函数将为system_server进程搭建一个和应用进程一样的Android运行环境
mSystemThread = at;//mSystemThread = at -> ActivityThread
Context context = at.getSystemContext();//【3】获取Context, 其实在ActivityThread.systemMain()构建的
context.setTheme(android.R.style.Theme_Holo);
m.mContext = context;
m.mFactoryTest = factoryTest;
m.mMainStack = new ActivityStack(m, context, true);//【4】构造ActivityStack
m.mBatteryStatsService.publish(context);
m.mUsageStatsService.publish(context);
synchronized (thr) {
thr.mReady = true;
thr.notifyAll();//通知线程thr，让它继续工作
}
m.startRunning(null, null, null, null);//【5】调用ActivityManagerService的startRunning
return context;
}- AMS的main函数首先创建一个线程AThread去new ActivityManagerService()构造AMS, 并等待AThread构造AMS完毕(此时AThread线程进入等待, 直到ASM的main函数所在线程通知它,它就进入loop状态),
- 然后main函数调用ActivityThread.systemMain()构造和初始化ActivityThread, 这函数会将system_server进程搭建成一个和应用进程一样的Android运行环境
- 然后调用ActivityThread的getSystemContexth()函数获取一个Context, (此context在system_server里多处使用), getSystemContexth()函数在上一步ActivityThread.systemMain()第一次调用, 那时进行初始化的, 这里第二次就直接返回上次初始化的Context
- 构建ActivityStack(用于管理Activity的任务堆栈, 暂时不去了解)
- 调用AThread的notifyAll()通知它继续工作(它会进入loop状态), 然后调用AMS的startRunning
1.1构造AMS
先查看AThread类的run方法,AMS在这里生成实例
[–＞ActivityManagerService.java：AThread的run函数]：
public void run() {
Looper.prepare();//成为Handler线程
android.os.Process.setThreadPriority(
android.os.Process.THREAD_PRIORITY_FOREGROUND);//设置线程优先级
android.os.Process.setCanSelfBackground(false);//设置成不可设置成后台线程
ActivityManagerService m = new ActivityManagerService();//在这个线程里构造ActivityManagerService
synchronized (this) {
mService = m;
notifyAll();//通知AMS的main函数线程ASM已经构造完毕，转到那个线程工作去
}
synchronized (this) {
while (!mReady) {
try {
wait();//等待ActivityManagerService.main(factoryTest)所在线程ServerThread通知
} catch (InterruptedException e) {
}
}
}
Looper.loop();//进入loop状态，用于接收信息
}run()方法逻辑比较简单, 设置线程优先级、new AMS实例、转到ASM的main函数线程(system_server的工作线程)、等AMS的main函数所在线程通知后进入loop状态，接下来重点看看AMS的构造函数
[–＞ActivityManagerService.java：ActivityManagerService的ActivityManagerService()构造函数]：
private ActivityManagerService() {
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system");
systemDir.mkdirs();
mBatteryStatsService = new BatteryStatsService(new File(////【1】创建BatteryStatsService（以后简称BSS）和UsageStatsService（以后简称USS）
systemDir, "batterystats.bin").toString());
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.getActiveStatistics().writeAsyncLocked();
mOnBattery = DEBUG_POWER ? true
: mBatteryStatsService.getActiveStatistics().getIsOnBattery();
mBatteryStatsService.getActiveStatistics().setCallback(this);
mUsageStatsService = new UsageStatsService(new File(
systemDir, "usagestats").toString());
GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version",//获取OpenGl版本
ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
mConfiguration.setToDefaults();//设置默认的Configuration
mConfiguration.locale = Locale.getDefault();
mConfigurationSeq = mConfiguration.seq = 1;
mProcessStats.init();//【2】对mProcessStats进行init初始化，它为ProcessStats类型，用于统计CPU、内存等信息。其内部工作原理就是
//读取并解析/proc/stat文件的内容。该文件由内核生成，用于记录kernel及system
mCompatModePackages = new CompatModePackages(this, systemDir);//解析/data/system/packages-compat.xml文件，该文件用于存储那些需要考虑屏幕尺寸的APK的一些信息
// Add ourself to the Watchdog monitors.
Watchdog.getInstance().addMonitor(this);
mProcessStatsThread = new Thread("ProcessStats") {
public void run() {
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;
if (nextWriteDelay < nextCpuDelay) {
nextCpuDelay = nextWriteDelay;
}
if (nextCpuDelay > 0) {
mProcessStatsMutexFree.set(true);
this.wait(nextCpuDelay);
}
}
} catch (InterruptedException e) {
}
updateCpuStatsNow();
} catch (Exception e) {
Slog.e(TAG, "Unexpected exception collecting process stats", e);
}
}
}
};
mProcessStatsThread.start();//【3】该线程用于统计activity的cpu使用率和耗电量，启动它
}构造函数主要是创建BatteryStatsService和UsageStatsService, 对ProcessStats进行初始化, 然后启动统计Activity的cpu使用率和耗电量的线程
1.2ActivityThread.systemMain()
[–＞ActivityThread.java：ActivityThread的systemMain()函数]：
public static final ActivityThread systemMain() {
HardwareRenderer.disable(true);//禁止硬件渲染加速
ActivityThread thread = new ActivityThread();//构造ActivityThread，它代表一个应用进程的主线程，其职责就是调度及执行在该线程中运行的四大组件
thread.attach(true);//调用attach，参数true说明是系统进程, 给system_server创建Android运行环境， 也就是归入AMS管理
return thread;
}这函数主要是给ActivityThread初始化以及给system_server进程创建Android运行环境
[–＞ActivityThread.java：ActivityThread的ActivityThread()构造函数]：
ActivityThread() {
}构造函数什么都没干, 但是创建AT(ActivityThread的简称)时, 成语变量初始化时候需要注意ApplicationThread和 H （extends Handler）的初始化
[–＞ActivityThread.java：ActivityThread的attach(boolean system)函数]：
private void attach(boolean system) {//这时传入的system参数为true
sThreadLocal.set(this);
mSystemThread = system;
if (!system) {// app应用进程
// 略...
} 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");//设置DDMS时看到的system_server进程名为system_process
try {//app重要的Instrumentation、ContextImpl、Application初始化
mInstrumentation = new Instrumentation();//【1】构造Instrumentation实例，这个类可能主要作用是用于测试
ContextImpl context = new ContextImpl();//【2】构造ContextImpl，然后调用init进行初始化
context.init(getSystemContext().mPackageInfo, null, this);//初始化context，其中getSystemContext()函数会生成一个代表system的ContextImpl
Application app = Instrumentation.newApplication(Application.class, context);//【3】利用Instrumentation静态方法创建一个Application对象，会调用app.attach()
mAllApplications.add(app);
mInitialApplication = app;
app.onCreate();//【4】调用app的Application的onCreate函数, 其实对于system没有任何操作
} catch (Exception e) {
throw new RuntimeException(
"Unable to instantiate Application():" + e.toString(), e);
}
}
// 设置Configuration发生变化时的回调函数(比如屏幕旋转)
ViewRootImpl.addConfigCallback(new ComponentCallbacks2() {
public void onConfigurationChanged(Configuration newConfig) {
// 略...
}
public void onLowMemory() {
}
public void onTrimMemory(int level) {
}
});
}- 构造Instrumentation实例，这个类可能主要作用是用于测试
- 构造ContextImpl，然后调用init进行初始化，注意这里的参数里的getSystemContext()函数，这函数会构造另一个ContextImpl，然后都用context.init(Resources.getSystem(), mainThread)和context.init(info, null, this)便成了代表System的ContextImpl，其中Resources.getSystem()是代表系统资源，mainThread为this，就是这个ActivityThread，info是包名为“android”的LoadedApk。接着设置成为原先的ContextImpl的mSystemContext。然后调用原先的ContextImpl的context.init(getSystemContext().mPackageInfo, null, this);其实这时原先的ContextImpl和刚刚代表的System的Context的mPackageInfo、mResources、mMainThread一样的，另外还构造一个心的mContentResolver（ApplicationContentResolver）。
Instrumentation.newApplication(Application.class, context)见下面的代码，就是构造一个Application实例，然后调用attach函数, 最终使得这个Application实例的mBase = context, mLoadedApk = context的mPackageInfo, 这个Application实例保存在ActivityThread的mInitialApplication
static public Application newApplication(Class<?> clazz, Context context) throws InstantiationException, IllegalAccessException, ClassNotFoundException { Application app = (Application)clazz.newInstance(); app.attach(context); return app; }/* package */ final void attach(Context context) { attachBaseContext(context);//mBase = context; mLoadedApk = ContextImpl.getImpl(context).mPackageInfo; }调用app的Application的onCreate函数, 其实对于system没有任何操作
总的来说, ActivityThread的attach(true)函数就是设置初始化AMS的成员mContext和mSystemThread(ActivityThread类),其中初始化了mSystemThread的成员mInitialApplication(Application类)中的mBase(ContextImpl类, 就是和mSystemContext类似的另一个实例)以及mLoadedApk(ContextImpl的mPackageInfo)
1.3ActivityManagerService的main函数总结
m.mMainStack = new ActivityStack(m, context, true);//【4】构造ActivityStack这里暂时不分析, m.startRunning(null, null, null, null);//【5】调用ActivityManagerService的startRunning这里实际也什么都没干, 所以main函数就结束了, 返回了AT的mSystemContex
2.ActivityManagerService.setSystemProcess()函数分析
[–＞ActivityManagerService.java：ActivityManagerService的setSystemProcess()函数]：
public static void setSystemProcess() {
try {
ActivityManagerService m = mSelf;
//【1】向ServiceManager注册这些服务
ServiceManager.addService("activity", m);
ServiceManager.addService("meminfo", new MemBinder(m));
ServiceManager.addService("gfxinfo", new GraphicsBinder(m));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(m));
}
ServiceManager.addService("permission", new PermissionController(m));
//【2】通过PKMS获取包名为android（就是framework-res.apk）的ApplicationInfo(AndroidManifest.xml's <application> tag 里声明的所有信息)
ApplicationInfo info =
mSelf.mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS);
mSystemThread.installSystemApplicationInfo(info);//设置mSystemThread的systemContext的LoadedApk的ApplicationInfo为info
//【3】构造和初始化代表system_server的ProcessRecord, 保存在AMS的mProcessNames和mPidsSelfLocked, 使得AMS能管理system_server进程
synchronized (mSelf) {
ProcessRecord app = mSelf.newProcessRecordLocked(
mSystemThread.getApplicationThread(), info,
info.processName);
app.persistent = true;//系统进程需要设置一些特殊值
app.pid = MY_PID;
app.maxAdj = ProcessList.SYSTEM_ADJ;
mSelf.mProcessNames.put(app.processName, app.info.uid, app);//mProcessNames： Map(processname, SparseArray(uid, ProcessRecord))
synchronized (mSelf.mPidsSelfLocked) {
mSelf.mPidsSelfLocked.put(app.pid, app);
}
mSelf.updateLruProcessLocked(app, true, true);
}
} catch (PackageManager.NameNotFoundException e) {
throw new RuntimeException(
"Unable to find android system package", e);
}
}- 向ServiceManager注册”activity”、”meminfo”、”gfxinfo”、”cpuinfo”、”permission”等服务
- 通过PKMS获取包名为android（就是framework-res.apk）的ApplicationInfo(AndroidManifest.xml’s tag 里声明的所有信息)，然后保持在AMS的mSystemThread（AtivityThread类）的mSystemContext(ContextImpl类)的mPackageInfo(LoadedApk)的mApplicationInfo(ApplicationInfol类)里
- 新建一个ProcessRecord实例, 它代表AMS管理每一个App进程的各种信息, 现在新建的ProcessRecord实例app代表的是system_server进程, 因为是系统进程所以还需要一些特别设置。然后保存这个ProcessRecord实例在AMS的mProcessNames和mPidsSelfLocked里，然后AMS更新LruProcess（
mSelf.updateLruProcessLocked(app, true, true)）
3.ActivityManagerService.installSystemProviders()函数分析
[–＞ActivityManagerService.java]：
public static final void installSystemProviders() {
List<ProviderInfo> providers;
synchronized (mSelf) {
ProcessRecord app = mSelf.mProcessNames.get("system", Process.SYSTEM_UID);
//【1】通过系统进程的processName和uid获取ContentProvider
providers = mSelf.generateApplicationProvidersLocked(app);
if (providers != null) {
for (int i=providers.size()-1; i>=0; i--) {//【2】删除不是系统的provider
ProviderInfo pi = (ProviderInfo)providers.get(i);
if ((pi.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) == 0) {
Slog.w(TAG, "Not installing system proc provider " + pi.name
+ ": not system .apk");
providers.remove(i);
}
}
}
}
if (providers != null) {//【3】调用ActivityThread的installSystemProviders,保存ContentProvider相关信息在AT里
mSystemThread.installSystemProviders(providers);
}
// 创建CoreSettingsObserver辅助类来减少IO次数
mSelf.mCoreSettingsObserver = new CoreSettingsObserver(mSelf);
mSelf.mUsageStatsService.monitorPackages();
}该函数作用主要是安装SettingsProvider, 就是把SettingsProvider的ContentProvider放到system_server进程上运行.主要步骤:
- 调用AMS的generateApplicationProvidersLocked(app)获取system进程(就是上面生成的代表system_server的ProcessRecord)的ContentProvider.通过跟进代码可知道是通过PKMS查询Manifest文件, 获取processName为app.processName(system)和uid为app.info.uid(systme)的ContentProvider, 并把ContentProviderRecord保存在AMS的mProvidersByClass和ProcessRecord的pubProviders里
- 删除上一步获取到的不是系统的provider
- 调用AMS的AT的installSystemProviders(providers)方法把Provders和AT联系起来, 然后向ASM注册, 使得这些ContentProvider可被使用, 详情见下面分析
3.1mSystemThread.installSystemProviders(providers)
[–＞ActivityThread.java]：
public final void installSystemProviders(List<ProviderInfo> providers) {
if (providers != null) {
installContentProviders(mInitialApplication, providers);
}
}private void installContentProviders(
Context context, List<ProviderInfo> providers) {
final ArrayList<IActivityManager.ContentProviderHolder> results =
new ArrayList<IActivityManager.ContentProviderHolder>();
Iterator<ProviderInfo> i = providers.iterator();
while (i.hasNext()) {
ProviderInfo cpi = i.next();
// 略去部分代码...
IContentProvider cp = installProvider(context, null, cpi,
false /*noisy*/, true /*noReleaseNeeded*/);//【1】获取一个IContentProvider实例
if (cp != null) {
IActivityManager.ContentProviderHolder cph =
new IActivityManager.ContentProviderHolder(cpi);
cph.provider = cp;
cph.noReleaseNeeded = true;
results.add(cph);
}
}
try {
ActivityManagerNative.getDefault().publishContentProviders(
getApplicationThread(), results);//【2】向AMS注册ContentProviders
} catch (RemoteException ex) {
}
}通过AT的installProvider函数获取每个Provider的IContentProvider实例, 对IContentProvider实例进行初始化, 调用它的onCreat回调, 然后保存对应的author和jBinder的ProviderClientRecord实例到AT的mProviderMap和mLocalProviders里
private IContentProvider installProvider(Context context, IContentProvider provider, ProviderInfo info, boolean noisy, boolean noReleaseNeeded) { ContentProvider localProvider = null; if (provider == null) { Context c = null; ApplicationInfo ai = info.applicationInfo; // 这个Provider是SettingsProvider,它的包名是com.android.providers.settings, 而context=mInitialApplication, 包名为android, 所以走else分支 if (context.getPackageName().equals(ai.packageName)) { c = context; } else if (mInitialApplication != null && mInitialApplication.getPackageName().equals(ai.packageName)) { c = mInitialApplication; } else { try { //【1】创建SettingsProvider包名的Context c = context.createPackageContext(ai.packageName, Context.CONTEXT_INCLUDE_CODE); } catch (PackageManager.NameNotFoundException e) { // Ignore } } // 略去部分代码... try { //【2】用反射构建出SettingsProvider的ContentProvider实例(info.name就是AndroidManifest文件Provider的name节点), 然后获取要返回的mTransport成员,这是一个Binder的Bn对象 final java.lang.ClassLoader cl = c.getClassLoader(); localProvider = (ContentProvider)cl. loadClass(info.name).newInstance(); // 返回ContentProvider的mTransport成员,这是一个Binder的Bn对象 provider = localProvider.getIContentProvider(); if (provider == null) { return null; } // XXX Need to create the correct context for this provider. //【3】初始化ContentProvider, 会回调它的onCreat方法 localProvider.attachInfo(c, info); } catch (java.lang.Exception e) { // 略去部分代码... return null; } } // 略去部分代码... synchronized (mProviderMap) { // There is a possibility that this thread raced with another thread to // add the provider. If we find another thread got there first then we // just get out of the way and return the original provider. IBinder jBinder = provider.asBinder(); String names[] = PATTERN_SEMICOLON.split(info.authority); //【4】以Provider的authority创建ProviderClientRecord保存在AT的mProviderMap(key为Provider的authority), 注意, 一个Provider实例可能有几个authority, 所就可能有几个对应的ProviderClientRecord for (int i = 0; i < names.length; i++) { ProviderClientRecord pr = mProviderMap.get(names[i]); if (pr != null) { // 如果已经有使用这个authority的Provider了,则用已经有的,放弃这次的 provider = pr.mProvider; } else { // 没有使用这个authority的Provider了 pr = new ProviderClientRecord(names[i], provider, localProvider); if (localProvider == null) { try { jBinder.linkToDeath(pr, 0); } catch (RemoteException e) { return null; } } // 把该Provider的ProviderClientRecord保存到AT的mProviderMap mProviderMap.put(names[i], pr); } } //【5】以Provider的IBinder jBinder创建ProviderClientRecord保存在ATmLocalProviders, 一个Provider实例只有一个jBinder. if (localProvider != null) { ProviderClientRecord pr = mLocalProviders.get(jBinder); if (pr != null) { provider = pr.mProvider; } else { // 把该Provider的ProviderClientRecord保存到AT的mLocalProviders pr = new ProviderClientRecord(null, provider, localProvider); mLocalProviders.put(jBinder, pr); } } if (!noReleaseNeeded) { //这是true, 代表是常驻 // 略去部分代码... } } return provider; }获取到这个进程(ProcessRecord)相关的所有IContentProvider实例后, 通过Binder调用AMS的publishContentProviders(其实是同一进程)向AMS注册这个ContentProvider,这样其他app才能使用这个ContentProvider.注册主要是指把这个CP的ContentProviderRecord保存到AMS的mProvidersByClass(以ComponentName为key)和mProvidersByName(以author为key)两个变量里
public final void publishContentProviders(IApplicationThread caller, List<ContentProviderHolder> providers) { // 略去部分代码... synchronized(this) { final ProcessRecord r = getRecordForAppLocked(caller);//找到调用者的ProcessRecord // 略去部分代码... final int N = providers.size(); for (int i=0; i<N; i++) { ContentProviderHolder src = providers.get(i); if (src == null || src.info == null || src.provider == null) { continue; } // 从调用者的ProcessRecored找到name一样的CP ContentProviderRecord dst = r.pubProviders.get(src.info.name); if (dst != null) { ComponentName comp = new ComponentName(dst.info.packageName, dst.info.name); mProvidersByClass.put(comp, dst);//把这个CPR放到AMS的mProvidersByClass(以ComponentName为key) String names[] = dst.info.authority.split(";"); for (int j = 0; j < names.length; j++) { mProvidersByName.put(names[j], dst);//把这个CPR放到AMS的mProvidersByName(以author为key) } // 略去部分代码... synchronized (dst) { dst.provider = src.provider; dst.proc = r; dst.notifyAll();// 通知那些等待ContentProvider所在进程启动的客户端进程 } updateOomAdjLocked(r); } } Binder.restoreCallingIdentity(origId); } }
4.ActivityManagerService的systemReady(final Runnable goingCallback)函数分析
[–＞ActivityManagerService.java]：
public void systemReady(final Runnable goingCallback) {
synchronized(this) {
// 略去部分代码...
if (!mDidUpdate) {// 第一次进入时mDidUpdate为false
if (mWaitingUpdate) {
return;
}
//【1】系统更新时，通知一些app更新数据（这些app只能是系统app）
Intent intent = new Intent(Intent.ACTION_PRE_BOOT_COMPLETED);
List<ResolveInfo> ris = null;
try {//com.android.providers.contacts.ContactsUpgradeReceiver，com.android.providers.calendar.CalendarUpgradeReceiver，com.android.providers.media.MediaUpgradeReceiver
ris = AppGlobals.getPackageManager().queryIntentReceivers(
intent, null, 0);
} catch (RemoteException e) {
}
if (ris != null) {
for (int i=ris.size()-1; i>=0; i--) {
if ((ris.get(i).activityInfo.applicationInfo.flags
&ApplicationInfo.FLAG_SYSTEM) == 0) {//只有系统app才能接收这个广播
ris.remove(i);
}
}
intent.addFlags(Intent.FLAG_RECEIVER_BOOT_UPGRADE);
// 上次处理这个intent的comp名字保存在文件/data/system/called_pre_boots.dat 里
// 系统更新前只处理一次
ArrayList<ComponentName> lastDoneReceivers = readLastDonePreBootReceivers();
final ArrayList<ComponentName> doneReceivers = new ArrayList<ComponentName>();
for (int i=0; i<ris.size(); i++) {
ActivityInfo ai = ris.get(i).activityInfo;
ComponentName comp = new ComponentName(ai.packageName, ai.name);
if (lastDoneReceivers.contains(comp)) {
ris.remove(i);
i--;
}
}
for (int i=0; i<ris.size(); i++) {
ActivityInfo ai = ris.get(i).activityInfo;
ComponentName comp = new ComponentName(ai.packageName, ai.name);
doneReceivers.add(comp);
intent.setComponent(comp);
IIntentReceiver finisher = null;
if (i == ris.size()-1) {// 最后一个处理完后
finisher = new IIntentReceiver.Stub() {
public void performReceive(Intent intent, int resultCode,
String data, Bundle extras, boolean ordered,
boolean sticky) {
mHandler.post(new Runnable() {
public void run() {
synchronized (ActivityManagerService.this) {
mDidUpdate = true;
}
writeLastDonePreBootReceivers(doneReceivers);//写到文件文件/data/system/called_pre_boots.dat 里
showBootMessage(mContext.getText(
R.string.android_upgrading_complete),
false);
systemReady(goingCallback);// 第二次进入systemReady, 此时mDidUpdate = true
}
});
}
};
}
Slog.i(TAG, "Sending system update to: " + intent.getComponent());
broadcastIntentLocked(null, null, intent, null, finisher,// 发送给每个receiver
0, null, null, null, true, false, MY_PID, Process.SYSTEM_UID);
if (finisher != null) {
mWaitingUpdate = true;
}
}
}
if (mWaitingUpdate) {
return;
}
mDidUpdate = true;
}
mSystemReady = true;
if (!mStartRunning) {
return;
}
}
//【2】杀掉一些AMS还未启动完成就已经启动的app进程
ArrayList<ProcessRecord> procsToKill = null;
synchronized(mPidsSelfLocked) {
for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
ProcessRecord proc = mPidsSelfLocked.valueAt(i);
if (!isAllowedWhileBooting(proc.info)){//“在AMS还未启动完毕就启动完了呢？对，那些声明了persistent为true的进程有可能”
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();// 从Settings里获取DEBUG_APP WAIT_FOR_DEBUGGER ALWAYS_FINISH_ACTIVITIES等属性
//【3】运行goingCallback
if (goingCallback != null) goingCallback.run();
//【4】启动声明了persistent的app
synchronized (this) {
if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
try {
List apps = AppGlobals.getPackageManager().
getPersistentApplications(STOCK_PM_FLAGS);
if (apps != null) {
int N = apps.size();
int i;
for (i=0; i<N; i++) {
ApplicationInfo info
= (ApplicationInfo)apps.get(i);
if (info != null &&
!info.packageName.equals("android")) {
addAppLocked(info);
}
}
}
} catch (RemoteException ex) {
// pm is in same process, this will never happen.
}
}
// Start up initial activity.
mBooting = true;
// 略去部分代码...
//【5】启动Home, 注意:Home启动完成后会AMS会发送ACTION_BOOT_COMPLETED广播
mMainStack.resumeTopActivityLocked(null);
}
}- 系统更新时，通知一些系统app更新数据。这个过程是通过发送ACTION_PRE_BOOT_COMPLETED广播给系统app来完成的，广播接收者处理这个广播后这个广播接收者会被记录在文件里，防止第二次处理
- ACTION_PRE_BOOT_COMPLETED都处理完后，杀掉一些AMS还未启动完成就已经启动的app进程，这些app进程可能是那些声明了persistent为true的进程
- 运行goingCallback，就是systemReady函数的参数,是个Runnable，在SystemServer.java里可以看到这个Runnable里主要是通知其他Service，ASM已经准备就绪，其他Service执行相应操作
- 启动声明了persistent的app
- 启动Home, 注意:Home启动完成后会AMS会发送ACTION_BOOT_COMPLETED广播
5.AMS启动流程总结
启动过程中涉及到的AMS相关类关系图如下
- context=ActivityManagerService.main(factoryTest);
创建ActivityManagerService实例, ActivityThread实例(AMS的mSystemTread), 初始化AMS的mContext和AT的mSystemContext(是ContextImpl的实例) - ActivityManagerService.setSystemProcess();
- 向ServiceManager注册”activity”、”meminfo”、”gfxinfo”、”cpuinfo”、”permission”等服务
- 然后把framework-res.apk的的ApplicationInfo保存在AT的mSystemContext里
- 接着创建ProcessRecord实例,它代表AMS管理每一个App进程的各种信息,从此system_server进程也受AMS管理
- ActivityManagerService.installSystemProviders();
注册SettingsProvider, 其他进程就可读写Settings了 - ActivityManagerService.self().systemReady( new Runnable() {…} )
- 系统更新时，通知一些系统app更新数据.
- 通知其他service, AMS已经准备好, 其他Service做相应处理
- 启动声明了persistent的app
- 启动Home, Home启动完后AMS发送ACTION_BOOT_COMPLETED广播
