3 ActivityManagerService(一)App启动
2023-08-12 本文已影响0人
Tsm_2020
所有代码都是Android 11
ActivityManagerService 简称 AMS ,那么他在系统调用过程中是干什么的,他到底管理了什么,他在系统调度又充当了什么角色,我们接下来就开始具体分析一下,由于ActivityManagerService 是一个非常功能非常复杂且代码特别庞大的一个类,想要了解ActivityManagerService 就需要将他里面非常多的功能拆分来讲解一下,本篇博客我会先将 ActivityManagerService 的启动流程说一下,了解一下 ActivityManagerService 在启动过程中都持有了哪些比较重要的对象,后续在针对不同的对象做具体的分析
ActivityManagerService 简称 AMS
ActivityManagerService.Lifecycle.class 代理 AMS ,并创建ams
我的关于 FrameWork 的第一篇和第三篇都有介绍 SystemServer 通过 SystemServiceMananger 启动各个服务的流程,同时我在前面的博客里面也多次提到,AMS的启动流程与其他 SystemService 有些不同,那就不是他不会通过代理类将自身添加到ServiceManager , 那么他是如何被添加到ServiceManager 当中的呢,
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm); // 启动AMS
通过 ActivityManagerService.Lifecycle 这个代理类解决java 单一继承的问题,来启动 AMS , 并且将 AcivityTaskManagerService 作为参数传入,AcivityTaskManagerService 是在android 10 版本中引入的一个功能,至于为什么要引入他,可能google 觉得 AMS 功能太复杂了,需要将部分功能继续封装一下吧
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);
}
public static ActivityManagerService startService(
SystemServiceManager ssm, ActivityTaskManagerService atm) {
sAtm = atm;
return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
}
@Override
public void onStart() {
mService.start();
}
@Override
public void onBootPhase(int phase) {
mService.mBootPhase = phase;
if (phase == PHASE_SYSTEM_SERVICES_READY) {
mService.mBatteryStatsService.systemServicesReady();
mService.mServices.systemServicesReady();
} else if (phase == PHASE_ACTIVITY_MANAGER_READY) {
mService.startBroadcastObservers();
} else if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) {
mService.mPackageWatchdog.onPackagesReady();
}
}
@Override
public void onUserStopped(@NonNull TargetUser user) {
mService.mBatteryStatsService.onCleanupUser(user.getUserIdentifier());
}
public ActivityManagerService getService() {
return mService;
}
}
代理类创建 AMS ,并且将 ATMS 作为参数给到 AMS ,我在前面说过 ams 并不是通过代理类将自身添加到 ServiceManager 当中的,那么他是如何添加进去的,带着这个疑问,接下来看一下他的构造方法
AMS 初始化方法 及内容分析
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
看起来像网络管理
mInjector = new Injector(systemContext);
系统上下文，是在SystemServer进程fork出来后通过createSystemContext()创建的，即与SystemServer进程是一样的
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
mSystemThread -->系统进程的主线程 sCurrentActivityThread，这里是systemMain()中创建的ActivityThread对象。即也与SystemServer一样的。
mSystemThread = ActivityThread.currentActivityThread();
MUiContext-->是通过SystemContext 创建的一个ContextImpl,并且是绑定过 Resource ,package 信息 以及其他信息
mUiContext = mSystemThread.getSystemUiContext();
Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
一个HandlerThread 具有looper
mHandlerThread = new ServiceThread(TAG,THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
处理AMS消息的handle ,looper 没使用SystemServer 的,使用的是上面创建的那个looper
mHandler = new MainHandler(mHandlerThread.getLooper());
UiHandler对应于Android中的Ui线程 , 使用的是SystemServer 中的主线程中的looper
mUiHandler = mInjector.getUiHandler(this);
又一个HandlerThread 具有looper
mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
mProcStartHandlerThread.start();
绑定了上面looper的Handler
mProcStartHandler = new Handler(mProcStartHandlerThread.getLooper());
厂商定制修改这里
mConstants = new ActivityManagerConstants(mContext, this, mHandler);
管理Uid 的
final ActiveUids activeUids = new ActiveUids(this, true /* postChangesToAtm */);
持有了 platformService
mPlatformCompat = (PlatformCompat) ServiceManager.getService(Context.PLATFORM_COMPAT_SERVICE);
字面意思就是获取进程列表
mProcessList = mInjector.getProcessList(this);
mProcessList.init(this, activeUids, mPlatformCompat);
启动一个线程 while(true) 查看内存情况, 也存在一个wait 机制,方法是waitForPressure ,不知道这个机制是什么样的,但是确保不回一直遍历
mLowMemDetector = new LowMemDetector(this);
这里面又创建了一个handlerThread,用来处理消息,这个类是用来减少后台内存的
mOomAdjuster = new OomAdjuster(this, mProcessList, activeUids);
// Broadcast policy parameters
final BroadcastConstants foreConstants = new BroadcastConstants(
Settings.Global.BROADCAST_FG_CONSTANTS);
foreConstants.TIMEOUT = BROADCAST_FG_TIMEOUT;
final BroadcastConstants backConstants = new BroadcastConstants(
Settings.Global.BROADCAST_BG_CONSTANTS);
backConstants.TIMEOUT = BROADCAST_BG_TIMEOUT;
final BroadcastConstants offloadConstants = new BroadcastConstants(
Settings.Global.BROADCAST_OFFLOAD_CONSTANTS);
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);
创建几种广播相关对象，前台广播、后台广播、offload广播队列。
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;
创建ActiveServices对象，管理 ServiceRecord
mServices = new ActiveServices(this);
创建ProviderMap对象，管理ContentProviderRecord
mProviderMap = new ProviderMap(this);
mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
final File systemDir = SystemServiceManager.ensureSystemDir();
创建电池统计服务，并输出到制定目录
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);
adb shell dumpsys procstats 查看应用进程信息
mProcessStats = new ProcessStatsService(this, new File(systemDir, "procstats"));
//appops是在现有权限机制上新增的一套权限管理机制，主要针对一些高危的非必须系统应用的权限，比如在其他应用上显示悬浮窗。
mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);
mUgmInternal = LocalServices.getService(UriGrantsManagerInternal.class);
mUserController = new UserController(this);
mPendingIntentController = new PendingIntentController(
mHandlerThread.getLooper(), mUserController, mConstants);
if (SystemProperties.getInt("sys.use_fifo_ui", 0) != 0) {
mUseFifoUiScheduling = true;
}
mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
//Intent防火墙，Google定义了一组规则，来过滤intent，如果触发了，则intent会被系统丢弃，
//且不会告知发送者
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
得到ActivityTaskManagerService的对象，调用ATM.initialize
mActivityTaskManager = atm;
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
DisplayThread.get().getLooper());
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
启动一个线程专门跟进cpu当前状态信息，ams对当前cpu状态了如指掌，可以更加高效的安排其他工作
mProcessCpuThread = new Thread("CpuTracker") {
@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的监控，监听进程，这个类每分钟调用一次监视器，如果进程没有任何返回就杀掉
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.mCachedAppOptimizer.mCachedAppOptimizerThread.getThreadId(),
Process.THREAD_GROUP_SYSTEM);
} catch (Exception e) {
Slog.w(TAG, "Setting background thread cpuset failed");
}
// ActivityManagerInternal类的实现类
mInternal = new LocalService();
mPendingStartActivityUids = new PendingStartActivityUids(mContext);
}
翻阅了很多资料,将所有能注释的地方我都注释了一下,其中非常有研究价值的是 关于保活-->updateOomAdjLocked 减少后台内存消耗-->OomAdjuster 与电池服务
在代理类的创建过程中会执行他的start 方法
private void start() {
removeAllProcessGroups();
开启cpu监控
mProcessCpuThread.start();
将电量服务添加到ServiceManager中
mBatteryStatsService.publish();
浮窗加强管理添加到ServiceManager中
mAppOpsService.publish();
Slog.d("AppOps", "AppOpsService published");
LocalServices.addService(ActivityManagerInternal.class, mInternal);
mActivityTaskManager.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();
} catch (InterruptedException e) {
Slog.wtf(TAG, "Interrupted wait during start", e);
Thread.currentThread().interrupt();
throw new IllegalStateException("Interrupted wait during start");
}
}
他的初始化和start方法就看完了, 从上面来看, AMS 可以 查看内存情况 耗电情况 cpu 情况 并且管理者四大组件 安全策略 网络 等各个服务的情况,还是非常有必要好好看一下的,
在SystemServer 初始化AMS 后,后续还调用了
mActivityManagerService.initPowerManagement();
初始化了电量服务 之后又调用了
mActivityManagerService.setSystemProcess();
public void setSystemProcess() {
try {
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
ServiceManager.addService(ProcessStats.SERVICE_NAME, mProcessStats);
ServiceManager.addService("meminfo", new MemBinder(this), /* allowIsolated= */ false,
DUMP_FLAG_PRIORITY_HIGH);
ServiceManager.addService("gfxinfo", new GraphicsBinder(this));
ServiceManager.addService("dbinfo", new DbBinder(this));
if (MONITOR_CPU_USAGE) {
ServiceManager.addService("cpuinfo", new CpuBinder(this),
/* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
}
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
ServiceManager.addService("cacheinfo", new CacheBinder(this));
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
synchronized (this) {
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);
addPidLocked(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 (getAppOpsManager().checkOpNoThrow(op, uid, packageName)
!= AppOpsManager.MODE_ALLOWED) {
runInBackgroundDisabled(uid);
}
}
}
});
final int[] cameraOp = {AppOpsManager.OP_CAMERA};
mAppOpsService.startWatchingActive(cameraOp, new IAppOpsActiveCallback.Stub() {
@Override
public void opActiveChanged(int op, int uid, String packageName, boolean active) {
cameraActiveChanged(uid, active);
}
});
}
在这里将他所持有的服务添加到 ServiceManager当中,这也解决了我们在看代码过程中没有发现 AMS 将自己添加到ServiceManager当中的这么一个疑问
