ActivityManagerService太复杂了，尤其是Android12的AMS没有相关文章，那我们就从它的启动开始分析源码，梳理ActivityManagerService(AMS)、ActivityTaskManagerService(ATMS)、WindowManagerService等相关类的关系。
AMS和ATMS的区别：
1. AMS负责管理四大组件的生命周期以及应用程序进程调度，其中activity相关实际上由ATMS负责。它有自己的IActivityManager.aidl、ActivityManagerInternal，属于server/am目录下；
2. ATMS负责管理activities和activity相关容器（task，stacks，display），也有自己的IActivityTaskManager.aidl、ActivityManagerInternal，在server/wm目录下。
目录
1.1 SystemServer启动ActivityTaskManagerService和 ActivityManagerService
1.2 ActivityTaskMangerService的启动过程
1.2.1 ActivityTaskMangerService.Lifecycle
1.2.2 ActivityTaskMangerService构造函数
1.2.3 ActivityTaskManagerService.start()
1.2.4 ActivityTaskManagerInternal类
1.3 ActivityManagerService的启动过程
1.3.1 ActivityMangerService.Lifecycle
1.3.2 ActivityMangerService构造方法
1.3.3 ActivityManagerService.start()
1.3.4 ActivityManagerInternal类
1.4 AMS设置SystemServiceManager和Installer
1 AMS和ATMS的启动
ActivityManagerService是在SystemServer中的startBootstrapServices()启动的，在启动过程涉及到的方法如下图所示：
1.1 SystemServer启动ActivityTaskManagerService和 ActivityManagerService
// /frameworks/base/services/java/com/android/server/SystemServer.java
private void startBootstrapServices(TimingsTraceAndSlog t) {
t.traceBegin("StartActivityManager");
//2. 先启动ActivityTaskManagerService，然后获取其实例
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
//3. 把atm作为参数启动ActivityManagerService，该方法会返回其实例
mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
//4. 把ssm和installer赋值给ActivityManagerService
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
//5. 利用atm，获取WindowManagerGlobalLock
mWindowManagerGlobalLock = atm.getGlobalLock();
t.traceEnd();
...
//6. AMS.initPowerManager
t.traceBegin("InitPowerManagement");
mActivityManagerService.initPowerManagement();
t.traceEnd();
}1.2 ActivityTaskMangerService的启动过程
注意：ActivityTaskManagerService是在server/wm目录下，而ActivityManagerService是在server/am目录下。ActivityTaskManagerService是Android10加入的，主要负责管理activities和activity相关容器（task，stacks，display），所以它才在wm目录下。
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();关于SystemServiceManager.startService()，请参考我的博文Framework层SystemServiceManager类的详解_雅雅姐的博客-CSDN博客
的详细介绍，它返回ActivityTaskManagerService.Lifecycle的实例，同时会调用该实例的onStart()方法，然后调用该实例的getService()获取ActivityTaskManagerService实例。
1.2.1 ActivityTaskMangerService.Lifecycle
// /frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
//静态内部类，继承SystemService，说明它是一个系统service
public static final class Lifecycle extends SystemService {
private final ActivityTaskManagerService mService;
public Lifecycle(Context context) {
// 这个context是SystemServiceManager传递过来的系统上下文，
// 即ContextImpl.getSystemContext()返回的实例
super(context);
mService = new ActivityTaskManagerService(context);
}
@Override
public void onStart() {
//有SystemService调用ServiceManager.addService()加入到servicemanager进程中管理
publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
//调用其start()
mService.start();
}
@Override
public void onUserUnlocked(@NonNull TargetUser user) {
synchronized (mService.getGlobalLock()) {
mService.mTaskSupervisor.onUserUnlocked(user.getUserIdentifier());
}
}
@Override
public void onUserStopped(@NonNull TargetUser user) {
synchronized (mService.getGlobalLock()) {
mService.mTaskSupervisor.mLaunchParamsPersister
.onCleanupUser(user.getUserIdentifier());
}
}
// 返回的是new的ActivityTaskManagerService实例，SystemSever中使用
// SystemServiceManager.startService()后调用的getService()就是调用该方法
public ActivityTaskManagerService getService() {
return mService;
}
}
}1.2.2 ActivityTaskMangerService构造函数
// /frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
public ActivityTaskManagerService(Context context) {
mContext = context;
mFactoryTest = FactoryTest.getMode();
// 初始化ActivityThread
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
mLifecycleManager = new ClientLifecycleManager();
mVisibleActivityProcessTracker = new VisibleActivityProcessTracker(this);
mInternal = new LocalService();
GL_ES_VERSION = SystemProperties.getInt("ro.opengles.version", GL_ES_VERSION_UNDEFINED);
mWindowOrganizerController = new WindowOrganizerController(this);
mTaskOrganizerController = mWindowOrganizerController.mTaskOrganizerController;
}
}注意：在ActivityTaskManagerService的构造方法中初始化了ActivityThread实例，它的使用会在之后慢慢展开，此处给出ActivityThread的官方解释：它管理应用程序进程中主线程的执行、调度和执行activities、broadcasts和其他ActivityManagerService请求的其他操作。
1.2.3 ActivityTaskManagerService.start()
该方法在启动ActivityTaskManagerService时会被调用，在Lifecycle.onStart()中调用了该start()。
// /frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
private void start() {
LocalServices.addService(ActivityTaskManagerInternal.class, mInternal);
}
}
LocalService会在其他博客中详细介绍。
1.2.4 ActivityTaskManagerInternal类
Activity Task manager的本地系统服务接口，只能在system server进程中使用。
// /frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerInternal.java
public abstract class ActivityTaskManagerInternal {
public interface ScreenObserver {
void onAwakeStateChanged(boolean isAwake);
void onKeyguardStateChanged(boolean isShowing);
}
public abstract void registerScreenObserver(ScreenObserver observer);
public abstract ComponentName getHomeActivityForUser(int userId);
public abstract int startActivitiesAsPackage(String packageName,
int userId, Intent[] intents, Bundle bOptions);
public abstract int startActivityAsUser(IApplicationThread caller, String callingPackage,
Intent intent, @Nullable Bundle options, int userId);
public abstract boolean isSleeping();
public abstract boolean isShuttingDown();
public abstract boolean shuttingDown(boolean booted, int timeout);
public abstract void enableScreenAfterBoot(boolean booted);
public final class ActivityTokens {
private final @NonNull IBinder mActivityToken;
private final @NonNull IBinder mAssistToken;
private final @NonNull IApplicationThread mAppThread;
...
}
public abstract Intent getHomeIntent();
public abstract boolean startHomeActivity(int userId, String reason);
...
}1.3 ActivityManagerService的启动过程
SystemServer把SystemServiceManager和ActivityTaskManagerService的实例对象作为参数来启动ActivityManagerService。
1.3.1 ActivityMangerService.Lifecycle
由ssm.startService(ActivityManagerService.Lifecycle.class).getService()启动获取的ActivityManagerService和上述获取ActivityTaskManagerService一样。
// /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
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;
//利用传入的ssm实例启动Activity manager服务，把该服务注册到systemmanager中，
//因为startService()返回的是ActivityManagerService实例，
//所以调用自身的onStart()，并调用自身的gerService()。
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;
}
}
}1.3.2 ActivityMangerService构造方法
// /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
mInjector = new Injector(systemContext);
//系统上下文，由systemserver进程创建的，ContextImpl.getSystemContext()得到的
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
//初始化ActivityThread, atm也初始化该实例
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
//mHandler和mUiHandler初始化
mHandlerThread = new ServiceThread(TAG, THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
mUiHandler = mInjector.getUiHandler(this);
//mProcStartHandler初始化
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 */);
mPlatformCompat = (PlatformCompat) ServiceManager.getService(
Context.PLATFORM_COMPAT_SERVICE);
mProcessList = mInjector.getProcessList(this);
mProcessList.init(this, activeUids, mPlatformCompat);
mAppProfiler = new AppProfiler(this, BackgroundThread.getHandler().getLooper(),
new LowMemDetector(this));
mPhantomProcessList = new PhantomProcessList(this);
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);
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);
mCpHelper = new ContentProviderHelper(this, true);
mPackageWatchdog = PackageWatchdog.getInstance(mUiContext);
mAppErrors = new AppErrors(mUiContext, this, mPackageWatchdog);
mUidObserverController = new UidObserverController(mUiHandler);
final File systemDir = SystemServiceManager.ensureSystemDir();
// TODO: Move creation of battery stats service outside of activity manager service.
//初始化BatteryStatsService
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, mConstants);
mUseFifoUiScheduling = SystemProperties.getInt("sys.use_fifo_ui", 0) != 0;
mTrackingAssociations = "1".equals(SystemProperties.get("debug.track-associations"));
mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
//持有atm引用,并调用其initialize()
mActivityTaskManager = atm;
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
DisplayThread.get().getLooper());
//获取其local service对象
mAtmInternal = LocalServices.getService(ActivityTaskManagerInternal.class);
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.mCachedAppOptimizer.mCachedAppOptimizerThread.getThreadId(),
Process.THREAD_GROUP_SYSTEM);
} catch (Exception e) {
Slog.w(TAG, "Setting background thread cpuset failed");
}
mInternal = new LocalService();
mPendingStartActivityUids = new PendingStartActivityUids(mContext);
mTraceErrorLogger = new TraceErrorLogger();
}
}1.3.3 ActivityManagerService.start()
该方法主要工作有：
- 添加BatteryStats、AppOpsServce和各自Internal service到ServiceManager和LocalServices中；
- 添加ActivityManagerInternal service到LocalServices中，并通知其他service来获取该internal service的引用。
// /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
private void start() {
removeAllProcessGroups(); //这是个native 方法
//ServiceManager中添加battarystats这个服务
mBatteryStatsService.publish();
//ServiceManager中添加appops这个service
mAppOpsService.publish();
Slog.d("AppOps", "AppOpsService published");
// 添加ActivityManagerInternal这个internal service，
// 之后会通知以下三个service获取该internal service的引用
LocalServices.addService(ActivityManagerInternal.class, mInternal);
LocalManagerRegistry.addManager(ActivityManagerLocal.class,
(ActivityManagerLocal) mInternal);
mActivityTaskManager.onActivityManagerInternalAdded();
mPendingIntentController.onActivityManagerInternalAdded();
mAppProfiler.onActivityManagerInternalAdded();
}
}1.3.4 ActivityManagerInternal类
它是一个抽象类，同ActivityTaskManagerInternal类类似，它是Activity Manager的本地系统服务接口，只能在system server内部使用。
// /frameworks/base/core/java/android/app/ActivityManagerInternal.java
public abstract class ActivityManagerInternal {
public abstract void killForegroundAppsForUser(@UserIdInt int userId);
public abstract int getUidProcessState(int uid);
public abstract boolean isSystemReady();
public abstract boolean isRuntimeRestarted();
public abstract List<ProcessMemoryState> getMemoryStateForProcesses();
/** Kill the process immediately. */
public abstract void killProcess(String processName, int uid, String reason);
public abstract boolean hasRunningActivity(int uid, @Nullable String packageName);
public abstract void updateOomAdj();
public abstract void updateCpuStats();
public abstract void updateBatteryStats(
ComponentName activity, int uid, @UserIdInt int userId, boolean resumed);
public abstract void noteWakeupAlarm(PendingIntent ps, WorkSource workSource, int sourceUid,
String sourcePkg, String tag);
...
}1.4 AMS设置SystemServiceManager和Installer
// /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
public void setSystemServiceManager(SystemServiceManager mgr) {
mSystemServiceManager = mgr;
}
public void setInstaller(Installer installer) {
mInstaller = installer;
}
}1.5 获取ATMS的全局Lock。
// /frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
final WindowManagerGlobalLock mGlobalLock = new WindowManagerGlobalLock();
public WindowManagerGlobalLock getGlobalLock() {
return mGlobalLock;
}
}
// /frameworks/base/services/core/java/com/android/server/wm/WindowManagerGlobalLock.java
public class WindowManagerGlobalLock {
}1.6 AMS.initPowerManagement()
// /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
public void initPowerManagement() {
mActivityTaskManager.onInitPowerManagement();
mBatteryStatsService.initPowerManagement();
// AMS持有PowerMManagerInternal service引用
mLocalPowerManager = LocalServices.getService(PowerManagerInternal.class);
}
}ATMS同AMS一样，也持有PowerManagerInternal service引用，ATMS.onInitPowerManagement()如下：
// /frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
public void onInitPowerManagement() {
synchronized (mGlobalLock) {
mTaskSupervisor.initPowerManagement();
final PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
//持有PowerManagerInternal service引用
mPowerManagerInternal = LocalServices.getService(PowerManagerInternal.class);
mVoiceWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "*voice*");
mVoiceWakeLock.setReferenceCounted(false);
}
}
}// /frameworks/base/services/core/java/com/android/server/am/BatteryStatsService.java
public final class BatteryStatsService extends IBatteryStats.Stub
implements PowerManagerInternal.LowPowerModeListener,
BatteryStatsImpl.PlatformIdleStateCallback,
BatteryStatsImpl.MeasuredEnergyRetriever,
Watchdog.Monitor {
public void initPowerManagement() {
//持有PowerManagerInternal service引用,并注册低电量模式监听
final PowerManagerInternal powerMgr = LocalServices.getService(PowerManagerInternal.class);
powerMgr.registerLowPowerModeObserver(this);
synchronized (mStats) {
mStats.notePowerSaveModeLocked(
powerMgr.getLowPowerState(ServiceType.BATTERY_STATS).batterySaverEnabled,
SystemClock.elapsedRealtime(), SystemClock.uptimeMillis(), true);
}
(new WakeupReasonThread()).start();
} 1.7 AMS.setSystemProcess()
该方法主要业务：
- 把AMS作为name = activity添加到systemserver进程中管理；
- 注册procstats服务（进程状态），meminfo服务（内存信息），gfxinfo服务（图像信息），dbinfo服务（数据库信息），cpuinfo服务（cup信息），permission服务（权限控制信息），processinfo服务（进程信息），cacheinfo服务（cache信息）注册到systemserver进程中进行管理；
- 获取package=“android”的ApplicationInfo，为ActivityThread安装相关system application信息；
-
为systemserver 主进程开辟一个ProcessRecord来维护进程的相关信息。
// /frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
public void setSystemProcess() {
try {
//1.把AMS作为name=activity注册到systemserver进程中管理
ServiceManager.addService(Context.ACTIVITY_SERVICE, this, /* allowIsolated= */ true,
DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PRIORITY_NORMAL | DUMP_FLAG_PROTO);
//2.注册进程状态服务
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));
//注册cupinfo服务到systemserver进程中，CUP信息
mAppProfiler.setCpuInfoService();
//注册权限服务、进程信息服务、缓存信息服务
ServiceManager.addService("permission", new PermissionController(this));
ServiceManager.addService("processinfo", new ProcessInfoService(this));
ServiceManager.addService("cacheinfo", new CacheBinder(this));
//3.获取package=“android”的ApplicationInfo，
ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
"android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
//为ActivityThread安装相关system application信息
mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());
synchronized (this) {
//4.为systemserver 主进程开辟一个ProcessRecord来维护进程的相关信息
ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
false,
0,
new HostingRecord("system"));
app.setPersistent(true);
app.setPid(MY_PID); //PID是进程ID，AMS在systemserver进程中
app.mState.setMaxAdj(ProcessList.SYSTEM_ADJ);
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
addPidLocked(app);
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, String attributionTag,
boolean active, @AttributionFlags int attributionFlags,
int attributionChainId) {
cameraActiveChanged(uid, active);
}
});
}
}补充个知识点：
获取package=“android”的ApplicationInfo，为ActivityThread安装相关system application信息；在后边的章节中介绍了AMS的这个mSystemThread，这个实际上是systemserver进程的主线程，所以此处是在systemserver进程中安装了framework-res.apk，（之后还会系统还会安装SettingsProvider.apk）。
此处安装的是framework-res.apk。因为只有该apk的AndroidManifest.xml中package=“android”且是SYSTEM_UID，如下图：
它的代码地址和Android.bp，参考地址：Android.bp - OpenGrok cross reference for /frameworks/base/core/res/Android.bp
以上就是均是在SystemServer.startBootstrapServices()方法中启动ActivityTaskManagerService和ActivityManagerService的过程，以及设置AMS相关配置的调用。
2 总结
在SystemServer.starBootstrapServices()中启动AMS和ATMS所做的工作主要有：
(1) 使用SystemServiceManager启动AMS和ATMS，并获取两者服务的实例。
(2) 在两者启动过程中会在LocalServices中分别注册AMS和ATMS的本地服务ActivityManagerInternal和ActivityTaskManagerInternal。
(3) AMS设置SystemServiceManager和Installer。
(4) 获取ATMS的全局Lock：WindowManagerGlobalLock。
(5) AMS.initPowerManagement()。
(6) AMS.setSystemProcess()把AMS作为name=activity和其他Service注册到ServiceManager中等
3805
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
