ActivityManagerService启动过程

AMSAndroid 阅读量

ActivityManagerService简称AMS，也就是通常说的组件管理器，是系统核心服务之一，用于对四大组件进行管理，包括创建四大组件，组件生命周期管理等。这里先先了解下AMS的创建过程。代码基于Android P。

AMS的启动是在SystemServer中进行的。SystemServer中服务启动分为三个过程：

1
2
3
startBootstrapServices();
startCoreServices();
startOtherServices();

AMS的启动贯穿了这三个过程。

startBootstrapServices

BootstrapServices是指系统启动所需的核心服务，这些服务具有复杂的相互依赖关系所以放到一个地方初始化。其中AMS的初始化代码如下：

1
2
3
4
5
6
7
// Activity manager runs the show.
traceBeginAndSlog("StartActivityManager");
mActivityManagerService = mSystemServiceManager.startService(
        ActivityManagerService.Lifecycle.class).getService();
mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
mActivityManagerService.setInstaller(installer);
traceEnd();

其中mSystemServiceManager是SystemServiceManager的实例用于管理系统服务的创建启动及其他生命周期事件。而 ActivityManagerService.Lifecycle是 ActivityManagerService的静态内部类，继承了SystemService并封装了一些AMS生命周期的回调，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public static final class Lifecycle extends SystemService {
    private final ActivityManagerService mService;

    public Lifecycle(Context context) {
        super(context);
        mService = new ActivityManagerService(context);
    }
    @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();
        }
    }
    @Override
    public void onCleanupUser(int userId) {
        mService.mBatteryStatsService.onCleanupUser(userId);
    }

    public ActivityManagerService getService() {
        return mService;
    }
}

SystemServiceManager的startService()方法是一个泛型方法，用于启动系统服务，其实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * Creates and starts a system service. The class must be a subclass of
 * {@link com.android.server.SystemService}.
 *
 * @param serviceClass A Java class that implements the SystemService interface.
 * @return The service instance, never null.
 * @throws RuntimeException if the service fails to start.
 */
@SuppressWarnings("unchecked")
public <T extends SystemService> T startService(Class<T> serviceClass) {
    try {
        final String name = serviceClass.getName();
        //……
        Trace.traceBegin(Trace.TRACE_TAG_SYSTEM_SERVER, "StartService " + name);
        //……
        final T service;
        try {
            Constructor<T> constructor = serviceClass.getConstructor(Context.class);
            service = constructor.newInstance(mContext);
        } catch (InstantiationException ex) {//……
        } catch (IllegalAccessException ex) {//……
        } catch (NoSuchMethodException ex) {//……
        } catch (InvocationTargetException ex) { //……
        }

        startService(service);
        return service;
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
    }
}

首先需要通过反射的方法得到service的实例，因为泛型不是具体的类，无法在编译期加载，只能使用反射在运行时动态加载。这里的service指的是ActivityManagerService.Lifecycle，而不是ActivityManagerService本身，之所以这么设计应该是应为ActivityManagerService已经继承了IActivityManager.Stub，无法再继承SystemService。

在LifeCycle的构造方法中构建了AMS的实例，AMS构造方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
  // 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;
      //……
      mSystemThread = ActivityThread.currentActivityThread();
      mUiContext = mSystemThread.getSystemUiContext();
      //……
      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(this, mHandler);

      /* static; one-time init here */
      if (sKillHandler == null) {
          sKillThread = new ServiceThread(TAG + ":kill",
                  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);
      mProviderMap = new ProviderMap(this);
      mAppErrors = new AppErrors(mUiContext, this);

      File dataDir = Environment.getDataDirectory();
      File systemDir = new File(dataDir, "system");
      systemDir.mkdirs();
//……
      mAppOpsService = mInjector.getAppOpsService(new File(systemDir, "appops.xml"), mHandler);//原生权限管理服务，暂时不管
      //……
      mTempConfig.setToDefaults();
      mTempConfig.setLocales(LocaleList.getDefault());
      mConfigurationSeq = mTempConfig.seq = 1;
      mStackSupervisor = createStackSupervisor();
      mStackSupervisor.onConfigurationChanged(mTempConfig);
    
      mKeyguardController = mStackSupervisor.getKeyguardController();
      mCompatModePackages = new CompatModePackages(this, systemDir, mHandler);
      //用于对Intent启动的组件进行拦截
      mIntentFirewall = new IntentFirewall(new IntentFirewallInterface(), mHandler);
      mTaskChangeNotificationController =
              new TaskChangeNotificationController(this, mStackSupervisor, mHandler);
      mActivityStartController = new ActivityStartController(this);
      mRecentTasks = createRecentTasks();
      mStackSupervisor.setRecentTasks(mRecentTasks);
      mLockTaskController = new LockTaskController(mContext, mStackSupervisor, mHandler);
      mLifecycleManager = new ClientLifecycleManager();
      //……
      mHiddenApiBlacklist = new HiddenApiSettings(mHandler, mContext);

      Watchdog.getInstance().addMonitor(this);
      Watchdog.getInstance().addThread(mHandler);

      // bind background thread 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();
      //……
  }

首先是进行Context和ActivityThread等成员的初始化，ActivityThread这个东西挺重要的，之后还要好好了解下，这里先关注主线流程。

AMS初始化过程中创建了三个ServiceThread，关于ServiceThread在了解PKMS的时候就接触过了，是系统服务专用的一个HandlerThread类，也就是一个带消息循环的线程，用来帮系统服务分担工作的，所以也不需要担心系统服务会不会管的事情太多而忙不过来。

前面说了AMS是管理四大组件的，接下来AMS首先创建了两个BroadcastQueue，一个是前台优先级的，一个是后台优先级的，用于进行广播的管理。

有了广播当然也要有Service和provider了，这两种组件分别用ActiveServices和ProviderMap进行管理，四大组件已经有了三个了，至于重头戏Activity还在后面，等下再说。

再然后会试着创建/data/system/目录，如果已存在的话就什么都不做。这个目录目测是用来存储一些系统用到的持久化文件的。

后面还有一堆的初始化工作，很多还不知道是干什么的，就先挑感兴趣的来看下。前面说了四大组件就差Activity了，Activity是通过什么来管理呢？其实是通过mStackSupervisor，这是一个ActivityStackSupervisor的实例，顾名思义是用来管理ActivityStack的，这个ActivityStack并不是平时说的任务栈，ActivityStack的内部管理着一个TaskRecord的列表，这个TaskRecord才是通常说的任务栈，而TaskRecord中维护着一个ActivityRecord的ArrayList，而这个ActivityRecord就是Activity在AMS中的表示。来看下mStackSupervisor的创建过程：

1
2
3
4
5
protected ActivityStackSupervisor createStackSupervisor() {
    final ActivityStackSupervisor supervisor = new ActivityStackSupervisor(this, mHandler.getLooper());
    supervisor.initialize();
    return supervisor;
}

里面的mHandler在前面出现过，是mHandlerThread这个ServiceThread的handler，也就是说和ActivityStackSupervisor相关的消息也不是在主线程处理的。在initialize()方法中会初始化RunningTasks实例，用以表示系统中正在运行的Task。

平时经常用到的最近任务也是在这里进行创建的：

1
2
mRecentTasks = createRecentTasks();
mStackSupervisor.setRecentTasks(mRecentTasks);

createRecentTasks()调用了RecentTasks的构造方法：

1
2
3
4
5
6
7
8
9
10
RecentTasks(ActivityManagerService service, ActivityStackSupervisor stackSupervisor) {
    final File systemDir = Environment.getDataSystemDirectory();
    final Resources res = service.mContext.getResources();
    mService = service;
    mUserController = service.mUserController;
    mTaskPersister = new TaskPersister(systemDir, stackSupervisor, service, this);
    mGlobalMaxNumTasks = ActivityManager.getMaxRecentTasksStatic();
    mHasVisibleRecentTasks = res.getBoolean(com.android.internal.R.bool.config_hasRecents);
    loadParametersFromResources(res);
}

mTaskPersister用于进行taskid的持久化，将taskId写入/data/system_de/0/persisted_taskIds.txt文件。mGlobalMaxNumTasks表示最大的任务数，低内存设备为36，非低内存设备48.mHasVisibleRecentTasks表示最近任务是否可见，可通过com.android.internal.R.bool.config_hasRecents这个资源进行配置，除此之外还可以进行以下配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<!-- Component name for the activity that will be presenting the Recents UI, which will receive special permissions for API related
      to fetching and presenting recent tasks. The default configuration uses Launcehr3QuickStep as default launcher and points to
      the corresponding recents component. When using a different default launcher, change this appropriately or use the default
      systemui implementation: com.android.systemui/.recents.RecentsActivity -->
<string name="config_recentsComponentName" translatable="false">com.android.launcher3/com.android.quickstep.RecentsActivity</string>

<!-- The minimum number of visible recent tasks to be presented to the user through the
     SystemUI. Can be -1 if there is no minimum limit. -->
<integer name="config_minNumVisibleRecentTasks_grid">-1</integer>

<!-- The maximum number of visible recent tasks to be presented to the user through the
     SystemUI. Can be -1 if there is no maximum limit. -->
<integer name="config_maxNumVisibleRecentTasks_grid">9</integer>

<!-- The minimum number of visible recent tasks to be presented to the user through the
     SystemUI. Can be -1 if there is no minimum limit. -->
<integer name="config_minNumVisibleRecentTasks_lowRam">-1</integer>

<!-- The maximum number of visible recent tasks to be presented to the user through the
     SystemUI. Can be -1 if there is no maximum limit. -->
<integer name="config_maxNumVisibleRecentTasks_lowRam">9</integer>

<!-- The minimum number of visible recent tasks to be presented to the user through the
     SystemUI. Can be -1 if there is no minimum limit. -->
<integer name="config_minNumVisibleRecentTasks">5</integer>

<!-- The maximum number of visible recent tasks to be presented to the user through the
     SystemUI. Can be -1 if there is no maximum limit. -->
<integer name="config_maxNumVisibleRecentTasks">-1</integer>

<!-- The duration in which a recent task is considered in session and should be visible. -->
<integer name="config_activeTaskDurationHours">6</integer>

除了config_hasRecents之外的配置项在Android O中还是没有的，其中config_recentsComponentName可以配置显示最近任务的组件，Android P中有两个组件可以显示最近任务，一个是launcher的com.android.launcher3/com.android.quickstep.RecentsActivity，一个是SystemUI的 com.android.systemui/.recents.RecentsActivity，默认采用launcher中的组件。

后面关于hidden api和性能的代码暂时不做了解。

好了，AMS的初始化到这里就结束了，之后通过mActivityManagerService.setSystemServiceManager(mSystemServiceManager);设置AMS的管理器。

startCoreServices

在该方法中只是将AMS和UsageStatsManager进行关联，至于UsageStatsManager是干吗的暂时不关心。

startOtherServices

该方法中AMS出现了这么几次，挑其中几个感兴趣的来了解下：

  • installSystemProviders, 安装系统的provider，包括Settings.System,Settings.Secure,Settings.Global等内容，该方法的代码：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    public final void installSystemProviders() {
         List<ProviderInfo> providers;
         synchronized (this) {
             ProcessRecord app = mProcessNames.get("system", SYSTEM_UID);
             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);
                     }
                 }
             }
         }
         if (providers != null) {
             mSystemThread.installSystemProviders(providers);
         }

         synchronized (this) {
             mSystemProvidersInstalled = true;
         }

         mConstants.start(mContext.getContentResolver());
         mCoreSettingsObserver = new CoreSettingsObserver(this);
         mFontScaleSettingObserver = new FontScaleSettingObserver();
         mDevelopmentSettingsObserver = new DevelopmentSettingsObserver();
         GlobalSettingsToPropertiesMapper.start(mContext.getContentResolver());

         // Now that the settings provider is published we can consider sending
         // in a rescue party.
         RescueParty.onSettingsProviderPublished(mContext);

         //mUsageStatsService.monitorPackages();
     }

    首先通过mProcessNames.get("system", SYSTEM_UID); 获取进程名为system，uid为SystemUID（1000）的进程，然后获取该进程中的provider信息，值得注意的是，进程名为system（android:process="system"），sharedUid为system(android:sharedUserId=”android.uid.system”)的应用有多个，常用到的SettingsProvider就是其中之一，但是包含provider的只有framework-res和SettingsProvider这两个（cts里还有一个，但是不算在内），这部分主要就是针对SettingsProvider的。

    之后通过mSystemThread.installSystemProviders(providers); 对获取的providers进行安装，也就是放到mProviderMap中，再然后就是对各种provider添加observer。关于provider的处理在以后单独了解，这里知道有这回事就行。

  • watchdog.init(context, mActivityManagerService);初始化看门狗，暂不了解。

  • mActivityManagerService.setWindowManager(wm);关联WMS实例，代码如下：

    1
    2
    3
    4
    5
    6
    7
    public void setWindowManager(WindowManagerService wm) {
        synchronized (this) {
            mWindowManager = wm;
            mStackSupervisor.setWindowManager(wm);
            mLockTaskController.setWindowManager(wm);
        }
    }

    在这个时候调用这个方法是因为AMS需要和WMS交互但是在AMS初始化的过程中WMS实例还不存在（是在otherService中生成的），所以需要在WMS生成后和AMS进行关联。

  • mActivityManagerService.systemReady，代码比较长，只挑其中几个感兴趣的片段来看下：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    mActivityManagerService.systemReady(() -> {
                Slog.i(TAG, "Making services ready");
                traceBeginAndSlog("StartActivityManagerReadyPhase");
                //通知系统服务，SystemServer到了PHASE_ACTIVITY_MANAGER_READY阶段
                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_ACTIVITY_MANAGER_READY);
                traceEnd();
                traceBeginAndSlog("StartObservingNativeCrashes");
                try {//添加NativeCrashListener
                    mActivityManagerService.startObservingNativeCrashes();
                } catch (Throwable e) {
                    reportWtf("observing native crashes", e);
                }
                traceEnd();
                //……
                traceBeginAndSlog("StartSystemUI");
                try {//启动SystemUI的com.android.systemui.SystemUIService
                     //并通知WMS，绑定keyguard
                    startSystemUi(context, windowManagerF);
                } catch (Throwable e) {
                    reportWtf("starting System UI", e);
                }
                traceEnd();
                //……
                traceBeginAndSlog("StartWatchdog");
                Watchdog.getInstance().start();
                traceEnd();

                // Wait for all packages to be prepared
                mPackageManagerService.waitForAppDataPrepared();
    		   //……
                // 所有的package data已准备完成，可以运行第三方的代码了，通知系统服务
                mSystemServiceManager.startBootPhase(
                        SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
                traceEnd();
    			//……
            }, BOOT_TIMINGS_TRACE_LOG);

    在systemReady方法中，runnable运行之后会启动homeActivity:startHomeActivityLocked(currentUserId, "systemReady"); 。

    ​

以上就是AMS启动的大致流程，主要就是创建AMS实例、关联其他服务，以及启动完成三个阶段，其中有很多内容未做了解，有些理解可能也不太到位，这里仅对已了解内容作个记录，以后再进行补充和修正。

Powered by Hexo and Hexo-theme-hiker

Copyright © 2018 - 2022 得一 All Rights Reserved.

访客数 : | 访问量 :