ActivityManagerService是Android Framework的核心，它管理着Android系统的4大组件：Activity、Service、ContentProvider、BroadcastReceiver。除此之外，ActivityManagerService还管理和调度所有用户进程。
1、AMS初始化
AMS运行在SystemServer进程中，对象的创建是在SystemServer类初始化时完成的，如下：
// Activity manager runs the show.
mActivityManagerService = mSystemServiceManager.startService(
ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);ActivityManagerService的构造方法如下：
// Note: This method is invoked on the main thread but may need to attach various
// handlers to other threads. So take care to be explicit about the looper.
public ActivityManagerService(Context systemContext) {
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
//获取运行在SystemServer中的ActivityThread对象
mSystemThread = ActivityThread.currentActivityThread();
Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
// 创建用于处理消息的线程和Handler对象
mHandlerThread = new ServiceThread(TAG,
android.os.Process.THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
mUiHandler = new UiHandler();
/* static; one-time init here */
if (sKillHandler == null) {
sKillThread = new ServiceThread(TAG + ":kill",
android.os.Process.THREAD_PRIORITY_BACKGROUND, true /* allowIo */);
sKillThread.start();
sKillHandler = new KillHandler(sKillThread.getLooper());
}
// 创建管理广播的数据结构
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;
mServices = new ActiveServices(this);// 创建管理组件Service的对象
mProviderMap = new ProviderMap(this);// 创建管理组件Provider的对象
mAppErrors = new AppErrors(mContext, this);
// TODO: Move creation of battery stats service outside of activity manager service.
File dataDir = Environment.getDataDirectory();
File systemDir = new File(dataDir, "system");
systemDir.mkdirs(); // /data/system/
// 创建BatteryStatsService服务,并创建了BatteryStatsImpl对象
mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);
//读取耗电量记录文件batterystats.bin
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.scheduleWriteToDisk(); // 更新数据
mOnBattery = DEBUG_POWER ? true
: mBatteryStatsService.getActiveStatistics().getIsOnBattery();// 是否在充电
mBatteryStatsService.getActiveStatistics().setCallback(this);// 设置回调
// 创建ProcessStats服务
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
// 创建AppOpsService服务，/data/system/appops.xml存储各个app的权限设置和操作信息
mAppOpsService = new AppOpsService(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);
}
}
}
});
// 打开文件 urigrants.xml
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"));
// mConfiguration 类型为Configuration,用于描述资源文件的配置属性，例如，字体、语言等
mConfiguration.setToDefaults();
mConfiguration.setLocales(LocaleList.getDefault());
mConfigurationSeq = mConfiguration.seq = 1;
//用来收集ANR、进程的CPU使用、电池的统计等信息；访问它时，必须获得此对象的锁。
mProcessCpuTracker.init();
//解析/data/system/packages-compat.xml文件，该文件用于存储那些需要考虑屏幕尺寸的APK信息，可以参考AnidroidManifest.xml
//中的compatible-screens相关说明，当APK所运行的设备不满足要求时，AMS会根据设置的参数以采用屏幕兼容的方式运行它。
mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
// 创建Intent防火墙
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
// 创建activity的管理对象
mStackSupervisor = new ActivityStackSupervisor(this);
mActivityStarter = new ActivityStarter(this, mStackSupervisor);
mRecentTasks = new RecentTasks(this, mStackSupervisor);
// 创建新的进程，用于定时更新系统信息，跟mProcessCpuTracker交互
mProcessCpuThread = new Thread("CpuTracker") {
@Override
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;
//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) {
Slog.e(TAG, "Unexpected exception collecting process stats", e);
}
}
}
};
// 将服务加到Watchdog的监控中
Watchdog.getInstance().addMonitor(this);
Watchdog.getInstance().addThread(mHandler);
mIsFreqAggrEnabled = mContext.getResources().getBoolean(
com.android.internal.R.bool.config_enableFreqAggr);
if(mIsFreqAggrEnabled) {
lFreqAggr_TimeOut = mContext.getResources().getInteger(
com.android.internal.R.integer.freqaggr_timeout_param);
lFreqAggr_Init_ParamVal = mContext.getResources().getIntArray(
com.android.internal.R.array.freqaggr_init_param_value);
lFreqAggr_ParamVal = mContext.getResources().getIntArray(
com.android.internal.R.array.freqaggr_param_value);
}
mIsLaunchBoostv2_enabled = mContext.getResources().getBoolean(
com.android.internal.R.bool.config_enableLaunchBoostv2);
if(mIsLaunchBoostv2_enabled) {
lBoost_v2_TimeOut = mContext.getResources().getInteger(
com.android.internal.R.integer.lboostv2_timeout_param);
lBoost_v2_ParamVal = mContext.getResources().getIntArray(
com.android.internal.R.array.lboostv2_param_value);
}
}AMS构造方法的只要作用是创建出了4大组件Activity、Service、Broadcast和ContentProvider的管理对象及一些内部对象。
2、理解setSystemProcess()方法
SystemServer中创建了AMS对象后，会调用它的setSystemProcess()方法，如下：
public void setSystemProcess() {
try {
// 将ActivityManagerService加入到ServiceManager
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, true);
// ProcessStats是dump进程信息的服务
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
// MemBinder是dump系统中每个进程的内存使用状况的服务
ServiceManager.addService("meminfo", new MemBinder(this));
//GraphicsBinder是dump系统中每个进程使用图形加速卡状态的服务
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
//DbBinder是dump系统中每个进程的db状况的服务
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this));
}
// PermissionController是检查Binder调用权限的服务
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
//得到framework-res.apk的ApplicationInfo
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
synchronized (this) {//把systemServer本身加入到process的管理中
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);
}
}setSystemProcess()方法主要是向ServiceManager注册了一些服务。注意最后一段代码，它创建了代表SystemServer的ProcessRecord对象，并把它加入到AMS的进程管理体系中。
上面代码中用到了mPidsSelfLocked变量，我们看下这个变量的定义，
/**
* All of the processes we currently have running organized by pid.
* The keys are the pid running the application.
*
* <p>NOTE: This object is protected by its own lock, NOT the global
* activity manager lock!
*/
final SparseArray<ProcessRecord> mPidsSelfLocked = new SparseArray<ProcessRecord>();
mPidsSelfLocked保存有pid组织起来的正在运行的进程，保存的是pid，及pid对应的ProcessRecord。
3、systemReady()方法
SystemServer在启动完所有服务之后，将调用AMS的systemReady()方法。这个方法是Android进入用户交互阶段前最后进行的准备工作。
public void systemReady(final Runnable goingCallback) {
synchronized(this) {
if (mSystemReady) {//调用时的值为false，不会执行下面的语句
// If we're done calling all the receivers, run the next "boot phase" passed in
// by the SystemServer在systemServer中执行下一个启动阶段
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();//调用UserController的updateCurrentProfileIdsLocked()方法。
mRecentTasks.onSystemReadyLocked();//重建带有persistent标记的task
mAppOpsService.systemReady();//AppOps准备工作
mSystemReady = true;//设置mSystemReady变量
}......（1）、装载系统中用户的profile ID
UserController的onSystemReady()中调用updateCurrentProfileIdsLocked()方法。
void onSystemReady() {
updateCurrentProfileIdsLocked();
}Android的许多系统调用都需要检查用户的ID，所以这里调用updateCurrnetProfileIdsLocked()方法来通过UserManagerService读取系统保持的Profile信息，装载系统中已经存在的用户信息。
（2）、重建带有persistent标记的Task
调用RecentTask的onSystemReadyLocked()方法，如下：
void onSystemReadyLocked() {
clear();
mTaskPersister.startPersisting();
}（3）、清理进程
ArrayList<ProcessRecord> procsToKill = null;
synchronized(mPidsSelfLocked) {
for (int i=mPidsSelfLocked.size()-1; i>=0; i--) {
ProcessRecord proc = mPidsSelfLocked.valueAt(i);
if (!isAllowedWhileBooting(proc.info)){//检查进程是否有persistent标记
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;
}（4）、如果处于“工厂测试模式”，启动用于工厂测试的模块
synchronized(this) {
// Make sure we have no pre-ready processes sitting around.
if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) {
// 处于工厂模式，则查找测试程序
ResolveInfo ri = mContext.getPackageManager()
.resolveActivity(new Intent(Intent.ACTION_FACTORY_TEST),
STOCK_PM_FLAGS);
CharSequence errorMsg = null;
if (ri != null) {
ActivityInfo ai = ri.activityInfo;
ApplicationInfo app = ai.applicationInfo;
//判断找到的测试程序是否是系统程序
if ((app.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
//把测试程序的信息设置在下面的变量中，将会启动测试程序
mTopAction = Intent.ACTION_FACTORY_TEST;
mTopData = null;
mTopComponent = new ComponentName(app.packageName,
ai.name);
} else {
errorMsg = mContext.getResources().getText(
com.android.internal.R.string.factorytest_not_system);
}
} else {
errorMsg = mContext.getResources().getText(
com.android.internal.R.string.factorytest_no_action);
}
if (errorMsg != null) {//发送出错的信息
mTopAction = null;
mTopData = null;
mTopComponent = null;
Message msg = Message.obtain();
msg.what = SHOW_FACTORY_ERROR_UI_MSG;
msg.getData().putCharSequence("msg", errorMsg);
mUiHandler.sendMessage(msg);
}
}
}（5）、读取设置信息
retrieveSettings();
DEBUG_APP：需要调试的app的名称。
WAIT_FOR_DEBUGGER：值为1表示启动调试的app时要先等待调试器，否则正常启动。
ALWAYS_FINISH_ACTIVITIES：值为1表示Activity不再需要时，系统会立即清除他们。
DEVELOPMENT_FORCE_RTL：值为1表示要将系统设置为从右到左的模式。
LENIENT_BACKGROUND_CHECK。
DEVELOPMENT_FORCE_RESIZABLE_ACTIVITIES。
之后再从资源文件中读取几个缺省的系统配置信息。
（6）、执行参数的callback
if (goingCallback != null) goingCallback.run();（7）、启动当前用户
final int currentUserId;
......
currentUserId = mUserController.getCurrentUserIdLocked();
......
mSystemServiceManager.startUser(currentUserId);（8）、启动带有标记为FLAG_PERSISTENT的应用和Home应用
synchronized (this) {
// Only start up encryption-aware persistent apps; once user is
// unlocked we'll come back around and start unaware apps
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);
} catch (RemoteException e) {
throw e.rethrowAsRuntimeException();
}
}
startHomeActivityLocked(currentUserId, "systemReady");//启动Home应用
// start the power off alarm by boot mode
boolean isAlarmBoot = SystemProperties.getBoolean("ro.alarm_boot", false);
if (isAlarmBoot) {
sendAlarmBroadcast();
}
try {
if (AppGlobals.getPackageManager().hasSystemUidErrors()) {
Slog.e(TAG, "UIDs on the system are inconsistent, you need to wipe your"
+ " data partition or your device will be unstable.");
mUiHandler.obtainMessage(SHOW_UID_ERROR_UI_MSG).sendToTarget();
}
} catch (RemoteException e) {
}
if (!Build.isBuildConsistent()) {
Slog.e(TAG, "Build fingerprint is not consistent, warning user");
mUiHandler.obtainMessage(SHOW_FINGERPRINT_ERROR_UI_MSG).sendToTarget();
}
long ident = Binder.clearCallingIdentity();
try {
Intent intent = new Intent(Intent.ACTION_USER_STARTED);//发送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, AppOpsManager.OP_NONE,
null, false, false, MY_PID, Process.SYSTEM_UID,
currentUserId);
intent = new Intent(Intent.ACTION_USER_STARTING);//发送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}, AppOpsManager.OP_NONE,
null, true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL);
} catch (Throwable t) {
Slog.wtf(TAG, "Failed sending first user broadcasts", t);
} finally {
Binder.restoreCallingIdentity(ident);
}
mStackSupervisor.resumeFocusedStackTopActivityLocked();
mUserController.sendUserSwitchBroadcastsLocked(-1, currentUserId); private void startPersistentApps(int matchFlags) {
if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) return;
synchronized (this) {
try {//查找系统中带有FLAG_PERSISTENT标记的应用
final List<ApplicationInfo> apps = AppGlobals.getPackageManager()
.getPersistentApplications(STOCK_PM_FLAGS | matchFlags).getList();
for (ApplicationInfo app : apps) {
if (!"android".equals(app.packageName)) {//排除掉包名为“android”的应用，前面已经加过了
addAppLocked(app, false, null /* ABI override */);//启动应用
}
}
} catch (RemoteException ex) {
}
}
}SystemReady()方法到此就分析完了。
从上面的分析中可以看出，如果系统应用希望在Home启动前启动，可以加入"FLAG_PERSISTENT"的标志；接收Intent“ACTION_BOOT_COMPLETED”的应用只能在Home启动后再启动。
下面接着分析Android的Process管理部分。
9325
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
