Android Binder通信学习
Android Binder通信学习。
以Hello为例说明设计的几个概念关系：
IhelloService.h : 提供给应用程序使用的类接口，注意是说明服务能够提供的哪些操作接口。
【注意】实际不只是定义一个接口类，还继承该接口并添加虚接口onTransact后定义了一个抽象类BnHelloService
class IHelloService: public IInterface
{
public:
DECLARE_META_INTERFACE(HelloService); /* 此宏声明了接口IHelloService::getInterfaceDescriptor 和 IHelloService::asInterface（这个接口可以生成一个Bp实例） */
virtual void sayhello(void) = 0;
virtual int sayhello_to(const char *name) = 0;
};
class BnHelloService: public BnInterface
{
public:
virtual status_t onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = 0);
virtual void sayhello(void);
virtual int sayhello_to(const char *name);
}; BnHelloService.cpp : 为了之后可以用BnHelloService实例化对象，需要对BnHelloService完成接口中定义的虚函数.【这个是实际去干活的服务，’别人‘只是给他发需求】
status_t BnHelloService::onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags)
{
switch (code) {
case HELLO_SVR_CMD_SAYHELLO:
sayhello();
break;
case HELLO_SVR_CMD_SAYHELLO_TO:
sayhello_to(name8.string());
break;
}
return NO_ERROR;
}
void BnHelloService::sayhello(void)
{
static int cnt = 0;
ALOGI("say hello : %d\n", ++cnt);
}
int BnHelloService::sayhello_to(const char *name)
{
static int cnt = 0;
ALOGI("say hello to %s : %d\n", name, ++cnt);
return cnt;
}BpHelloService.cpp : 继承抽象的接口类，并去实现虚函数，这样才能实例化对象，成为给服务发需求的‘别人’。【BpXXService负责给服务发需求，这么说服务并不是谁叫我干活就干，我只听Bp的】
class BpHelloService: public BpInterface<IHelloService>
{
public:
BpHelloService(const sp<IBinder>& impl)
: BpInterface<IHelloService>(impl)
{
}
void sayhello(void)
{
Parcel data, reply;
data.writeInt32(0);
data.writeString16(String16("IHelloService"));
remote()->transact(HELLO_SVR_CMD_SAYHELLO, data, &reply);
}
int sayhello_to(const char *name)
{
Parcel data, reply;
int exception;
data.writeInt32(0);
data.writeString16(String16("IHelloService"));
data.writeString16(String16(name));
remote()->transact(HELLO_SVR_CMD_SAYHELLO_TO, data, &reply);
exception = reply.readInt32();
if (exception)
return -1;
else
return reply.readInt32();
}
};
IMPLEMENT_META_INTERFACE(HelloService, "android.media.IHelloService");/* 此宏具体实现了接口IHelloService::getInterfaceDescriptor 和 IHelloService::asInterface */HelloServer.c : 实现的最底层接收请求的服务器，提供怎样的服务呢？只提供这个里面提供的服务BnHelloService！
int main(void)
{
/* 打开biner并mmap进内存 */
sp proc(ProcessState::self());
/* 获得 BnServiceManager */
sp sm = defaultServiceManager();
/* 添加服务 */
sm->addService(String16("hello"), new BnHelloService());
/* 循环体，不断获取服务并处理 */
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();
return 0;
} HelloClient.c : 最底层发请求的客户端，这才是满肚子需求的底层人民啊。
int main(int argc, char **argv)
{
int cnt;
/* 打开biner并mmap进内存 */
sp proc(ProcessState::self());
/* 获得 BpServiceManager */
sp sm = defaultServiceManager();
/* 获得 根据hello名字 获取服务 */
sp binder =
sm->getService(String16("hello"));
if (binder == 0)
{
ALOGI("can't get hello service\n");
return -1;
}
/* Service肯定是 BpHelloService 指针？？ * interface_cast(binder) -> IHelloService::asInterface(binder);（IMPLEMENT_META_INTERFACE宏中定义） *【结果：在下面代码中分配一个BpHelloService实例指针】 */
sp service =
interface_cast(binder);
/* 调用 BpHelloService提供的函数 */
service->sayhello();
ALOGI("client call sayhello");
return 0;
} 好了，下面来总结下：背景是世界的阶级斗争依然是如此的激烈，因此不管干啥我们都分等级，Binder服务也是如此,有需求只向上级反映，由上级出处理：
BpServiceManager <- HelloClient
|
\ /
BnServiceManager -> HelloServer
Binder的java实现。
IHelloService.aidl ： Android接口描述文件，只要用户定义自己需要提供的接口，然后放到frameworks/base/core/java/android/os下，并修改
frameworks/base/Android.mk 添加一行
core/java/android/os/IHelloService.aidl\
代码：
/** {@hide} */
interface IHelloService
{
void sayhello();
int sayhello_to(String name);
}IHelloService.java : 由aidl文件编译出来的接口类，里面除了用户自定义的接口外还包含一个 stub 的内部类。
【stub】：为屏蔽客户调用远程主机上的对象，必须提供某种方式来模拟本地对象,这种本地对象称为存根(stub),根负责接收本地方法调用,并将它们委派给各自的具体实现对象
代码只保留框架:
public interface IHelloService extends android.os.IInterface {
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements IHelloService {
private static final java.lang.String DESCRIPTOR = "IHelloService";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/** * Cast an IBinder object into an IHelloService interface, * generating a proxy if needed. */
public static IHelloService asInterface(android.os.IBinder obj)
{
return new IGoodbyeService.Stub.Proxy(obj); /* 客户端获取服务后，需要转化为proxy才能进行最终的接口调用 */
}
@Override public android.os.IBinder asBinder()
{
return this;
}
/* 实际处理需求的服务端，类似于C++ binder中的BnXxService功能，用于接收需求并实际出执行需求任务 */
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_saygoodbye:
{
data.enforceInterface(DESCRIPTOR);
this.saygoodbye(); /* 调用本stub中定义的接口函数 */
reply.writeNoException();
return true;
}
case TRANSACTION_saygoodbye_to:
{
data.enforceInterface(DESCRIPTOR);
java.lang.String _arg0;
_arg0 = data.readString();
int _result = this.saygoodbye_to(_arg0); /* 调用本stub中定义的接口函数 */
reply.writeNoException();
reply.writeInt(_result);
return true;
}
}
}
private static class Proxy implements IGoodbyeService /* 代理类，类似于C++ binder中的BpXxService，用于接收需求并封装数据发生需求给服务端 */ {
mRemote.transact(Stub.TRANSACTION_saygoodbye_to, _data, _reply, 0);
}
}
public void sayhello() throws android.os.RemoteException;
public int sayhello_to(java.lang.String name) throws android.os.RemoteException;
}Helloservice.java : 服务器代码，非常简单，继承IHelloService.Stub的接口，并实现最终干活的代码。
public class HelloService extends IHelloService.Stub {
private static final String TAG = "HelloService";
private int cnt1 = 0;
private int cnt2 = 0;
public void sayhello() throws android.os.RemoteException {
cnt1++;
Slog.i(TAG, "sayhello : cnt = "+cnt1);
}
public int sayhello_to(java.lang.String name) throws android.os.RemoteException {
cnt2++;
Slog.i(TAG, "sayhello_to "+name+" : cnt = "+cnt2);
return cnt2;
}
}TestServer.java : 用户这边提供服务的代码，目的就是注册一个服务
public class TestServer {
private static final String TAG = "TestServer";
public static void main(String args[])
{
/* add Service */
Slog.i(TAG, "add hello service");
ServiceManager.addService("hello", new HelloService()); /* 此处添加负责服务器任务的类 */
while (true)
{
try {
Thread.sleep(100);
} catch (Exception e){}
}
}
}TestClient.java : 最底层发需求的用户代码。
public class TestClient {
private static final String TAG = "TestClient";
public static void main(String args[])
{
/* 1. getService */
IBinder binder = ServiceManager.getService("hello");
if (binder == null)
{
System.out.println("can not get hello service");
Slog.i(TAG, "can not get hello service");
return;
}
IHelloService svr = IHelloService.Stub.asInterface(binder); /* 得到接口的代理 */
if (args.length == 1)
{
try {
svr.sayhello();
System.out.println("call sayhello");
Slog.i(TAG, "call sayhello");
} catch (Exception e) {}
}
else
{
try {
int cnt = svr.sayhello_to(args[1]);
System.out.println("call sayhello_to "+args[1]+" : cnt = "+cnt);
Slog.i(TAG, "call sayhello_to "+args[1]+" : cnt = "+cnt);
} catch (Exception e) {
System.out.println("call sayhello_to , err :"+e);
Slog.i(TAG, "call sayhello_to , err : "+e);
}
}
}
}