Native Service的实现

步骤1 创建一个继承于 IInterface的基类
  参考代码如下
在头文件中：
class IMyTestBase: public IInterface
{
public:
    DECLARE_META_INTERFACE(MyTestBase);
virtual int            Test( unsigned int input,unsigned int *  output ) = 0; 
};
说明：
DECLARE_META_INTERFACE 定义在frameworks\native\include\binder\IInterface.h中，
#define DECLARE_META_INTERFACE(INTERFACE)                               \
    static const android::String16 descriptor;                          \
    static android::sp<I##INTERFACE> asInterface(                       \
            const android::sp<android::IBinder>& obj);                  \
    virtual const android::String16& getInterfaceDescriptor() const;    \
    I##INTERFACE();                                                     \
    virtual ~I##INTERFACE();    
这个宏实际上就是定义了这个类的构造函数和析构函数。定义了一个descriptor的字符串和getInterfaceDescriptor和asInterface的方法，descriptor是service的标示，用于BP和BN通讯的唯一标识。


DECLARE_META_INTERFACE的参数一定要和类名I后面的名称是对应的。


IMyTestBase类中的Test就是我们要提供的接口，也就是在其他的应用中通过Remote端要调用的接口。
在C文件中：
IMPLEMENT_META_INTERFACE(MyTestBase, "MyTestBase.name");
说明：
IMPLEMENT_META_INTERFACE也是定义在frameworks\native\include\binder\IInterface.h中
#define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)                       \
    const android::String16 I##INTERFACE::descriptor(NAME);             \
    const android::String16&                                            \
            I##INTERFACE::getInterfaceDescriptor() const {              \
        return I##INTERFACE::descriptor;                                \
    }                                                                   \
    android::sp<I##INTERFACE> I##INTERFACE::asInterface(                \
            const android::sp<android::IBinder>& obj)                   \
    {                                                                   \
        android::sp<I##INTERFACE> intr;                                 \
        if (obj != NULL) {                                              \
            intr = static_cast<I##INTERFACE*>(                          \
                obj->queryLocalInterface(                               \
                        I##INTERFACE::descriptor).get());               \
            if (intr == NULL) {                                         \
                intr = new Bp##INTERFACE(obj);                          \
            }                                                           \
        }                                                               \
        return intr;                                                    \
    }                                                                   \
    I##INTERFACE::I##INTERFACE() { }                                    \
    I##INTERFACE::~I##INTERFACE() { }      
通过上面的定义可以看出，这个宏实际上就是实现了IMyTestBase类。




步骤2 定义一个本地的服务BnXXX，继承于BnInterface<IXXXService>，并实现OnTransact()函数。然后实现一个service，继承于BnXXX，在该类实现本服务要提供的接口。另外实现一个静态函数static  int           instantiate()在这个函数里调用addService添加本服务。
    下面是示例代码：
1 实现BnMyTestBase
    在头文件中定义一个BnMyTestBase


class BnMyTestBase: public BnInterface<IMyTestBase>
{
public:
    virtual status_t    onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags = 0);
                          
};
在C文件中实现该类
status_t BnMyTestBase::onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    switch(code) 
    {
        case TEST_CODE: 
        {
         
            CHECK_INTERFACE(IMyTestBase, data, reply);
            
            unsigned  int input = (unsigned int )data.readInt32();
            unsigned  int output ;  
            int ret = Test(input, &output );
            reply->writeInt32(output);
            reply->writeInt32(ret); 
            return NO_ERROR;
        } break;
          
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}


2 实现 MyTestService
在头文件中：
class MyTestService: public BnMyTestBase
{
public:
    static  int           instantiate();
    virtual int           Test( unsigned int input,unsigned int *  output );
 
MyTestService( void );
~MyTestService( void );
 
};
在C文件中


int MyTestService::instantiate() 
{

    status_t ret = defaultServiceManager()->addService(
            String16("MYTEST"), new MyTestService());
    if(ret == NO_ERROR)
    {
    ALOGD("addService MyTestService sucess" );
    return 0;
    }
    else
    {
    ALOGD("addService MyTestService failed ret=0x%x" ,ret );
    return -1;
    }
     
}


MyTestService::MyTestService( )
{
ALOGD("MyTestService init" );
}
      
int MyTestService::Test( unsigned int input,unsigned int *  output )
{
ALOGD("test input=%d" ,input);
*output=0xaa;
return 0;
}
   
MyTestService::~MyTestService( void )
{
ALOGD("MyTestService deinit" ); 
}


步骤3 定义一个remote sevice BpXXX,继承BpInterface<IXXXService>
示例代码如下：
在头文件中
class BpMyTestBase: public BpInterface<IMyTestBase>
{
  
public:
    BpMyTestBase(const sp<IBinder>& impl)
        : BpInterface<IMyTestBase>(impl)
    {
    }
virtual int Test( unsigned int input,unsigned int *  output )
{
Parcel data, reply;
data.writeInterfaceToken(IMyTestBase::getInterfaceDescriptor());
data.writeInt32(input); 
remote()->transact(TEST_CODE, data, &reply); 
*output = reply.readInt32();
return  (reply.readInt32());
}
};
完成这3步，我们的服务就定义好了。
说明：
1 我们定义的服务一定要用namespace android 括起来，否则编译时会报错。
2 在BN和BP之间通过Parcel 传递参数的时候，write和read的顺序是一样的。这里不是堆栈，不存在后进先出。
3 在MyTestService::instantiate函数中addService的第一个参数是添加的服务的名字，这个名字是唯一的，我们在应用中要使用这个服务，就是通过这个名字来寻找的。


步骤4 ：启动这个服务
我们定义一个可执行程序，来调用instantiate，添加服务。然后再Init.rc文件中启动这个可执行程序。
参考代码如下：
using namespace android;
 
int main(int argc, char** argv)
{
 
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm = defaultServiceManager();
    
    if(MyTestService::instantiate()<0)
    {
    exit(0);
    } 
    
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
   
    return 0;
} 
编译下载好后重新启动机器，在adb shell界面中输入service list命令，就可以看到我们定义的服务了。
如果服务没有启动，可能是权限问题，可以参考《android  init.rc文件语法详解》添加selinux的权限。


步骤5：在应用中调用这个服务
参考代码如下
sp<IMyTestBase>   sService ;


const sp<IMyTestBase>& getService( )
{
    int icount =0;
 
    if (sService.get() == 0) 
    {
     
        sp<IServiceManager> sm = defaultServiceManager();
         
        sp<IBinder> binder;
         
         
            binder = sm->getService(String16("MYTEST"));
            if (binder != 0) 
            {
             
            sService = interface_cast<IMyTestBase>(binder);   
                 
             
            }
            

    } 
     
    return sService;
}
调用服务的接口
const sp<IMyTestBase>& service(getService());
unsigned int input=0,output; 
service->Test(input,&output); 


OK ！大功告成！
不过如果在android5.0之后，可能调用会失败，因为我们还没有定义selinux的权限。
下面介绍下如何添加权限。
假设我们启动这个服务的应用是/system/bin/Start__server这个程序。
首先我们要在创建一个Start__server.te。在里面定义
type Start__server, domain;
type Start__server_exec, exec_type, file_type;
init_daemon_domain(Start__server)


在file_contexts文件里面添加
/system/bin/Start__server          u:object_r:Start__server_exec:s0


在service_contexts文件中添加
MYTEST u:object_r:system_server_service:s0 
注意这里的MYTEST就是我们调用addService的第一个参数，这里要完全对应。


然后重新编译运行，我们会看到logcat的调试信息由很多下面的错误
avc:  denied  { add } for service=MYTEST scontext=u:r:Start__server:s0 tcontext=u:object_r:system_server_service:s0 tclass=service_manager
avc: denied { call } for scontext=u:r:untrusted_app:s0 tcontext=u:r:Start__server:s0 tclass=binder permissive=0avc: denied { search } for name="150" dev="proc" ino=4877 scontext=u:r:servicemanager:s0 tcontext=u:r:Start__server:s0 tclass=dir permissive=0
等等很多错误信息。
我们可以参考《android  init.rc文件语法详解》介绍的方法在Start__server.te中一条条添加相应的权限。


另外还有更简洁的办法，google已经定义好了宏，我们直接拿来用就好了。
我们只要简单的在Start__server.te添加下面的语句
allow Start__server system_server_service:service_manager add;
binder_use(Start__server)
binder_call(appdomain,Start__server)


说明binder_call第一个参数是允许使用这个服务的应用的类型。
appdomain则说明说有的应用都可以使用。
我们可以根据需要制定其他的类型例如platform_app、untrusted_app
也可以指定某一个应用程序例如shell、adbd、mediaserver等等。