android服务如何开机不获取,Android系统服务调用分析

在Android系统中，framework向应用层提供了很多系统服务，例如InputManager、ActivityManager、WindowManager等，方便的实现软件需求的开发。

一.系统服务使用

一般而言，在使用时，通过以下方式来获取对应的系统服务管理者：

WindowManager mWindowManager;

mWindowManager = (WindowManager) mService.getSystemService(Context.WINDOW_SERVICE);

mWindowManager.addView();

即：调用 Context 类的 getSystemService(String name) 方法，通过一步一步调用，该方法的最终实现是在 ContextImpl 类中，通过查看 ContextImpl 的源码，发现对应的实现如下：

public Object getSystemService(String name) {

return SystemServiceRegistry.getSystemService(this, name);

}

从ContextImpl里面的实现来看，会调用到SystemServiceRegistry类里面的getSystemService方法，再进去看一下SystemServiceRegistry.java的内部实现：

public static Object getSystemService(ContextImpl ctx, String name) {

SystemServiceRegistry.ServiceFetcher> fetcher = (SystemServiceRegistry.ServiceFetcher)SYSTEM_SERVICE_FETCHERS.get(name);

return fetcher != null ? fetcher.getService(ctx) : null;

}

从以上方法可以看到：从SYSTEM_SERVICE_FETCHERS 中获取对应名称的系统服务管理者提取器，然后从中得到对应的服务器管理者。看一下SYSTEM_SERVICE_FETCHERS：

private static final HashMap> SYSTEM_SERVICE_FETCHERS = new HashMap();

SYSTEM_SERVICE_FETCHERS是一个HashMap，存放着String为key，ServiceFetcher为value的键值对：

private static void registerService(String serviceName, Class serviceClass, SystemServiceRegistry.ServiceFetcher serviceFetcher) {

SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);

SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);

}

在执行registerService方法时，将serviceName对应的serviceFetcher存入HashMap，接着看一下ServiceFetcher的实现：

abstract static class CachedServiceFetcher implements SystemServiceRegistry.ServiceFetcher {

private final int mCacheIndex;

public CachedServiceFetcher() {

mCacheIndex = SystemServiceRegistry.sServiceCacheSize++;

}

public final T getService(ContextImpl ctx) {

final Object[] cache = ctx.mServiceCache;

synchronized(cache) {

Object service = cache[mCacheIndex];

if (service == null) {

try {

service = createService(ctx);

cache[mCacheIndex] = service;

} catch (ServiceNotFoundException e) {

onServiceNotFound(e);

}

}

return (T)service;

}

}

public abstract T createService(ContextImpl ctx) throws ServiceNotFoundException;

}

interface ServiceFetcher {

T getService(ContextImpl var1);

}

从以上可以看到，ServiceFetcher是一个接口，通过CachedServiceFetcher来实现，里面有一个抽象方法createService()需要实现，在getService()方法里面有调用到createService()，接下来看一下系统服务是如何注册的：

二.系统服务注册

要想使用系统服务，肯定是需要系统服务先注册后使用，看一下系统服务是什么时候注册的：

static {

....

registerService("rttmanager", RttManager.class, new SystemServiceRegistry.CachedServiceFetcher() {

public RttManager createService(ContextImpl ctx) throws ServiceNotFoundException {

IBinder b = ServiceManager.getServiceOrThrow("rttmanager");

IRttManager service = android.net.wifi.IRttManager.Stub.asInterface(b);

return new RttManager(ctx.getOuterContext(), service, ConnectivityThread.getInstanceLooper());

}

});

registerService("ethernet", EthernetManager.class, new SystemServiceRegistry.CachedServiceFetcher() {

public EthernetManager createService(ContextImpl ctx) throws ServiceNotFoundException {

IBinder b = ServiceManager.getServiceOrThrow("ethernet");

IEthernetManager service = android.net.IEthernetManager.Stub.asInterface(b);

return new EthernetManager(ctx.getOuterContext(), service);

}

});

registerService("window", WindowManager.class, new SystemServiceRegistry.CachedServiceFetcher() {

public WindowManager createService(ContextImpl ctx) {

return new WindowManagerImpl(ctx);

}

});

}

....

registerService()是在static代码块里面，createService()会返回对应的Manager，那么在getSystemService()内部执行fetcher.getService(ctx)就获取到了manager，在返回前有以下逻辑：

IBinder b = ServiceManager.getServiceOrThrow("ethernet");

IEthernetManager service = android.net.IEthernetManager.Stub.asInterface(b);

先通过ServiceManager获取了“ethernet”对应的IBinder，然后获取到service，最后把service作为参数传递给EthernetManager。看一下EthernetManager的实现：

public class EthernetManager {

private final IEthernetManager mService;

public EthernetManager(Context context, IEthernetManager service) {

mContext = context;

mService = service;

}

public IpConfiguration getConfiguration() {

try {

return mService.getConfiguration();

}

.....

}

public void setConfiguration(IpConfiguration config) {

try {

mService.setConfiguration(config);

}

.....

}

public boolean isAvailable() {

try {

return mService.isAvailable();

}

......

}

public void addListener(Listener listener) {

mListeners.add(listener);

if (mListeners.size() == 1) {

try {

mService.addListener(mServiceListener);

}

......

}

}

public void removeListener(Listener listener) {

mListeners.remove(listener);

if (mListeners.isEmpty()) {

try {

mService.removeListener(mServiceListener);

}

......

}

}

通过以上看到，通过EthernetManager来调用framework接口，其实是通过IEthernetManager来执行的，IEthernetManager是aidl接口，而前面看到，IEthernetManager是通过Stub.asInterface()来获取的，肯定有对应Binder实现，接下来看一下该Binder的实现及Binder是如何暴露出来的：

三.系统服务实现

本文拿EthernetManager来举例，看一下对应的EthernetService的内部逻辑是如何实现的：

public final class EthernetService extends SystemService {

private static final String TAG = "EthernetService";

final EthernetServiceImpl mImpl;

public EthernetService(Context context) {

super(context);

mImpl = new EthernetServiceImpl(context);

}

@Override

public void onStart() {

Log.i(TAG, "Registering service " + Context.ETHERNET_SERVICE);

//公开Binder

publishBinderService(Context.ETHERNET_SERVICE, mImpl);

}

}

在构造方法中创建EthernetServiceImpl()实例，然后在onStart()中执行publishBinderService()，该方法是父类SystemService.java的方法，实现如下：

protected final void publishBinderService(String name, IBinder service) {

publishBinderService(name, service, false);

}

protected final void publishBinderService(String name, IBinder service,

boolean allowIsolated) {

//最终会通过ServiceManager.addService来注册Binder

ServiceManager.addService(name, service, allowIsolated);

}

通过以上可以看到，在EthernetService启动时，会执行publishBinderService()来将EthernetServiceImpl来作为实名的Binder来暴露出来，在publishBinderService()内部会通过ServiceManager.addService()将实名Binder统一给ServiceManager来管理。

public class EthernetServiceImpl extends IEthernetManager.Stub {

//实现IEthernetManager里面的方法

IpConfiguration getConfiguration() {

}

void setConfiguration(in IpConfiguration config) {

}

boolean isAvailable(){

}

void addListener(in IEthernetServiceListener listener){

}

}

EthernetServiceImpl继承IEthernetManager.Stub，来实现IEthernetManager.aidl的方法，供远端的Client来最终调用。

interface IEthernetManager

{

IpConfiguration getConfiguration();

void setConfiguration(in IpConfiguration config);

boolean isAvailable();

void addListener(in IEthernetServiceListener listener);

}

四.系统服务启动

要想获取IEthernetManager的Binder，必须要先把Binder公开出来，该Binder公开是在EthernetService启动后执行的，那么需要有个地方来启动EthernetService，该启动入口是在哪的？在SystemServer.java中：

private void run() {

// Start services.

try {

traceBeginAndSlog("StartServices");

startBootstrapServices();

startCoreServices();

startOtherServices();

SystemServerInitThreadPool.shutdown();

}

......

}

在SystemServer启动的时候，去在main()中调用run()方法，然后在run()中会去启动系统的一些公共service，该service在startOtherServices()中启动的：

private static final String ETHERNET_SERVICE_CLASS ="com.android.server.ethernet.EthernetService";

private void startOtherServices() {

......

//其他service

......

if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_ETHERNET) ||

mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {

traceBeginAndSlog("StartEthernet");

mSystemServiceManager.startService(ETHERNET_SERVICE_CLASS);

traceEnd();

}

....

//其他service

......

}

EthernetService是在startOtherServices()通过SystemServiceManager.startService()去启动的，传入对应的系统服务类名，看一下SystemServiceManager内部startService的实现逻辑：

public SystemService startService(String className) {

final Class serviceClass;

try {

serviceClass = (Class)Class.forName(className);

}

......

return startService(serviceClass);

}

先通过传入的字符串找到对应的类，然后传入类名调用startService()：

public T startService(Class serviceClass) {

try {

final String name = serviceClass.getName();

.......

final T service;

try {

Constructor constructor = serviceClass.getConstructor(Context.class);

service = constructor.newInstance(mContext);

}

.......

startService(service);

return service;

} finally {

Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);

}

}

通过反射找到构造方法，然后通过newInstance()来创造了实例，然后传入该实例调用startService()：

public void startService(@NonNull final SystemService service) {

// Register it.

mServices.add(service);

// Start it.

long time = SystemClock.elapsedRealtime();

try {

service.onStart();

}

......

}

调用service的onStart()方法，即调用了EthernetService的onStart()方法，将Binder暴露出来供调用；注意：SystemService是一个抽象类，不是Service。

简单总结一下：系统服务首先通过SystemServer内部调用SystemServiceManager来进行启动，启动后会将自己注册到ServiceManager作为实名服务，系统服务对应的Manager在SystemServiceRegistry内部注册时就通过ServiceManager来获取到该服务，从而供上层应用使用；当使用系统服务时，首先通过 Context 类的 getSystemService方法获取到服务对应的Manager，Manager会通过对应服务公开的Binder最终与服务进行通信，然后来执行上层的逻辑。

五.系统服务实现及使用流程

1.创建xx.aidl文件，加入系统服务能提供的方法；

2.创建类文件来实现xx.Stub，来实现服务提供的方法；

3.将实现xx.Stub的类对象Binder通过ServiceManager.addService()注册【SystemServer作为入口触发】；

4.创建服务对应的Manager，封装对应服务提供方法的方法来供app调用；

5.SystemServiceProxy通过registerService来注册对应的服务【Manager与对应的服务建立联系】；

6.app通过getSystemService()来获取对应服务的Manager，然后调用方法；

六.其他

系统服务是供上层app来使用的，在rom定制化开发时，如果使用某个服务的应用很多时，比如数据上报，那么可以将数据上报作为一个系统服务来跟后台进行交互；

系统服务暴露对应的门面类Manager供应用来调用，这样的话系统服务只跟Manager打交道就行了，不需要跟所有的应用来维持关系。