binder 订阅
BINDER致力于为都市男性打造一系列商务休闲皮具,无论大学生、白领,还是主管都必须的上品皮具。融汇商务皮具与休闲包理念,打破了以正装皮具为主的局面;并以互联网直销依托“大牌品质、低廉价格和完美售后”拉近受众群的距离。当下都市男性在严谨的工作和快节奏的生活氛围中,更加注重休闲、舒适、随意的生活品味。 展开全文
BINDER致力于为都市男性打造一系列商务休闲皮具,无论大学生、白领,还是主管都必须的上品皮具。融汇商务皮具与休闲包理念,打破了以正装皮具为主的局面;并以互联网直销依托“大牌品质、低廉价格和完美售后”拉近受众群的距离。当下都市男性在严谨的工作和快节奏的生活氛围中,更加注重休闲、舒适、随意的生活品味。
信息
品牌文化
品牌树形象,品质得人心
主要产品
服装、皮具、皮鞋等
品牌创立
男性把皮具当成一种品味风格
外文名
BINDER
BINDER品牌创立
当今,男性已经把皮具当成是生活中的点缀品,它代表的是一种品味,一种风格。BINDER为此而来。在国外男士皮具已经超脱了消费品的简单意义,如同女人的香水,携带的是一种文化,传达的是一种生活方式。
收起全文
精华内容
下载资源
问答
  • Binder

    2019-07-09 09:56:55
    binder是一种架构,提供了服务端接口、Binder驱动、客户端接口三个模块。 binder对象一旦创建,内部会启动一个隐藏线程,该线程会接受binder驱动发来的消息,收到消息后执行binder中的onTransact方法,按照其中参数...

    binder是一种架构,提供了服务端接口、Binder驱动、客户端接口三个模块。

    binder对象一旦创建,内部会启动一个隐藏线程,该线程会接受binder驱动发来的消息,收到消息后执行binder中的onTransact方法,按照其中参数执行不同服务代码。实现Binder必须重载onTransact方法。

    重载onTransact主要是把onTransact函数的参数转换为服务函数,参数来源是客户端调用transact函数时输入的,

    Binder驱动中户自动穿一个mRemote对象,他也是Binder类。客户端访问远程服务都是通过mRemote。

     

    展开全文
  • binder

    2015-06-05 16:43:18
    把之前看binder留下的记录贴在此,以作备忘. 1 Binder 1.1代码位置 system/extras/tests/binder frameworks/native/libs/binder frameworks/native/include/private/binder frameworks/native/include...

    把之前看binder留下的记录贴在此,以作备忘.


    1      Binder

    1.1代码位置

    system/extras/tests/binder

    frameworks/native/libs/binder

    frameworks/native/include/private/binder

    frameworks/native/include/binder

    kernel_imx/drivers/staging/android/binder.c

    1.2网络摘录

    http://blog.csdn.net/luoshengyang/article/details/6618363

    Binder是一种进程间通信机制,它是一种类似于COM和CORBA分布式组件架构,通俗一点,其实是提供远程过程调用(RPC)功能。从英文字面上意思看,Binder具有粘结剂的意思,那么它把什么东西粘结在一起呢?在Android系统的Binder机制中,由一系统组件组成,分别是Client、Server、Service Manager和Binder驱动程序,其中Client、Server和ServiceManager运行在用户空间,Binder驱动程序运行内核空间。Binder就是一种把这四个组件粘合在一起的粘结剂了,其中,核心组件便是Binder驱动程序了,Service Manager提供了辅助管理的功能,Client和Server正是在Binder驱动和Service Manager提供的基础设施上,进行Client-Server之间的通信。Service Manager和Binder驱动已经在Android平台中实现好,开发者只要按照规范实现自己的Client和Server组件就可以了。


     

    android在framework层增加自己的service---仿照GPS

    http://www.2cto.com/kf/201402/280008.html

     

    1.3书籍摘录

    《android框架揭秘》







    《Android系统原理及开发要点详解》

    P91

     

     

    P97


    1.4分析


    展开全文
  • binder

    2011-04-22 16:33:00
    第一部分 Binder的组成 1.1 驱动程序部分驱动程序的部分在以下的文件夹中: Java 代码 kernel/include/linux/binder.h kernel/drivers/android/binder.c kernel/include/linux/binder.h kernel/drivers...
    第一部分 Binder的组成
    1.1 驱动程序部分驱动程序的部分在以下的文件夹中:
    Java 代码
    1. kernel/include/linux/binder.h
    2. kernel/drivers/android/binder.c
    kernel/include/linux/binder.h
    kernel/drivers/android/binder.c
    

    binder驱动程序是一个miscdevice,主设备号为10,此设备号使用动态获得(MISC_DYNAMIC_MINOR),其设备的节点为:
    /dev/binder
    binder驱动程序会在proc文件系统中建立自己的信息,其文件夹为/proc/binder,其中包含如下内容:
    proc目录:调用Binder各个进程的内容
    state文件:使用函数binder_read_proc_state
    stats文件:使用函数binder_read_proc_stats
    transactions文件:使用函数binder_read_proc_transactions
    transaction_log文件:使用函数binder_read_proc_transaction_log,其参数为 binder_transaction_log (类型为struct binder_transaction_log)
    failed_transaction_log文件:使用函数binder_read_proc_transaction_log 其参数为
    binder_transaction_log_failed (类型为struct binder_transaction_log)

    在binder文件被打开后,其私有数据(private_data)的类型:
    struct binder_proc
    在这个数据结构中,主要包含了当前进程、进程ID、内存映射信息、Binder的统计信息和线程信息等。
    在用户空间对Binder驱动程序进行控制主要使用的接口是mmap、poll和ioctl,ioctl主要使用的ID为:
    Java 代码
    1. #define BINDER_WRITE_READ _IOWR('b', 1, struct binder_write_read)
    2. #define BINDER_SET_IDLE_TIMEOUT _IOW('b', 3, int64_t)
    3. #define BINDER_SET_MAX_THREADS _IOW('b', 5, size_t)
    4. #define BINDER_SET_IDLE_PRIORITY _IOW('b', 6, int)
    5. #define BINDER_SET_CONTEXT_MGR _IOW('b', 7, int)
    6. #define BINDER_THREAD_EXIT _IOW('b', 8, int)
    7. #define BINDER_VERSION _IOWR('b', 9, struct binder_version)
    #define BINDER_WRITE_READ        _IOWR('b', 1, struct binder_write_read)
    #define BINDER_SET_IDLE_TIMEOUT  _IOW('b', 3, int64_t)
    #define BINDER_SET_MAX_THREADS   _IOW('b', 5, size_t)
    #define BINDER_SET_IDLE_PRIORITY _IOW('b', 6, int)
    #define BINDER_SET_CONTEXT_MGR   _IOW('b', 7, int)
    #define BINDER_THREAD_EXIT       _IOW('b', 8, int)
    #define BINDER_VERSION           _IOWR('b', 9, struct binder_version)

    BR_XXX等宏为BinderDriverReturnProtocol,表示Binder驱动返回协议。
    BC_XXX等宏为BinderDriverCommandProtocol,表示Binder驱动命令协议。
    binder_thread是Binder驱动程序中使用的另外一个重要的数据结构,数据结构的定义如下所示:
    Java 代码
    1. struct binder_thread {
    2. struct binder_proc *proc;
    3. struct rb_node rb_node;
    4. int pid;
    5. int looper;
    6. struct binder_transaction *transaction_stack;
    7. struct list_head todo;
    8. uint32_t return_error;
    9. uint32_t return_error2;
    10. wait_queue_head_t wait;
    11. struct binder_stats stats;
    12. };
    struct binder_thread {
          struct binder_proc *proc;
         struct rb_node rb_node;
         int pid;
         int looper;
         struct binder_transaction *transaction_stack;
         struct list_head todo;
         uint32_t return_error;
         uint32_t return_error2;
         wait_queue_head_t wait;
         struct binder_stats stats;
    };

    binder_thread 的各个成员信息是从rb_node中得出。
    BINDER_WRITE_READ是最重要的ioctl,它使用一个数据结构binder_write_read定义读写的数据。
    Java 代码
    1. struct binder_write_read {
    2. signed long write_size;
    3. signed long write_consumed;
    4. unsigned long write_buffer;
    5. signed long read_size;
    6. signed long read_consumed;
    7. unsigned long read_buffer;
    8. };
    struct binder_write_read {
         signed long write_size;
         signed long write_consumed;
         unsigned long write_buffer;
         signed long read_size;
         signed long read_consumed;
         unsigned long read_buffer;
    };

    1.2 servicemanager部分 servicemanager是一个守护进程,用于这个进程的和/dev/binder通讯,从而达到管理系统中各个服务的作用。
    可执行程序的路径:
    /system/bin/servicemanager
    开源版本文件的路径:
    Java 代码
    1. frameworks/base/cmds/servicemanager/binder.h
    2. frameworks/base/cmds/servicemanager/binder.c
    3. frameworks/base/cmds/servicemanager/service_manager.c
    frameworks/base/cmds/servicemanager/binder.h
    frameworks/base/cmds/servicemanager/binder.c
    frameworks/base/cmds/servicemanager/service_manager.c

    程序执行的流程:

    open():打开binder驱动

    mmap():映射一个128*1024字节的内存

    ioctl(BINDER_SET_CONTEXT_MGR):设置上下文为mgr
    进入主循环binder_loop()
    ioctl(BINDER_WRITE_READ),读取
    binder_parse()进入binder处理过程循环处理
    binder_parse()的处理,调用返回值:
    当处理BR_TRANSACTION的时候,调用svcmgr_handler()处理增加服务、检查服务等工作。各种服务存放在一个链表(svclist)中。其中调用binder_等开头的函数,又会调用ioctl的各种命令。
    处理BR_REPLY的时候,填充binder_io类型的数据结
    1.3 binder的库的部分
    binder相关的文件作为Android的uitls库的一部分,这个库编译后的名称为libutils.so,是Android系统中的一个公共库。
    主要文件的路径如下所示:
    Java 代码
    1. frameworks/base/include/utils/*
    2. frameworks/base/libs/utils/*
    frameworks/base/include/utils/*
    frameworks/base/libs/utils/*


    主要的类为:
    RefBase.h :
    引用计数,定义类RefBase。
    Parcel.h :
    为在IPC中传输的数据定义容器,定义类Parcel
    IBinder.h:
    Binder对象的抽象接口, 定义类IBinder
    Binder.h:
    Binder对象的基本功能, 定义类Binder和BpRefBase
    BpBinder.h:
    BpBinder的功能,定义类BpBinder
    IInterface.h:
    为抽象经过Binder的接口定义通用类,
    定义类IInterface,类模板BnInterface,类模板BpInterface
    ProcessState.h
    表示进程状态的类,定义类ProcessState
    IPCThreadState.h
    表示IPC线程的状态,定义类IPCThreadState
    各个类之间的关系如下所示:



    在IInterface.h中定义的BnInterface和BpInterface是两个重要的模版,这是为各种程序中使用的。
    BnInterface模版的定义如下所示:
    Java 代码
    1. template
    2. class BnInterface : public INTERFACE, public BBinder
    3. {
    4. public:
    5. virtual sp queryLocalInterface(const String16& _descriptor);
    6. virtual String16 getInterfaceDescriptor() const;
    7. protected:
    8. virtual IBinder* onAsBinder();
    9. };
    10. BnInterface 模版的定义如下所示:
    11. template
    12. class BpInterface : public INTERFACE, public BpRefBase
    13. {
    14. public:
    15. BpInterface(const sp& remote);
    16. protected:
    17. virtual IBinder* onAsBinder();
    18. };
    template
    class BnInterface : public INTERFACE, public BBinder
    {
    public:
        virtual sp  queryLocalInterface(const String16& _descriptor);
        virtual String16        getInterfaceDescriptor() const;
    protected:
        virtual IBinder*        onAsBinder();
    };
         BnInterface模版的定义如下所示:
    template
    class BpInterface : public INTERFACE, public BpRefBase
    {
    public:
                                BpInterface(const sp& remote);
    protected:
        virtual IBinder*    onAsBinder();
    };

    这两个模版在使用的时候,起到得作用实际上都是双继承:使用者定义一个接口INTERFACE,然后使用BnInterface和BpInterface 两个模版结合自己的接口,构建自己的BnXXX和BpXXX两个类。
    DECLARE_META_INTERFACE和IMPLEMENT_META_INTERFACE两个宏用于帮助BpXXX类的实现:
    Java 代码
    1. #define DECLARE_META_INTERFACE(INTERFACE) /
    2. static const String16 descriptor; /
    3. static sp asInterface(const sp& obj); /
    4. virtual String16 getInterfaceDescriptor() const; /
    5. #define IMPLEMENT_META_INTERFACE(INTERFACE, NAME) /
    6. const String16 I##INTERFACE::descriptor(NAME); /
    7. String16 I##INTERFACE::getInterfaceDescriptor() const { /
    8. return I##INTERFACE::descriptor; /
    9. } /
    10. sp I##INTERFACE::asInterface(const sp& obj) /
    11. { /
    12. sp intr; /
    13. if (obj != NULL) { /
    14. intr = static_cast( /
    15. obj->queryLocalInterface( /
    16. I##INTERFACE::descriptor).get()); /
    17. if (intr == NULL) { /
    18. intr = new Bp##INTERFACE(obj); /
    19. } /
    20. } /
    21. return intr; /
    22. }
    #define DECLARE_META_INTERFACE(INTERFACE)                               /
        static const String16 descriptor;                                   /
        static sp asInterface(const sp& obj);        /
        virtual String16 getInterfaceDescriptor() const;                    /
    #define IMPLEMENT_META_INTERFACE(INTERFACE, NAME)                       /
        const String16 I##INTERFACE::descriptor(NAME);                      /
        String16 I##INTERFACE::getInterfaceDescriptor() const {             /
            return I##INTERFACE::descriptor;                                /
        }                                                                   /
        sp I##INTERFACE::asInterface(const sp& obj)  /
        {                                                                   /
            sp intr;                                          /
            if (obj != NULL) {                                              /
                intr = static_cast(                          /
                    obj->queryLocalInterface(                               /
                            I##INTERFACE::descriptor).get());               /
                if (intr == NULL) {                                         /
                    intr = new Bp##INTERFACE(obj);                          /
                }                                                           /
            }                                                               /
            return intr;                                                    /
        }
    


    在定义自己的类的时候,只需要使用DECLARE_META_INTERFACE和IMPLEMENT_META_INTERFACE两个接口,并
    结合类的名称,就可以实现BpInterface中的asInterface()和getInterfaceDescriptor()两个函数。
    第二部分 Binder的运作
      2.1 Binder的工作机制
    Service Manager是一个守护进程,它负责启动各个进程之间的服务,对于相关的两个需要通讯的进程,它们通过调用libutil.so库实现通讯,而真正通讯的机制,是内核空间中的一块共享内存。



      2.2 从应  用程序的角度看Binder

      从应用程序的角度看Binder一共有三个方面:
      Native 本地:例如BnABC,这是一个需要被继承和实现的类。
      Proxy 代理:例如BpABC,这是一个在接口框架中被实现,但是在接口中没有体现的类。
      客户端:例如客户端得到一个接口ABC,在调用的时候实际上被调用的是BpABC



    本地功能(Bn)部分做的:
    实现BnABC:: BnTransact()
    注册服务:IServiceManager::AddService
    代理部分(Bp)做的:
    实现几个功能函数,调用BpABC::remote()->transact()
    客户端做的:
    获得ABC接口,然后调用接口(实际上调用了BpABC,继而通过IPC调用了BnABC,然后调用了具体的功能)

    在程序的实现过程中BnABC和BpABC是双继承了接口ABC。一般来说BpABC是一个实现类,这个实现类不需要在接口中体现,它实际上负责的只是通讯功能,不执行具体的功能;BnABC则是一个接口类,需要一个真正工作的类来继承、实现它,这个类才是真正执行具体功能的类。
    在客户端中,从ISeriviceManager中获得一个ABC的接口,客户端调用这个接口,实际上是在调用BpABC,而BpABC又通过 Binder的IPC机制和BnABC通讯,BnABC的实现类在后面执行。
      事实上,
    服务器
    的具体实现和客户端是两个不同的进程,如果不考虑进程间通讯的过程,从调用者的角度,似乎客户端在直接调用另外一个进程间的函数——当然这个函数必须是接口ABC中定义的。
      2.3 ISericeManager的作用

    ISericeManager涉及的两个文件是ISericeManager.h和ISericeManager.cpp。这两个文件基本上是
    ISericeManager。ISericeManager是系统最先被启动的服务。非常值得注意的是:ISericeManager本地功能并没有使
    现,它实际上由ServiceManager守护进程执行,而用户程序通过调用BpServiceManager来获得其他的服务。
    在ISericeManager.h中定义了一个接口,用于得到默认的ISericeManager:
    sp defaultServiceManager();
    这时得到的ISericeManager实际上是一个全局的ISericeManager。
    第三部分 程序中Binder的具体实现
      3.1 一个利用接口的具体实现
    PermissionController也是libutils中定义的一个有关权限控制的接口,它一共包含两个文件:IPermissionController.h和IPermissionController.cpp这个结构在所有类的实现中都是类似的。
    头文件IPermissionController.h的主要内容是定义IPermissionController接口和类 BnPermissionController:
    Java 代码
    1. class IPermissionController : public IInterface
    2. {
    3. public:
    4. DECLARE_META_INTERFACE(PermissionController);
    5. virtual bool checkPermission(const String16& permission,int32_t pid, int32_t uid) = 0;
    6. enum {
    7. CHECK_PERMISSION_TRANSACTION = IBinder::FIRST_CALL_TRANSACTION
    8. };
    9. };
    10. class BnPermissionController : public BnInterface
    11. {
    12. public:
    13. virtual status_t onTransact( uint32_t code,
    14. const Parcel& data,
    15. Parcel* reply,
    16. uint32_t flags = 0);
    17. };
    class IPermissionController : public IInterface
    {
    public:
        DECLARE_META_INTERFACE(PermissionController);
        virtual bool   checkPermission(const String16& permission,int32_t pid, int32_t uid) = 0;
        enum {
            CHECK_PERMISSION_TRANSACTION = IBinder::FIRST_CALL_TRANSACTION
        };
    };
    class BnPermissionController : public BnInterface
    {
    public:
        virtual status_t    onTransact( uint32_t code,
                                        const Parcel& data,
                                        Parcel* reply,
                                        uint32_t flags = 0);
    };

    IPermissionController是一个接口类,只有checkPermission()一个纯虚函数。


    BnPermissionController继承了以BnPermissionController实例化模版类BnInterface。因
    此,BnPermissionController,事实上BnPermissionController双继承了BBinder和
    IPermissionController。
    实现文件IPermissionController.cpp中,首先实现了一个BpPermissionController。
    Java 代码
    1. class BpPermissionController : public BpInterface
    2. {
    3. public:
    4. BpPermissionController(const sp& impl)
    5. : BpInterface(impl)
    6. {
    7. }
    8. virtual bool checkPermission(const String16& permission, int32_t pid, int32_t uid)
    9. {
    10. Parcel data, reply;
    11. data.writeInterfaceToken(IPermissionController::
    12. getInterfaceDescriptor());
    13. data.writeString16(permission);
    14. data.writeInt32(pid);
    15. data.writeInt32(uid);
    16. remote()->transact(CHECK_PERMISSION_TRANSACTION, data, &reply);
    17. if (reply.readInt32() != 0) return 0;
    18. return reply.readInt32() != 0;
    19. }
    20. };
    class BpPermissionController : public BpInterface
    {
    public:
        BpPermissionController(const sp& impl)
            : BpInterface(impl)
        {
        }
        virtual bool checkPermission(const String16& permission, int32_t pid, int32_t uid)
        {
            Parcel data, reply;
            data.writeInterfaceToken(IPermissionController::
                                           getInterfaceDescriptor());
            data.writeString16(permission);
            data.writeInt32(pid);
            data.writeInt32(uid);
            remote()->transact(CHECK_PERMISSION_TRANSACTION, data, &reply);
            if (reply.readInt32() != 0) return 0;
            return reply.readInt32() != 0;
        }
    };

    IMPLEMENT_META_INTERFACE(PermissionController, "android.os.IPermissionController");


    BpPermissionController继承了BpInterface,它本身是一个
    已经实现的类,而且并没有在接口中体现。这个类按照格式写就可以,在实现checkPermission()函数的过程中,使用Parcel作为传输数据
    的容器,传输中时候transact()函数,其参数需要包含枚举值CHECK_PERMISSION_TRANSACTION。
    IMPLEMENT_META_INTERFACE用于扶助生成。
    BnPermissionController中实现的onTransact()函数如下所示:
    Java 代码
    1. status_t BnPermissionController:: BnTransact(
    2. uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
    3. {
    4. switch(code) {
    5. case CHECK_PERMISSION_TRANSACTION: {
    6. CHECK_INTERFACE(IPermissionController, data, reply);
    7. String16 permission = data.readString16();
    8. int32_t pid = data.readInt32();
    9. int32_t uid = data.readInt32();
    10. bool res = checkPermission(permission, pid, uid);
    11. reply->writeInt32(0);
    12. reply->writeInt32(res ? 1 : 0);
    13. return NO_ERROR;
    14. } break;
    15. default:
    16. return BBinder:: BnTransact(code, data, reply, flags);
    17. }
    18. }
    status_t BnPermissionController:: BnTransact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
    {
        switch(code) {
            case CHECK_PERMISSION_TRANSACTION: {
                CHECK_INTERFACE(IPermissionController, data, reply);
                String16 permission = data.readString16();
                int32_t pid = data.readInt32();
                int32_t uid = data.readInt32();
                bool res = checkPermission(permission, pid, uid);
                reply->writeInt32(0);
                reply->writeInt32(res ? 1 : 0);
                return NO_ERROR;
            } break;
            default:
                return BBinder:: BnTransact(code, data, reply, flags);
        }
    }


    在onTransact()函数中根据枚举值判断数据使用的方式。注意,由于BnPermissionController也是继承了类
    IPermissionController,但是纯虚函数checkPermission()依然没有实现。因此这个
    BnPermissionController类并不能实例化,它其实也还是一个接口,需要一个实现类来继承它,那才是实现具体功能的类。
      3.2 BnABC的实现
    本地服务启动后将形成一个守护进程,具体的本地服务是由一个实现类继承BnABC来实现的,这个服务的名称通常叫做ABC。
    在其中,通常包含了一个instantiate()函数,这个函数一般按照如下的方式实现:
    void ABC::instantiate() {
    defaultServiceManager()->addService(
    String16("XXX.ABC"), new ABC ());
    }
    按照这种方式,通过调用defaultServiceManager()函数,将增加一个名为"XXX.ABC"的服务。
    在这个defaultServiceManager()函数中调用了:
    ProcessState::self()->getContextObject(NULL));
    IPCThreadState* ipc = IPCThreadState::self();
    IPCThreadState::talkWithDriver()
    在ProcessState 类建立的过程中调用open_driver()打开
    驱动
    程序,在talkWithDriver()的执行过程中。
      3.3 BpABC调用的实现
    BpABC调用的过程主要通过mRemote()->transact() 来传输数据,mRemote()是BpRefBase的成员,它是一个IBinder。这个调用过程如下所示:
    Java 代码
    1. mRemote()->transact()
    2. Process::self()
    3. IPCThreadState::self()->transact()
    4. writeTransactionData()
    5. waitForResponse()
    6. talkWithDriver()
    7. ioctl(fd, BINDER_WRITE_READ, &bwr)
    展开全文
  • Android跨进程通信:图文详解 Binder机制 原理

    万次阅读 多人点赞 2017-06-22 10:31:24
    虽然 网上有很多介绍 Binder的文章,可是存在一些问题:浅显的讨论Binder机制 或 一味讲解 Binder源码、逻辑不清楚,最终导致的是读者们还是无法形成一个完整的Binder概念 本文采用 清晰的图文讲解方式,按照 大角度...

    前言

    • 如果你接触过 跨进程通信 (IPC),那么你对Binder一定不陌生
    • 虽然 网上有很多介绍 Binder的文章,可是存在一些问题:浅显的讨论Binder机制 或 一味讲解 Binder源码、逻辑不清楚,最终导致的是读者们还是无法形成一个完整的Binder概念
    • 本文采用 清晰的图文讲解方式,按照 大角度 -> 小角度 去分析Binder,即:
      1. 先从 机制、模型的角度 去分析 整个Binder跨进程通信机制的模型
      2. 再 从源码实现角度,分析 BinderAndroid中的具体实现

    从而全方位地介绍 Binder,希望你们会喜欢。

    请尽量在PC端而不要在移动端看,否则图片可能看不清。


    目录

    目录


    1. Binder到底是什么?

    • 中文即 粘合剂,意思为粘合了两个不同的进程

    • 网上有很多对Binder的定义,但都说不清楚:Binder是跨进程通信方式、它实现了IBinder接口,是连接 ServiceManager的桥梁blabla,估计大家都看晕了,没法很好的理解

    • 我认为:对于Binder的定义,在不同场景下其定义不同

    定义

    在本文的讲解中,按照 大角度 -> 小角度 去分析Binder,即:

    • 先从 机制、模型的角度 去分析 整个Binder跨进程通信机制的模型

    其中,会详细分析模型组成中的 Binder驱动

    • 再 从源码实现角度,分析 BinderAndroid中的具体实现

    从而全方位地介绍 Binder,希望你们会喜欢。


    2. 知识储备

    在讲解Binder前,我们先了解一些Linux的基础知识

    2.1 进程空间划分

    • 一个进程空间分为 用户空间 & 内核空间(Kernel),即把进程内 用户 & 内核 隔离开来
    • 二者区别:
      1. 进程间,用户空间的数据不可共享,所以用户空间 = 不可共享空间
      2. 进程间,内核空间的数据可共享,所以内核空间 = 可共享空间

    所有进程共用1个内核空间

    • 进程内 用户空间 & 内核空间 进行交互 需通过 系统调用,主要通过函数:
    1. copy_from_user():将用户空间的数据拷贝到内核空间
    2. copy_to_user():将内核空间的数据拷贝到用户空间

    示意图

    2.2 进程隔离 & 跨进程通信( IPC )

    • 进程隔离
      为了保证 安全性 & 独立性,一个进程 不能直接操作或者访问另一个进程,即Android的进程是相互独立、隔离的

    • 跨进程通信( IPC
      即进程间需进行数据交互、通信

    • 跨进程通信的基本原理

    示意图

    a. 而Binder的作用则是:连接 两个进程,实现了mmap()系统调用,主要负责 创建数据接收的缓存空间 & 管理数据接收缓存
    b. 注:传统的跨进程通信需拷贝数据2次,但Binder机制只需1次,主要是使用到了内存映射,具体下面会详细说明

    2.5 内存映射

    具体请看文章:操作系统:图文详解 内存映射


    3. Binder 跨进程通信机制 模型

    3.1 模型原理图

    Binder 跨进程通信机制 模型 基于 Client - Server 模式
    示意图

    3.2 模型组成角色说明

    示意图

    此处重点讲解 Binder驱动的作用 & 原理:

    • 简介

    示意图

    • 跨进程通信的核心原理

    关于其核心原理:内存映射,具体请看文章:操作系统:图文详解 内存映射

    示意图

    3.3 模型原理步骤说明

    示意图

    3.4 额外说明

    说明1:Client进程、Server进程 & Service Manager 进程之间的交互 都必须通过Binder驱动(使用 openioctl文件操作函数),而非直接交互

    原因:

    1. Client进程、Server进程 & Service Manager进程属于进程空间的用户空间,不可进行进程间交互
    2. Binder驱动 属于 进程空间的 内核空间,可进行进程间 & 进程内交互

    所以,原理图可表示为以下:

    虚线表示并非直接交互

    示意图

    说明2: Binder驱动 & Service Manager进程 属于 Android基础架构(即系统已经实现好了);而Client 进程 和 Server 进程 属于Android应用层(需要开发者自己实现)

    所以,在进行跨进程通信时,开发者只需自定义Client & Server 进程 并 显式使用上述3个步骤,最终借助 Android的基本架构功能就可完成进程间通信

    示意图

    说明3:Binder请求的线程管理
    • Server进程会创建很多线程来处理Binder请求
    • Binder模型的线程管理 采用Binder驱动的线程池,并由Binder驱动自身进行管理

    而不是由Server进程来管理的

    • 一个进程的Binder线程数默认最大是16,超过的请求会被阻塞等待空闲的Binder线程。

    所以,在进程间通信时处理并发问题时,如使用ContentProvider时,它的CRUD(创建、检索、更新和删除)方法只能同时有16个线程同时工作


    • 至此,我相信大家对Binder 跨进程通信机制 模型 已经有了一个非常清晰的定性认识
    • 下面,我将通过一个实例,分析Binder跨进程通信机制 模型在 Android中的具体代码实现方式

    即分析 上述步骤在Android中具体是用代码如何实现的


    4. Binder机制 在Android中的具体实现原理

    • Binder机制在 Android中的实现主要依靠 Binder类,其实现了IBinder 接口

    下面会详细说明

    • 实例说明:Client进程 需要调用 Server进程的加法函数(将整数a和b相加)

    即:

    1. Client进程 需要传两个整数给 Server进程
    2. Server进程 需要把相加后的结果 返回给Client进程
    • 具体步骤
      下面,我会根据Binder 跨进程通信机制 模型的步骤进行分析

    步骤1:注册服务

    • 过程描述
      Server进程 通过Binder驱动 向 Service Manager进程 注册服务
    • 代码实现
      Server进程 创建 一个 Binder 对象
    1. Binder 实体是 Server进程 在 Binder 驱动中的存在形式
    2. 该对象保存 ServerServiceManager 的信息(保存在内核空间中)
    3. Binder 驱动通过 内核空间的Binder 实体 找到用户空间的Server对象
    • 代码分析
        
        Binder binder = new Stub();
        // 步骤1:创建Binder对象 ->>分析1
    
        // 步骤2:创建 IInterface 接口类 的匿名类
        // 创建前,需要预先定义 继承了IInterface 接口的接口 -->分析3
        IInterface plus = new IPlus(){
    
              // 确定Client进程需要调用的方法
              public int add(int a,int b) {
                   return a+b;
             }
    
              // 实现IInterface接口中唯一的方法
              public IBinder asBinder(){ 
                    return null ;
               }
    };
              // 步骤3
              binder.attachInterface(plus,"add two int");
             // 1. 将(add two int,plus)作为(key,value)对存入到Binder对象中的一个Map<String,IInterface>对象中
             // 2. 之后,Binder对象 可根据add two int通过queryLocalIInterface()获得对应IInterface对象(即plus)的引用,可依靠该引用完成对请求方法的调用
            // 分析完毕,跳出
    
    
    <-- 分析1:Stub类 -->
        public class Stub extends Binder {
        // 继承自Binder类 ->>分析2
    
              // 复写onTransact()
              @Override
              boolean onTransact(int code, Parcel data, Parcel reply, int flags){
              // 具体逻辑等到步骤3再具体讲解,此处先跳过
              switch (code) { 
                    case Stub.add: { 
    
                           data.enforceInterface("add two int"); 
    
                           int  arg0  = data.readInt();
                           int  arg1  = data.readInt();
    
                           int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 
    
                            reply.writeInt(result); 
    
                            return true; 
                      }
               } 
          return super.onTransact(code, data, reply, flags); 
    
    }
    // 回到上面的步骤1,继续看步骤2
    
    <-- 分析2:Binder 类 -->
     public class Binder implement IBinder{
        // Binder机制在Android中的实现主要依靠的是Binder类,其实现了IBinder接口
        // IBinder接口:定义了远程操作对象的基本接口,代表了一种跨进程传输的能力
        // 系统会为每个实现了IBinder接口的对象提供跨进程传输能力
        // 即Binder类对象具备了跨进程传输的能力
    
            void attachInterface(IInterface plus, String descriptor);
            // 作用:
              // 1. 将(descriptor,plus)作为(key,value)对存入到Binder对象中的一个Map<String,IInterface>对象中
              // 2. 之后,Binder对象 可根据descriptor通过queryLocalIInterface()获得对应IInterface对象(即plus)的引用,可依靠该引用完成对请求方法的调用
    
            IInterface queryLocalInterface(Stringdescriptor) ;
            // 作用:根据 参数 descriptor 查找相应的IInterface对象(即plus引用)
    
            boolean onTransact(int code, Parcel data, Parcel reply, int flags);
            // 定义:继承自IBinder接口的
            // 作用:执行Client进程所请求的目标方法(子类需要复写)
            // 参数说明:
            // code:Client进程请求方法标识符。即Server进程根据该标识确定所请求的目标方法
            // data:目标方法的参数。(Client进程传进来的,此处就是整数a和b)
            // reply:目标方法执行后的结果(返回给Client进程)
             // 注:运行在Server进程的Binder线程池中;当Client进程发起远程请求时,远程请求会要求系统底层执行回调该方法
    
            final class BinderProxy implements IBinder {
             // 即Server进程创建的Binder对象的代理对象类
             // 该类属于Binder的内部类
            }
            // 回到分析1原处
    }
    
    <-- 分析3:IInterface接口实现类 -->
    
     public interface IPlus extends IInterface {
              // 继承自IInterface接口->>分析4
              // 定义需要实现的接口方法,即Client进程需要调用的方法
             public int add(int a,int b);
    // 返回步骤2
    }
    
    <-- 分析4:IInterface接口类 -->
    // 进程间通信定义的通用接口
    // 通过定义接口,然后再服务端实现接口、客户端调用接口,就可实现跨进程通信。
    public interface IInterface
    {
        // 只有一个方法:返回当前接口关联的 Binder 对象。
        public IBinder asBinder();
    }
      // 回到分析3原处
    

    注册服务后,Binder驱动持有 Server进程创建的Binder实体

    步骤2:获取服务

    • Client进程 使用 某个 service前(此处是 相加函数),须 通过Binder驱动 向 ServiceManager进程 获取相应的Service信息
    • 具体代码实现过程如下:

    示意图

    此时,Client进程与 Server进程已经建立了连接

    步骤3:使用服务

    Client进程 根据获取到的 Service信息(Binder代理对象),通过Binder驱动 建立与 该Service所在Server进程通信的链路,并开始使用服务

    • 过程描述

      1. Client进程 将参数(整数a和b)发送到Server进程
      2. Server进程 根据Client进程要求调用 目标方法(即加法函数)
      3. Server进程 将目标方法的结果(即加法后的结果)返回给Client进程
    • 代码实现过程

    步骤1: Client进程 将参数(整数a和b)发送到Server进程

    // 1. Client进程 将需要传送的数据写入到Parcel对象中
    // data = 数据 = 目标方法的参数(Client进程传进来的,此处就是整数a和b) + IInterface接口对象的标识符descriptor
      android.os.Parcel data = android.os.Parcel.obtain();
      data.writeInt(a); 
      data.writeInt(b); 
    
      data.writeInterfaceToken("add two int");;
      // 方法对象标识符让Server进程在Binder对象中根据"add two int"通过queryLocalIInterface()查找相应的IInterface对象(即Server创建的plus),Client进程需要调用的相加方法就在该对象中
    
      android.os.Parcel reply = android.os.Parcel.obtain();
      // reply:目标方法执行后的结果(此处是相加后的结果)
    
    // 2. 通过 调用代理对象的transact() 将 上述数据发送到Binder驱动
      binderproxy.transact(Stub.add, data, reply, 0)
      // 参数说明:
        // 1. Stub.add:目标方法的标识符(Client进程 和 Server进程 自身约定,可为任意)
        // 2. data :上述的Parcel对象
        // 3. reply:返回结果
        // 0:可不管
    
    // 注:在发送数据后,Client进程的该线程会暂时被挂起
    // 所以,若Server进程执行的耗时操作,请不要使用主线程,以防止ANR
    
    
    // 3. Binder驱动根据 代理对象 找到对应的真身Binder对象所在的Server 进程(系统自动执行)
    // 4. Binder驱动把 数据 发送到Server 进程中,并通知Server 进程执行解包(系统自动执行)
    
    

    步骤2:Server进程根据Client进要求 调用 目标方法(即加法函数)

    // 1. 收到Binder驱动通知后,Server 进程通过回调Binder对象onTransact()进行数据解包 & 调用目标方法
      public class Stub extends Binder {
    
              // 复写onTransact()
              @Override
              boolean onTransact(int code, Parcel data, Parcel reply, int flags){
              // code即在transact()中约定的目标方法的标识符
    
              switch (code) { 
                    case Stub.add: { 
                      // a. 解包Parcel中的数据
                           data.enforceInterface("add two int"); 
                            // a1. 解析目标方法对象的标识符
    
                           int  arg0  = data.readInt();
                           int  arg1  = data.readInt();
                           // a2. 获得目标方法的参数
                          
                           // b. 根据"add two int"通过queryLocalIInterface()获取相应的IInterface对象(即Server创建的plus)的引用,通过该对象引用调用方法
                           int  result = this.queryLocalIInterface("add two int") .add( arg0,  arg1); 
                          
                            // c. 将计算结果写入到reply
                            reply.writeInt(result); 
                            
                            return true; 
                      }
               } 
          return super.onTransact(code, data, reply, flags); 
          // 2. 将结算结果返回 到Binder驱动
    
    
    

    步骤3:Server进程 将目标方法的结果(即加法后的结果)返回给Client进程

      // 1. Binder驱动根据 代理对象 沿原路 将结果返回 并通知Client进程获取返回结果
      // 2. 通过代理对象 接收结果(之前被挂起的线程被唤醒)
    
        binderproxy.transact(Stub.ADD, data, reply, 0);
        reply.readException();;
        result = reply.readInt();
              }
    }
    
    • 总结
      下面,我用一个原理图 & 流程图来总结步骤3的内容

    原理图

    流程图


    5. 优点

    对比 LinuxAndroid基于Linux)上的其他进程通信方式(管道、消息队列、共享内存、
    信号量、Socket),Binder 机制的优点有:
    示意图


    6. 总结

    • 本文主要详细讲解 跨进程通信模型 Binder机制 ,总结如下:

    定义

    特别地,对于从模型结构组成的Binder驱动来说:

    示意图

    • 整个Binder模型的原理步骤 & 源码分析

    示意图

    • 下面我将继续对 Android中的知识进行讲解 ,感兴趣的同学可以继续关注carson_ho的微信公众号
      示意图
      示意图

    请帮顶 / 评论点赞!因为你的鼓励是我写作的最大动力!

    展开全文
  • Binder时序图

    2018-07-02 17:10:25
    Binder
  • Binder-Binder简介

    2017-05-04 20:05:20
    Binder的简介 Binder是android特有的进程间通信方式,它融合了面相对象的RPC,它就像一张网,将整个系统的组件,跨越进程和线程,组织在了一起,是整个系统运行的枢纽。 Binder对象的定义 1)Binder实体对象...
  • BinderJava

    2015-04-18 11:36:53
    Binder简化例子, 只使用java演示Binder和Service实现。希望对写新的跨进程Service有帮助。
  • Binder——Binder 对象生命周期注册服务流程注册服务整个流程,涉及 Binder 对象生命周期的地方,概括如下:获取服务流程获取服务整个流程,涉及 Binder 对象生命周期的地方,概括如下:获取服务过程,涉及 Binder ...
  • 在Android系统中,每一个应用程序都是由一些Activity和Service组成的,这些Activity和Service有可能运行在同一个进程中,也有可能运行在不同的进程中。...这就是本文中要介绍的Binder进程间通信机制了。
  • Android-Binder进程间通讯机制 概述 最近在学习Binder机制,在网上查阅了大量的资料,也看了老罗的Binder系列的博客和Innost的深入理解Binder系列的博客,都是从底层开始讲的,全是C代码,虽然之前学过C和C++,...
  • Android系统启动完成后,ActivityManager, PackageManager等各大服务都运行在system_server进程,app应用需要使用系统服务都是通过binder来完成进程之间的通信,上篇文章彻底理解Android Binder通信架构,从整体架构...
  • Binder机制

    2019-04-15 16:14:00
    Binder机制 目录 Binder是什么 Binder通信机制 Binder驱动 Service Manager Binder机制跨进程通信流程 总结 先给出Android中的Binder的工作机制图 我们在上一篇文章讲解了AIDL生成的Java文件,我们知道AIDL的...
  • binder原理

    2012-06-28 19:37:25
    从结构上来说Android Binder系统是一种服务器/客户机模式,包括Binder Server、Binder Client和Android Binder驱动,实际的数据传输就是通过Android Binder驱动来完成的,这里我们就来详细的介绍Android Binder驱动...
  • Android Binder实现浅析-Binder驱动

    千次阅读 多人点赞 2019-07-04 10:53:34
    Android是如何实现跨进程通信的,大家熟悉的Binder是什么,怎么设计的,进程间的数据如何发送接收的。本文将以及解析,并对Binder驱动实现、Native层实现、Java层实现三块做一个总结分析。 Binder学习思路 Binder与...
  • Android Binder

    千次阅读 2015-07-09 18:09:02
    Binder进程间通信库Android系统在应用程序框架层将各种Binder驱动程序操作封装成了一个Binder库,这样进程就可以方便调用Binder库提供的接口来进行进程间通信。在Binder库中,Service组件和Client组件分别使用模板类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,939
精华内容 9,175
关键字:

binder