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<IHelloService>        {        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<ProcessState> proc(ProcessState::self());            /* 获得 BnServiceManager */            sp<IServiceManager> 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<ProcessState> proc(ProcessState::self());            /* 获得 BpServiceManager */            sp<IServiceManager> sm = defaultServiceManager();            /* 获得 根据hello名字 获取服务  */            sp<IBinder> binder =                sm->getService(String16("hello"));            if (binder == 0)            {                ALOGI("can't get hello service\n");                return -1;            }        /* Service肯定是 BpHelloService 指针？？        * interface_cast<IHelloService>(binder)  ->            IHelloService::asInterface(binder);（IMPLEMENT_META_INTERFACE宏中定义）            *【结果：在下面代码中分配一个BpHelloService实例指针】             */            sp<IHelloService> service =                interface_cast<IHelloService>(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);            }        }    }}

---