SystemServer分析记录

Zygote进程forkSystemServer进程后，调用了SystemServer的main方法，具体流程请参考其他资料，这里记录的是SystemServer关键代码的分析

SystemServer代码：

public final class SystemServer {

	private SystemServiceManager mSystemServiceManager;
	private ActivityManagerService mActivityManagerService;
	
	public static void main(String[] args) {
        new SystemServer().run();
    }
	
	private void run() {
		...
		mSystemServiceManager = new SystemServiceManager(mSystemContext);
		...
		try {
            traceBeginAndSlog("StartServices");
            startBootstrapServices();
            startCoreServices();
            startOtherServices();
            SystemServerInitThreadPool.shutdown();
        } catch (Throwable ex) {
            Slog.e("System", "******************************************");
            Slog.e("System", "************ Failure starting system services", ex);
            throw ex;
        } finally {
            traceEnd();
        }
		...
	}
	
	private void startBootstrapServices() {
		...
		// AMS服务
		mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
        mActivityManagerService.setInstaller(installer);
		...
		// 添加AMS到ServiceManager 并添加其他Binder服务
		mActivityManagerService.setSystemProcess();
	}
	
	private void startCoreServices() {
        ...
		// 电池服务
        mSystemServiceManager.startService(BatteryService.class);
		...
    }
	
	private void startOtherServices() {
		...
		// WMS服务
		wm = WindowManagerService.main(context, inputManager,
				mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
				!mFirstBoot, mOnlyCore, new PhoneWindowManager());
		ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
				DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
		...
		// AMS与WMS建立关系
		mActivityManagerService.setWindowManager(wm);
		...
		// 启动桌面Launcher
		mActivityManagerService.systemReady(() -> {
		...
		});
	}

}

主要使用SystemServiceManager启动和管理各种服务：

引导服务	作用
Installer	系统安装apk时的一个服务类，启动完成Installer服务之后才能启动其他的系统服务
ActivityManagerService	负责四大组件的启动、切换、调度。
PowerManagerService	计算系统中和Power相关的计算，然后决策系统应该如何反应
LightsService	管理和显示背光LED
DisplayManagerService	用来管理所有显示设备
UserManagerService	多用户模式管理
SensorService	为系统提供各种感应器服务
PackageManagerService	用来对apk进行安装、解析、删除、卸载等等操作
核心服务
BatteryService	管理电池相关的服务
UsageStatsService	收集用户使用每一个APP的频率、使用时常
WebViewUpdateService	WebView更新服务
其他服务
CameraService	摄像头相关服务
AlarmManagerService	全局定时器管理服务
InputManagerService	管理输入事件
WindowManagerService	窗口管理服务
VrManagerService	VR模式管理服务
BluetoothService	蓝牙管理服务
NotificationManagerService	通知管理服务
DeviceStorageMonitorService	存储相关管理服务
LocationManagerService	定位管理服务
AudioService	音频相关管理服务

SystemServiceManager代码：

public class SystemServiceManager {

	private final ArrayList<SystemService> mServices = new ArrayList<SystemService>();

	public SystemService startService(String className) {
		final Class<SystemService> serviceClass;
		try {
			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);
		}
		return startService(serviceClass);
	}

	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 {
			   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(service);
			return service;
		} finally {
			Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
		}
	}

	public void startService(@NonNull final SystemService service) {
		// Register it.
		mServices.add(service);
		// Start it.
		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");
	}
	
}

AMS服务：

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
		
	// SystemServer调用
	// 其他服务都是在start方法添加到ServiceManager
	public void setSystemProcess() {
        try {
			// 添加到ServiceManager
            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));

            ApplicationInfo info = mContext.getPackageManager().getApplicationInfo(
                    "android", STOCK_PM_FLAGS | MATCH_SYSTEM_ONLY);
            mSystemThread.installSystemApplicationInfo(info, getClass().getClassLoader());

            synchronized (this) {
                ProcessRecord app = newProcessRecordLocked(info, info.processName, false, 0);
                app.persistent = true;
                app.pid = MY_PID;
                app.maxAdj = ProcessList.SYSTEM_ADJ;
                app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
                synchronized (mPidsSelfLocked) {
                    mPidsSelfLocked.put(app.pid, app);
                }
                updateLruProcessLocked(app, false, null);
                updateOomAdjLocked();
            }
        } 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 (mAppOpsService.checkOperation(op, uid, packageName)
                                    != AppOpsManager.MODE_ALLOWED) {
                                runInBackgroundDisabled(uid);
                            }
                        }
                    }
                });
    }

	// SystemServer创建WMS后，调用这个方法达成AMS与WMS建立关系
    public void setWindowManager(WindowManagerService wm) {
        synchronized (this) {
            mWindowManager = wm;
            mStackSupervisor.setWindowManager(wm);
            mLockTaskController.setWindowManager(wm);
        }
    }
	
	// 启动Launcher桌面应用
	public void systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
		...
		startHomeActivityLocked(currentUserId, "systemReady");
		...
	}

	// 所有服务都要继承SystemService，方便SystemServiceManager统一管理
	// 而AMS需要提供给APP使用，需要使用Binder机制，作为服务端继承Stub，所以使用静态内部类持有AMS达到多继承目的
	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();
			// 怎么没有添加到ServiceManager？
		}

		@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;
		}
	}

}