AMS启动过程分析
AMS启动过程分析
首先ams是在system_server进程
system_server具体实现是
frameworks/base/services/java/com/android/server/SystemServer.java
AMS启动流程图分析
1.SystemServer#main()方法
public static void main(String[] args) {
new SystemServer().run();
}
private void run() {
Looper.prepareMainLooper();//创建主线程Looper
//创建系统context（new ContextImpl）和加载系统资源
createSystemContext();
mSystemServiceManager = new SystemServiceManager(mSystemContext);//创建SystemServiceManger对象用来管理所有的service
// Start services.
startBootstrapServices();//启动引导服务
startCoreServices();//启动核心服务
startOtherServices();//启动其它服务
// Loop forever.
Looper.loop();//loop循环
}
2. SystemServer#startBootstrapServices()方法
private void startBootstrapServices() {
//...
// Activity manager runs the show.
// TODO: Might need to move after migration to WM.
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm);//启动AMS
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
//...
mActivityManagerService.setSystemProcess();//将AMS注册到ServiceManager中
//...
}
public static final class Lifecycle extends SystemService {
private final ActivityManagerService mService;
private static ActivityTaskManagerService sAtm;
public Lifecycle(Context context) {
super(context);
mService = new ActivityManagerService(context, sAtm);//创建AMS实例
}
public static ActivityManagerService startService(
SystemServiceManager ssm, ActivityTaskManagerService atm) {
sAtm = atm;
return ssm.startService(ActivityManagerService.Lifecycle.class).getService();//通过LifeCycle的getService返回AMS对象
}
@Override
public void onStart() {
mService.start();//启动AMS
}
//...
public ActivityManagerService getService() {
return mService;
}
}
3. SystemServiceManager#startService()方法
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
final String name = serviceClass.getName();
//...
//通过反射创建AMS对象，会调到上面ActivityManagerService.Lifecycle构造方法
final T service;
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
//...
startService(service);
return service;
}
// Services that should receive lifecycle events.
private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();
public void startService(@NonNull final SystemService service) {
// Register it.
mServices.add(service);//注册到SystemServiceManager
service.onStart();////启动服务
}
4. ActivityManagerService#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, ActivityTaskManagerService atm) {
mInjector = new Injector();
mContext = systemContext;//获取系统上下文环境
mSystemThread = ActivityThread.currentActivityThread();//获取当前ActivityThread线程
mUiContext = mSystemThread.getSystemUiContext();//赋值mUiContext
mHandlerThread = new ServiceThread(TAG,
THREAD_PRIORITY_FOREGROUND, false /allowIo/);//创建Handler线程，用来处理handler消息
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
mUiHandler = mInjector.getUiHandler(this);//处理ui相关msg的Handler
mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
mProcStartHandlerThread.start();
mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
mConstants = new ActivityManagerConstants(mContext, this, mHandler);
final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
mProcessList.init(this, activeUids);
mLowMemDetector = new LowMemDetector(this);
mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
// Broadcast policy parameters
final BroadcastConstants foreConstants = new BroadcastConstants(
Settings.Global.BROADCAST_FG_CONSTANTS);//初始化前台广播的队列，设置10s超时
foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
final BroadcastConstants backConstants = new BroadcastConstants(
Settings.Global.BROADCAST_BG_CONSTANTS);//初始化后台广播的队列，设置60s超时
backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
final BroadcastConstants offloadConstants = new BroadcastConstants(
Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);//初始化离线广播的队列，设置60s超时
offloadConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
// by default, no "slow" policy in this queue
offloadConstants.SLOW_TIME = Integer.MAX_VALUE;
mEnableOffloadQueue = SystemProperties.getBoolean(
"persist.device_config.activity_manager_native_boot.offload_queue_enabled", false);
mFgBroadcastQueue = new BroadcastQueue(this, mHandler,
"foreground", foreConstants, false);
mBgBroadcastQueue = new BroadcastQueue(this, mHandler,
"background", backConstants, true);
mOffloadBroadcastQueue = new BroadcastQueue(this, mHandler,
"offload", offloadConstants, true);
mBroadcastQueues[0] = mFgBroadcastQueue;
mBroadcastQueues[1] = mBgBroadcastQueue;
mBroadcastQueues[2] = mOffloadBroadcastQueue;
mServices = new ActiveServices(this);//初始化管理Service的ActiveServices对象
mProviderMap = new ProviderMap(this);
mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
final File systemDir = SystemServiceManager.ensureSystemDir();
// TODO: Move creation of battery stats service outside of activity manager service.
mBatteryStatsService = new BatteryStatsService(systemContext, systemDir,
BackgroundThread.get().getHandler());//创建电池状态服务
mBatteryStatsService.getActiveStatistics().readLocked();
mBatteryStatsService.scheduleWriteToDisk();
mOnBattery = DEBUG_POWER ? true
: mBatteryStatsService.getActiveStatistics().getIsOnBattery();
mBatteryStatsService.getActiveStatistics().setCallback(this);
mOomAdjProfiler.batteryPowerChanged(mOnBattery);
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
mUserController = new UserController(this);
mPendingIntentController = new PendingIntentController(
mHandlerThread.getLooper(), mUserController);
if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
mUseFifoUiScheduling = true;
}
mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
mActivityTaskManager = atm;
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
DisplayThread.get().getLooper());
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
mProcessCpuThread = new Thread("CpuTracker") {//启动一个线程跟进CPU当前状态信息
@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) {
Slog.e(TAG, "Unexpected exception collecting process stats", e);
}
}
}
};
mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);
Watchdog.getInstance().addMonitor(this);//看门狗，监听进程
Watchdog.getInstance().addThread(mHandler);
// bind background threads to little cores
// this is expected to fail inside of framework tests because apps can't touch cpusets directly
// make sure we've already adjusted system_server's internal view of itself first
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
try {
Process.setThreadGroupAndCpuset(BackgroundThread.get().getThreadId(),
Process.THREAD_GROUP_SYSTEM);
Process.setThreadGroupAndCpuset(
mOomAdjuster.mAppCompact.mCompactionThread.getThreadId(),
Process.THREAD_GROUP_SYSTEM);
} catch (Exception e) {
Slog.w(TAG, "Setting background thread cpuset failed");
}
}
5. ActivityManagerService#start()方法
private void start() {
removeAllProcessGroups();//移除所有的进程组
mProcessCpuThread.start();//启动Cpu进程
mBatteryStatsService.publish();//启动电池状态服务
mAppOpsService.publish(mContext);
LocalServices.addService(ActivityManagerInternal.class, new LocalService());//创建本地服务并注册，将创建的本地服务放入本地服务集合完成注册
mActivityTaskManager.onActivityManagerInternalAdded();
mUgmInternal.onActivityManagerInternalAdded();
mPendingIntentController.onActivityManagerInternalAdded();
// Wait for the synchronized block started in mProcessCpuThread,
// so that any other access to mProcessCpuTracker from main thread
// will be blocked during mProcessCpuTracker initialization.
try {
mProcessCpuInitLatch.await();//等待mProcessCpuThread完成初始化后，释放锁
} catch (InterruptedException e) {
Slog.wtf(TAG, "Interrupted wait during start", e);
Thread.currentThread().interrupt();
throw new IllegalStateException("Interrupted wait during start");
}
}
6. ActivityManagerService#setSystemProcess()方法
public void setSystemProcess() {
try {
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);//将AMS注册到ServiceManager中
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);//注册进程状态服务
ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_HIGH);//注册内存Binder
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));//注册图像信息Binder
ServiceManager.addService("dbinfo", new DbBinder(this));//注册数据库Binder
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this),
/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);//注册监控CPU使用状态Binder
}
ServiceManager.addService("permission", new PermissionController(this));//注册权限控制Binder
ServiceManager.addService("processinfo", new ProcessInfoService(this));//注册进程服务Binder
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);//查询并处理ApplicationInfo
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());//将Application信息配置到ActivityThread中
synchronized (this) {
//创建并处理ProcessRecord
ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
false,
0,
new HostingRecord("system"));
app.setPersistent(true);
app.pid = MY_PID;
app.getWindowProcessController().setPid(MY_PID);
app.maxAdj = ProcessList.SYSTEM_ADJ;
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
mPidsSelfLocked.put(app);
mProcessList.updateLruProcessLocked(app, false, null);
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
}
} catch (PackageManager.NameNotFoundException e) {
throw new RuntimeException(
"Unable to find android system package", e);
}
// Start watching app ops after we and the package manager are up and running.
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);
}
}
}
});
}
7. SystemServer#startOtherServices()方法
private void startOtherServices() {
//...
//安装ContentProvider
mActivityManagerService.installSystemProviders();
//...
//AMS与WMS关联
mActivityManagerService.setWindowManager(wm);
//...
//所有的服务已经准备就绪
mActivityManagerService.systemReady(() -> {
//启动系统UI
startSystemUi(context, windowManagerF);
//...
//执行一系列服务的systemReady
networkStatsF.systemReady();
//...
}
8. ActivityManagerService#installSystemProviders()方法
public final void installSystemProviders() {
List<ProviderInfo> providers;
synchronized (this) {
ProcessRecord app = mProcessList.mProcessNames.get("system", SYSTEM_UID);//找到名为"system"的进程，就是setSystemProcess中创建的ProcessRecord对象
providers = generateApplicationProvidersLocked(app);
if (providers != null) {
for (int i=providers.size()-1; i>=0; i--) {
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);//移除非系统provider
}
}
}
}
if (providers != null) {
mSystemThread.installSystemProviders(providers);//安装所有的系统provider
}
synchronized (this) {
mSystemProvidersInstalled = true;
}
mConstants.start(mContext.getContentResolver());
mCoreSettingsObserver = new CoreSettingsObserver(this);//创建核心Settings Observer，用于监听Settings的改变
mActivityTaskManager.installSystemProviders();
mDevelopmentSettingsObserver = new DevelopmentSettingsObserver();//开发者权限
SettingsToPropertiesMapper.start(mContext.getContentResolver());
mOomAdjuster.initSettings();
// Now that the settings provider is published we can consider sending
// in a rescue party.
RescueParty.onSettingsProviderPublished(mContext);
//mUsageStatsService.monitorPackages();
}
9. ActivityManagerService#systemReady()方法
public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
//...
mAtmInternal.startHomeOnAllDisplays(currentUserId, "systemReady");//启动Launcher界面
//...
}
总结：
第一: system_server进程具体实现是SystemServer.java
main()方法首先创建SystemServer对象并调用其run()方法
第二: SystemServer将系统服务分成了
| 服务 | 类型 |
|---|---|
| BootstrapServices | 引导服务 |
| CoreServices | 核心服务 |
| OtherServices | 其他服务 |
其中AMS属于引导服务
这些服务在run()方法中启动
第三：通过 SystemServiceManager 管理所有服务
具体怎么管理AMS的，这里设计非常巧妙。
首先，创建一个抽象类，SystemServer
然后在ActivityMangerService中通过内部类LifeCycle实现SystemService抽象类
其次是SystemServiceManager通过反射创建LifeCycle对象，怎么创建呢，LifeCycle中传入SystemServiceManager的对象，然后就可以调用SystemServiceManager的方法，显然SystemServiceManager这个对象是SystemServer类run()方法中创建的
LifeCycle对象创建时去创建ActivityMangerService
这样SystemServiceManger就拿到了LifeCycle和ActivityMangerService对象，就可以对其进行管理
这一套流程非常的通用，所以如果app应用开发时需要启动很多的服务，可以搞一个服务管理类，管理这些服务，这点值得学习。
浙公网安备 33010602011771号