添加native和java系统服务

前面分析过binder的实现流程，binder的实现包含了Java和c++两部分，所以service的实现也包括java和c++两种，那么应该如何去自己实现并添加一个service？

c++中添加service

下面以SurfaceComposer这个service为例， 
① 首先提供接口文件ISurfaceComposer.h

//frameworks\native\include\gui\ISurfaceComposer.h//首先是接口，c++实现是虚函数class ISurfaceComposer: public IInterface {public:    DECLARE_META_INTERFACE(SurfaceComposer);    // flags for setTransactionState()    enum {        eSynchronous = 0x01,        eAnimation   = 0x02,    };    enum {        eDisplayIdMain = 0,        eDisplayIdHdmi = 1    };    /* create connection with surface flinger, requires     * ACCESS_SURFACE_FLINGER permission     */    virtual sp<ISurfaceComposerClient> createConnection() = 0;}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

② 建立BnSurfaceComposer 
建立BnSurfaceComposer，需要重写BBinder的onTransact函数。

class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {public:    enum {        // Note: BOOT_FINISHED must remain this value, it is called from        // Java by ActivityManagerService.        BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION,        CREATE_CONNECTION,        CREATE_GRAPHIC_BUFFER_ALLOC,        CREATE_DISPLAY_EVENT_CONNECTION,        CREATE_DISPLAY,        DESTROY_DISPLAY,        GET_BUILT_IN_DISPLAY,        SET_TRANSACTION_STATE,        AUTHENTICATE_SURFACE,        BLANK,        UNBLANK,        GET_DISPLAY_INFO,        CONNECT_DISPLAY,        CAPTURE_SCREEN,    };    virtual status_t onTransact(uint32_t code, const Parcel& data,            Parcel* reply, uint32_t flags = 0);};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

③ Bpxxx的实现

frameworks\native\libs\gui\ISurfaceComposer.cpp中，

//Bp实现，代理端class BpSurfaceComposer : public BpInterface<ISurfaceComposer>{public:    BpSurfaceComposer(const sp<IBinder>& impl)        : BpInterface<ISurfaceComposer>(impl)    {    }    //代理接口    virtual sp<ISurfaceComposerClient> createConnection()    {        uint32_t n;        Parcel data, reply;        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());        remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);        return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

④ Bnxxx的实现

//Bn端，即server端status_t BnSurfaceComposer::onTransact(    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags){    switch(code) {        case CREATE_CONNECTION: {            CHECK_INTERFACE(ISurfaceComposer, data, reply);            //createConnection就是server端的实现函数            sp<IBinder> b = createConnection()->asBinder();            reply->writeStrongBinder(b);            return NO_ERROR;        }        default: {            return BBinder::onTransact(code, data, reply, flags);        }    }    // should be unreachable    return NO_ERROR;}   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⑤ 注册service 
通过上面几步已经完成了service的建立，我们需要将service注册到service manager中。

class SurfaceFlinger : public BnSurfaceComposer,
1
1

    //在frameworks\native\services\surfaceflinger\main_surfaceflinger.cpp中，    // publish surface flinger    sp<IServiceManager> sm(defaultServiceManager());    sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);
1
2
3
4
1
2
3
4

⑥ 使用service

    //首先获取代理端BpSurfaceComposer    sp<ISurfaceComposer> composer(ComposerService::getComposerService());    //直接调用代理BpSurfaceComposer的接口    sp<IGraphicBufferAlloc> alloc(composer->createGraphicBufferAlloc());
1
2
3
4
1
2
3
4

其中getComposerService()的实现为，

/*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() {    ComposerService& instance = ComposerService::getInstance();    Mutex::Autolock _l(instance.mLock);    if (instance.mComposerService == NULL) {        ComposerService::getInstance().connectLocked();        assert(instance.mComposerService != NULL);        ALOGD("ComposerService reconnected");    }    return instance.mComposerService;}   
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

void ComposerService::connectLocked() {    const String16 name("SurfaceFlinger");    //获取service，返回的mComposerService是BpSurfaceComposer，有了Bp就能直接调用代理接口了    while (getService(name, &mComposerService) != NO_ERROR) {        usleep(250000);    }    assert(mComposerService != NULL);    // Create the death listener.    class DeathObserver : public IBinder::DeathRecipient {        ComposerService& mComposerService;        virtual void binderDied(const wp<IBinder>& who) {            ALOGW("ComposerService remote (surfaceflinger) died [%p]",                  who.unsafe_get());            mComposerService.composerServiceDied();        }     public:        DeathObserver(ComposerService& mgr) : mComposerService(mgr) { }    };    mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this));    mComposerService->asBinder()->linkToDeath(mDeathObserver);}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

java添加service

Android为了方便开发人员，提供了AIDL工具，简化了编写service的难度。下面以添加TestService这个服务为例， 
① 编写AIDL文件

package android.app;interface ITestService {    boolean enableWifi(boolean enabled);}
1
2
3
4
5
1
2
3
4
5

TestService的AIDL文件提供了一个接口，enableWifi()。

② 创建TestService服务 
TestService 服务需要继承ITestService.Stub类，这个类就是通过AIDL工具对①中的AIDL文件处理后产生的，

class TestService extends ITestService.Stub {    //实现接口    public boolean enableWifi(boolean enabled)    {        ......    } }
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

③ Context.java中添加service名字字符串

// Context.java中添加service名字字符串    public static final String TEST_SERVICE = "my_test";
1
2
1
2

④ 向ServiceManager中注册service 
java中大部分的系统service都是在SystemServer中去向service manager注册的，

//ServiceManager注册service// 在SystemServer.java中，模仿其他向ServiceManager添加service的方法            try {                TestService myService = new TestService(context);                ServiceManager.addService(Context.TEST_SERVICE, myService);            } catch (Throwable e) {                reportWtf("register my test service fail", e);            }
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

⑤创建服务对应的Manager 
对于每一个service而言，通常会有一个相关的Manager。 Managers提供API给app使用，成为SDK的一部分，是apps和remote service的中间桥梁。Manager中的接口和Service中的接口必须一一对应。

public class TestServiceManager{    private final ITestService mService;    private final Context mContext;    //构造函数中传入的service，其实就是BpTestService    TestServiceManager(Context context,ITestService service) {        mContext = context;        mService = service;    }       public boolean enableWifi(boolean enabled) {        try {            return mService.enableWifi(enabled);        } catch (RemoteException ex) {        }        return false;    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

到目前为止，我们只是完成了Service的注册，但是还没有使用，该如何使用？

⑥ contextImpl中注册Manager 
一旦我们实现了service和对应的Manager，需要有一种方法在app中调用他们。前面说过，Manager会成为SDK的一部分，供我们调用，那么Manager和Service是如何联系起来的？首先需要将我们的service和mangager注册到execution context，即contextImpl中，

        registerService(TEST_SERVICE, new ServiceFetcher() {                public Object createService(ContextImpl ctx) {                    IBinder b = ServiceManager.getService(TEST_SERVICE);                    //asInterface(BpBinder)后就是BpTestService                    ITestService service = ITestService.Stub.asInterface(b);                    //创建TestServiceManager，第二个参数为BpBpTestService                    return new TestServiceManager(ctx.getOuterContext(), service);                }});
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

registerService的第二个参数是一个ServiceFetcher对象，这里直接在调用时，新建了一个ServiceFetcher类，重写了createService方法。 
ContextImpl.java中的registerService()方法，其核心就是把servicename和ServiceFetcher对象放到一个Hash的键值对中。

    private static void registerService(String serviceName, ServiceFetcher fetcher) {        if (!(fetcher instanceof StaticServiceFetcher)) {            fetcher.mContextCacheIndex = sNextPerContextServiceCacheIndex++;        }        SYSTEM_SERVICE_MAP.put(serviceName, fetcher);    }
1
2
3
4
5
6
1
2
3
4
5
6

⑦ app如何使用service

那么app是如何调用的呢?

import android.app.TestServiceManager;import android.content.Context;TestServiceManager mTestServiceManager;mTestServiceManager=(TestServiceManager)context.getSystemService(Context.TEST_SERVICE);
1
2
3
4
5
6
1
2
3
4
5
6

然后直接调用TestServiceManager中的方法即可，其中的奥秘需要分析下getSystemService函数。 
ContextImpl.java中，

    @Override    public Object getSystemService(String name) {        ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);        //从ServiceFetcher 中获取service        return fetcher == null ? null : fetcher.getService(this);    }
1
2
3
4
5
6
1
2
3
4
5
6

getService()函数的核心就是上面重写的createService()函数，返回的就是TestServiceManager对象，所以通过context.getSystemService返回的是Manager对象。

    public Object getService(ContextImpl ctx) {            ArrayList<Object> cache = ctx.mServiceCache;            Object service;            synchronized (cache) {                if (cache.size() == 0) {                    // Initialize the cache vector on first access.                    // At this point sNextPerContextServiceCacheIndex                    // is the number of potential services that are                    // cached per-Context.                    for (int i = 0; i < sNextPerContextServiceCacheIndex; i++) {                        cache.add(null);                    }                } else {                    service = cache.get(mContextCacheIndex);                    if (service != null) {                        return service;                    }                }                //调用重载的createService函数，返回的就是TestServiceManager对象                service = createService(ctx);                cache.set(mContextCacheIndex, service);                return service;            }        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24