머리말
WindowManagerService 서비스와 마찬가지로 ActivityManagerService도 Android 시스템에서 매우 중요한 서비스입니다. 보통 쓰기의 편의를 위해 ActivityManagerService를 AMS로 줄여서 사용합니다. AMS와 관련된 기능을 구체적으로 설명하기 전에 이 서비스를 더 잘 이해하기 위해 ActivityManagerService의 시작 프로세스를 정리해야 합니다.
1. SystemServer가 ActivityManagerService 서비스를 시작합니다.
1. 시스템 시작 후 JVM 가상 머신이 시작됩니다.SystemServer는 가상 머신의 첫 번째 프로세스로 init 프로세스의 포크에 의해 생성됩니다. 주로 프레임워크 계층에서 서비스를 시작하는 데 사용됩니다. SystemServer 프로세스에는 main() 메서드가 있으며 주요 메서드는 다음과 같습니다.
frameworks/base/service/java/com/android/server/SystemServer.java
public final class SystemServer {
public static void main(String[] args) {
new SystemServer().run();
}
}
2. run() 메서드는 main 메서드에서 시작되고 startBootstrapServices() 메서드는 run 메서드에서 호출됩니다.
public final class SystemServer {
private void run() {
...代码省略...
try {
t.traceBegin("StartServices");
startBootstrapServices(t);//引导服务
startCoreServices(t);//核心服务
startOtherServices(t);//其他服务
} catch (Throwable ex) {
Slog.e("System", "******************************************");
Slog.e("System", "************ Failure starting system services", ex);
throw ex;
} finally {
t.traceEnd(); // StartServices
}
...代码省略...
}
}
3. startBootstrapServices 메서드 및 ActivityManagerService 서비스 시작과 관련된 코드는 다음과 같습니다.
public final class SystemServer {
private SystemServiceManager mSystemServiceManager;
private ActivityManagerService mActivityManagerService;
private WindowManagerGlobalLock mWindowManagerGlobalLock;
private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
...代码省略...
// Activity manager runs the show.
t.traceBegin("StartActivityManager");
//SystemServiceManager启动ActivityTaskManagerService服务
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
//调用ActivityManagerService.Lifecycle的静态方法startService启动ActivityManagerService服务
mActivityManagerService = ActivityManagerService.Lifecycle.startService(
mSystemServiceManager, atm);
//ActivityManagerService持有SystemServiceManager的引用
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
mWindowManagerGlobalLock = atm.getGlobalLock();
t.traceEnd();
...代码省略...
}
}
startBootstrapServices 메소드는 먼저 SystemServiceManager의 startService 메소드를 호출하여 ActivityTaskManagerService 서비스를 시작하는데, 일반적으로 이 서비스를 줄여서 ATMS라고 하고 ActivityManagerService.Lifecycle의 startService 메소드를 호출하여 AMS를 시작하고 새로 생성된 ATMS를 매개변수로 전달합니다.
둘째, SystemServiceManager는 ActivityTaskManagerService 서비스를 시작합니다.
1. ATMS 서비스의 시작은 SystemServiceManager의 startService 메소드와 밀접한 관련이 있으므로 여기서는 먼저 SystemServiceManager의 startService 메소드에 대해 알아보겠습니다.
frameworks/base/services/core/java/com/android/server/SystemServiceManager.java
public final class SystemServiceManager implements Dumpable {
/**
* 创建一个系统服务，该服务必须是com.android.server.SystemService的子类
*
* @param serviceClass 一个实现了SystemService接口的Java类
* @return 返回一个服务实例对象
*/
public <T extends SystemService> T startService(Class<T> serviceClass) {
try {
final String name = serviceClass.getName();
Slog.i(TAG, "Starting " + name);
Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
// Create the service.
if (!SystemService.class.isAssignableFrom(serviceClass)) {
throw new RuntimeException("Failed to create " + name
+ ": service must extend " + SystemService.class.getName());
}
final T service;
try {
//获取参数为Context的构造方法，通过反射创建service对象
Constructor<T> constructor = serviceClass.getConstructor(Context.class);
service = constructor.newInstance(mContext);
} catch (InstantiationException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service could not be instantiated", ex);
} catch (IllegalAccessException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service must have a public constructor with a Context argument", ex);
} catch (NoSuchMethodException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service must have a public constructor with a Context argument", ex);
} catch (InvocationTargetException ex) {
throw new RuntimeException("Failed to create service " + name
+ ": service constructor threw an exception", ex);
}
//继续调用startService方法
startService(service);
return service;
} finally {
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
}
}
}
SystemServiceManager의 startService는 먼저 시작할 서비스 개체의 Context 매개 변수로 구성 메서드를 가져오고 구성 메서드를 호출하여 서비스 인스턴스 개체를 생성합니다.첫 번째 섹션의 코드와 결합하면 다음을 알 수 있습니다.
ActivityTaskManagerService atm = mSystemServiceManager.startService(
ActivityTaskManagerService.Lifecycle.class).getService();
여기에서는 ActivityTaskManagerService.Lifecycle 인스턴스 객체를 생성하기 위해 ActivityTaskManagerService.Lifecycle 클래스의 Context 매개 변수를 사용하여 생성 메서드를 실제로 호출합니다.
2. ActivityTaskManagerService.Lifecycle의 구성 방법은 다음과 같습니다.
frameworks/base/services/core/java/com/android/server/wm/ActivityTaskManagerService.java
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
public static final class Lifecycle extends SystemService {
private final ActivityTaskManagerService mService;
public Lifecycle(Context context) {
super(context);
//创建ActivityTaskManagerService实例对象
mService = new ActivityTaskManagerService(context);
}
}
}
ActivityTaskManagerService 인스턴스 개체는 ActivityTaskManagerService.Lifecycle의 생성자에서 생성됩니다.
3. 1단계로 돌아갑니다. SystemServiceManager의 startService(Class serviceClass) 메소드가 리플렉션을 통해 ActivityTaskManagerService.Lifecycle 인스턴스 객체를 생성한 후 자체 startService(@NonNull final SystemService service) 메소드를 계속 호출합니다.
public final class SystemServiceManager implements Dumpable {
public void startService(@NonNull final SystemService service) {
//在类型为ArrayList<SystemService>的属性集合mServices中注册新创建的服务对象
mServices.add(service);
//调用服务的onStart方法，开启服务
long time = SystemClock.elapsedRealtime();
try {
service.onStart();
} catch (RuntimeException ex) {
throw new RuntimeException("Failed to start service " + service.getClass().getName()
+ ": onStart threw an exception", ex);
}
//统计开启对应服务所花费的时间
warnIfTooLong(SystemClock.elapsedRealtime() - time, service, "onStart");
}
위의 코드에서 이 메서드는 ArrayList 유형의 속성 컬렉션 mServices에 새로 생성된 ActivityTaskManagerService.Lifecycle 인스턴스 개체를 먼저 등록한 다음 인스턴스 개체의 onStart 메서드를 호출하는 것을 볼 수 있습니다.
4. 여기에 ActivityTaskManagerService.Lifecycle 클래스의 모든 코드를 게시합니다.
public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
public static final class Lifecycle extends SystemService {
private final ActivityTaskManagerService mService;
public Lifecycle(Context context) {
super(context);
//创建ActivityTaskManagerService实例对象
mService = new ActivityTaskManagerService(context);
}
@Override
public void onStart() {
//调用自己的父类SystemService的publishBinderService方法，
//将ActivityTaskManagerService实例对象绑定到ServiceManager中
publishBinderService(Context.ACTIVITY_TASK_SERVICE, mService);
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());
}
}
public ActivityTaskManagerService getService() {
return mService;
}
}
}
ActivityTaskManagerService.Lifecycle의 onStart 메서드는 먼저 상위 클래스인 SystemService의 publishBinderService 메서드를 호출하고 ActivityTaskManagerService 인스턴스 개체를 ServiceManager에 바인딩합니다.
3. ActivityManagerService.Lifecycle은 ActivityManagerService 서비스를 시작합니다.
1. 첫 번째 섹션의 3단계에 있는 startBootstrapServices 메서드로 돌아가 ActivityManagerService.Lifecycle 인스턴스 개체가 생성된 후 시스템은 계속해서 ActivityManagerService.Lifecycle의 정적 메서드 startService를 호출하여 ActivityManagerService 서비스를 시작합니다.
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;
//和ActivityTaskManagerService服务的启动相似，也是调用SystemServiceManager的startService方法。
return ssm.startService(ActivityManagerService.Lifecycle.class).getService();
}
@Override
public void onStart() {
//调用AMS的start方法
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;
}
}
}
ActivityManagerService.Lifecycle의 startService도 SystemServiceManager의 startService 메서드를 호출하여 ActivityManagerService 서비스를 시작합니다. 프로세스는 기본적으로 ActivityTaskManagerService의 생성 프로세스와 동일하며 결국 ActivityManagerService.Lifecycle 객체의 구성 메서드를 트리거합니다. ActivityManagerService 인스턴스를 생성합니다. 이 구성 메서드에서 개체를 호출한 다음 ActivityManagerService.Lifecycle 개체의 onStart 메서드를 호출하여 ActivityManagerService의 시작 메서드를 트리거합니다.
네, ActivityManagerService 클래스 정의
4.1 시공방법
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
// 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) {
LockGuard.installLock(this, LockGuard.INDEX_ACTIVITY);
mInjector = new Injector(systemContext);
mContext = systemContext;
mFactoryTest = FactoryTest.getMode();
mSystemThread = ActivityThread.currentActivityThread();
mUiContext = mSystemThread.getSystemUiContext();
Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
mHandlerThread = new ServiceThread(TAG,
THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
mHandlerThread.start();
mHandler = new MainHandler(mHandlerThread.getLooper());
mUiHandler = mInjector.getUiHandler(this);
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.
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);
mActivityTaskManager = atm;
mActivityTaskManager.initialize(mIntentFirewall, mPendingIntentController,
DisplayThread.get().getLooper());
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();
}
}
4.2 시작 방법 시작 코드는 다음과 같습니다.
public class ActivityManagerService extends IActivityManager.Stub
implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback, ActivityManagerGlobalLock {
private void start() {
removeAllProcessGroups();
mBatteryStatsService.publish();
mAppOpsService.publish();
Slog.d("AppOps", "AppOpsService published");
LocalServices.addService(ActivityManagerInternal.class, mInternal);
LocalManagerRegistry.addManager(ActivityManagerLocal.class,
(ActivityManagerLocal) mInternal);
mActivityTaskManager.onActivityManagerInternalAdded();
mPendingIntentController.onActivityManagerInternalAdded();
mAppProfiler.onActivityManagerInternalAdded();
}
}