1. SystemServiceManger启动
分析过SystemServer的朋友应该都有记忆，SystemServiceManager就是在SystemServer中启动的，下面是SystemServiceManager的启动代码：
|
1 2 3 4 |
[SystemServer.java] // Create the system service manager. mSystemServiceManager = new SystemServiceManager(mSystemContext); LocalServices.addService(SystemServiceManager.class, mSystemServiceManager); |
这里直接通过new一个SystemServiceManager对象，然后将新new的对象保存到mSystemServiceManager中，以备后用。
SystemServiceManager的代码如下：
|
1 2 3 |
public SystemServiceManager(Context context) { mContext = context; } |
这里只要将context保存到mContext中即可，现在SystemServiceManager就初始化完毕了。
2. SystemServiceManager代码分析
2.1 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 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 77 78 |
/** * Starts a service by class name. * * @return The service instance. */ @SuppressWarnings("unchecked") public SystemService startService(String className) { // SystemrService类的class对象 final Class<SystemService> serviceClass; try { // 通过Class.forName，传入String型类名，得到对应类名的class对象 serviceClass = (Class<SystemService>)Class.forName(className); } catch (ClassNotFoundException ex) { Slog.i(TAG, "Starting " + className); throw new RuntimeException("Failed to create service " + className + ": service class not found, usually indicates that the caller should " + "have called PackageManager.hasSystemFeature() to check whether the " + "feature is available on this device before trying to start the " + "services that implement it", ex); } // 调用另一个startService重载函数 return startService(serviceClass); } /** * 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") // 模板类函数，其中serviceClass必须是SystemService的子类 public <T extends SystemService> T startService(Class<T> serviceClass) { final String name = serviceClass.getName(); Slog.i(TAG, "Starting " + name); // Create the service. // 再次确认serviceClass是SystemService的子类 if (!SystemService.class.isAssignableFrom(serviceClass)) { throw new RuntimeException("Failed to create " + name + ": service must extend " + SystemService.class.getName()); } final T service; try { // 获取service的构造函数 Constructor<T> constructor = serviceClass.getConstructor(Context.class); // 创建service对象 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); } // Register it. // 将service添加到mServices ArrayList中 mServices.add(service); // Start it. try { // 启动service service.onStart(); } catch (RuntimeException ex) { throw new RuntimeException("Failed to start service " + name + ": onStart threw an exception", ex); } return service; } |
2.2 SystemServiceManager中的startBootPhase函数
|
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 |
/** * Starts the specified boot phase for all system services that have been started up to * this point. * * @param phase The boot phase to start. */ public void startBootPhase(final int phase) { if (phase <= mCurrentPhase) { throw new IllegalArgumentException("Next phase must be larger than previous"); } mCurrentPhase = phase; Slog.i(TAG, "Starting phase " + mCurrentPhase); // 轮询mServices中所有的service final int serviceLen = mServices.size(); for (int i = 0; i < serviceLen; i++) { final SystemService service = mServices.get(i); try { /// M: Service operation time log @{ long startTime = 0; if (!IS_USER_BUILD) startTime = SystemClock.elapsedRealtime(); /// @} // 调用service的onBootPhase方法 service.onBootPhase(mCurrentPhase); /// M: Service operation time log @{ if (!IS_USER_BUILD) { checkTime(startTime, "Phase " + mCurrentPhase, service.getClass().getName()); } /// @} } catch (Exception ex) { throw new RuntimeException("Failed to boot service " + service.getClass().getName() + ": onBootPhase threw an exception during phase " + mCurrentPhase, ex); } } } |
startBootPhase也比较简单，因为有些service的启动需要以来其他的service，所以Systemserver会将设备启动分成几个阶段，每个阶段启动不同的service，而这些就是由startBootPhase这个方法来实现的。如果检测到当前的phase达到service的设定值，service就会完成相应的工作。下面是BatteryService的onBootPhase方法，可以知道当设备启动到PHASE_ACTIVITY_MANAGER_READY，该方法就会调用执行相应的操作。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public void onBootPhase(int phase) { if (phase == PHASE_ACTIVITY_MANAGER_READY) { // check our power situation now that it is safe to display the shutdown dialog. synchronized (mLock) { mBootCompleted = true; ContentObserver obs = new ContentObserver(mHandler) { @Override public void onChange(boolean selfChange) { synchronized (mLock) { updateBatteryWarningLevelLocked(); } } }; final ContentResolver resolver = mContext.getContentResolver(); resolver.registerContentObserver(Settings.Global.getUriFor( Settings.Global.LOW_POWER_MODE_TRIGGER_LEVEL), false, obs, UserHandle.USER_ALL); updateBatteryWarningLevelLocked(); } } } |
2.3 SystemServiceManager中剩余关于user的函数
SystemServiceManager中剩余一下关于特定user的函数，具体的使用场景在SystemService.java中有描述，大家可以看下面代码中的注释，简单明了。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
/** * Called when switching to a different foreground user, for system services that have * special behavior for whichever user is currently in the foreground. This is called * before any application processes are aware of the new user. * @param userHandle The identifier of the user. */ public void onSwitchUser(int userHandle) {} /** * Called when an existing user is stopping, for system services to finalize any per-user * state they maintain for running users. This is called prior to sending the SHUTDOWN * broadcast to the user; it is a good place to stop making use of any resources of that * user (such as binding to a service running in the user). * @param userHandle The identifier of the user. */ public void onStopUser(int userHandle) {} /** * Called when an existing user is stopping, for system services to finalize any per-user * state they maintain for running users. This is called after all application process * teardown of the user is complete. * @param userHandle The identifier of the user. */ public void onCleanupUser(int userHandle) {} |
3. 看看SystemService的内容
系统中存在部分service是systemservice的子类，所以就顺便看看Systemservice的代码都有哪些：
|
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 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
public abstract class SystemService { // 列出设备启动的各个阶段 /* * Boot Phases */ public static final int PHASE_WAIT_FOR_DEFAULT_DISPLAY = 100; // maybe should be a dependency? /** * After receiving this boot phase, services can obtain lock settings data. */ public static final int PHASE_LOCK_SETTINGS_READY = 480; /** * After receiving this boot phase, services can safely call into core system services * such as the PowerManager or PackageManager. */ public static final int PHASE_SYSTEM_SERVICES_READY = 500; /** * After receiving this boot phase, services can broadcast Intents. */ public static final int PHASE_ACTIVITY_MANAGER_READY = 550; /** * After receiving this boot phase, services can start/bind to third party apps. * Apps will be able to make Binder calls into services at this point. */ public static final int PHASE_THIRD_PARTY_APPS_CAN_START = 600; /** * After receiving this boot phase, services can allow user interaction with the device. * This phase occurs when boot has completed and the home application has started. * System services may prefer to listen to this phase rather than registering a * broadcast receiver for ACTION_BOOT_COMPLETED to reduce overall latency. */ public static final int PHASE_BOOT_COMPLETED = 1000; private final Context mContext; /** * Initializes the system service. * * Subclasses must define a single argument constructor that accepts the context * and passes it to super. * * * @param context The system server context. */ // systemservice的构造函数 public SystemService(Context context) { mContext = context; } /** * Gets the system context. */ public final Context getContext() { return mContext; } /** * Returns true if the system is running in safe mode. * TODO: we should define in which phase this becomes valid */ public final boolean isSafeMode() { return getManager().isSafeMode(); } /** * Called when the dependencies listed in the @Service class-annotation are available * and after the chosen start phase. * When this method returns, the service should be published. */ public abstract void onStart(); /** * Called on each phase of the boot process. Phases before the service's start phase * (as defined in the @Service annotation) are never received. * * @param phase The current boot phase. */ public void onBootPhase(int phase) {} /** * Called when a new user is starting, for system services to initialize any per-user * state they maintain for running users. * @param userHandle The identifier of the user. */ public void onStartUser(int userHandle) {} /** * Called when switching to a different foreground user, for system services that have * special behavior for whichever user is currently in the foreground. This is called * before any application processes are aware of the new user. * @param userHandle The identifier of the user. */ public void onSwitchUser(int userHandle) {} /** * Called when an existing user is stopping, for system services to finalize any per-user * state they maintain for running users. This is called prior to sending the SHUTDOWN * broadcast to the user; it is a good place to stop making use of any resources of that * user (such as binding to a service running in the user). * @param userHandle The identifier of the user. */ public void onStopUser(int userHandle) {} /** * Called when an existing user is stopping, for system services to finalize any per-user * state they maintain for running users. This is called after all application process * teardown of the user is complete. * @param userHandle The identifier of the user. */ public void onCleanupUser(int userHandle) {} /** * Publish the service so it is accessible to other services and apps. */ protected final void publishBinderService(String name, IBinder service) { publishBinderService(name, service, false); } /** * Publish the service so it is accessible to other services and apps. */ protected final void publishBinderService(String name, IBinder service, boolean allowIsolated) { ServiceManager.addService(name, service, allowIsolated); } /** * Get a binder service by its name. */ protected final IBinder getBinderService(String name) { return ServiceManager.getService(name); } /** * Publish the service so it is only accessible to the system process. */ protected final <T> void publishLocalService(Class<T> type, T service) { LocalServices.addService(type, service); } /** * Get a local service by interface. */ protected final <T> T getLocalService(Class<T> type) { return LocalServices.getService(type); } private SystemServiceManager getManager() { return LocalServices.getService(SystemServiceManager.class); } } |
其中比较感兴趣的是publishBinderService这个方法，在之前看到这个函数还不知道是做什么用的，现在看到这个方法的代码，瞬间清晰了，这个方法最终也还是会调用ServiceManager.addService方法，将service添加到ServiceManager中。
另一个感兴趣的方法是publishLocalService，这个方法将一些要在system process中用到的service添加到LocalServices static类对象中，这个类内部通过ArrayMap将这些service记录起来，到后面需要使用就可以非常快速方便的取出来了。
