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

    前言

    Binder是Android核心中的核心。Android各种服务都是通过Binder来实现进程间通讯的,我计划分三部分大概剖析一下binder的具体原理。

    1. Binder的具体使用案例
    2. 源码分析大概流程
    3. 实现最简单的binder

    正文

    binder是分为两部分的,一部分是服务端,通过线程池,等待其他进程通过binder驱动通知服务。另一部分是客户端,主要通过mmap函数,得到内核的内存映射区,写入数据,然后通知服务端。一个最简单的服务端如下:

    在这里插入图片描述

    主要操作流程大概是

    1. Bnservice向binder驱动注册自己(主要包括名称和线程池)
    2. 客户端通过defaultServiceManager(binder驱动模块)获取注册的Bpservice。
    3. 客户端吧需要传输的消息写入到通过map共享的内存中,然后通知binder,唤醒服务端。
    4. 服务端进程启动,调用onTransact,读取共享缓冲区的内容。做出相应,写会相应。
    5. 阻塞的客户端得到相应。完成一次通讯。

    下面我们先简要介绍一个最简答的HelloWorld的binder程序

    首先介绍一下:binder使用的接口:

    无论任何一对客户端和服务端的binder通讯对(可以一对多),都需要一个IXXXService,

    比如IHelloService

    class IHelloService: public IInterface
    {
    public:
        DECLARE_META_INTERFACE(HelloService);
    /*                                
    public:                                                                 
        static const ::android::String16 descriptor;                        
        static ::android::sp<IHelloService> asInterface(                     
                const ::android::sp<::android::IBinder>& obj);              
        virtual const ::android::String16& getInterfaceDescriptor() const;  
        IHelloService();                                                     
        virtual ~IHelloService();                                            
        static bool setDefaultImpl(std::unique_ptr<IHelloService> impl);     
        static const std::unique_ptr<IHelloService>& getDefaultImpl();       
    private:                                                                
        static std::unique_ptr<IHelloService> default_impl;                  
    public:     
    
    */
                                                                
    
        virtual int    SayHello(char *str) = 0;
        virtual char*    getHi() = 0;
        
    };
    

    一般开发过程中都直接使用预编译的DECLARE_META_INTERFACE的定义一些公共方法,最终等效于注释部分,主要定义一些函数、和default_impl变量。而IInterface的代码如下:

    class IInterface : public virtual RefBase
    {
    public:
                IInterface();
                static sp<IBinder>  asBinder(const IInterface*);
                static sp<IBinder>  asBinder(const sp<IInterface>&);
    
    protected:
        virtual                     ~IInterface();
        virtual IBinder*            onAsBinder() = 0;
    };
    

    这个类主要是关于binder的静态方法。

    下面我们介绍一下BnService的实现

    class HelloService: public BnInterface<IHelloService>
    {
    public:
    
        static void instantiate(){
        defaultServiceManager()->addService(
                String16("hello.service"), new HelloService());
    	};
    
        int    SayHello(char *str){
        return 1;
    	}
    
        char*    getHi(){
        return NULL;
         }
    
    status_t    onTransact(uint32_t code, const Parcel& data, Parcel* reply,
                                    uint32_t flags){
          
        switch (code) {
        	case SAY_HELLO: {
                CHECK_INTERFACE(IHelloService, data, reply);
                const char *name = data.readCString();
                return NO_ERROR;
            }
    
            case GET_REPLAY: {
                CHECK_INTERFACE(IHelloService, data, reply);
                reply->writeCString("hello");
                return NO_ERROR;
            }
    
            default:
                return BBinder::onTransact(code, data, reply, flags);
            
            }
            
            return -1;       
        }  
    };
    

    其实代码逻辑比较简单,主要是实现了IHelloService的接口,以及核心收到binder有消息时写入时,被线程池调用的函数onTransact。

    BnInterface其实比较简单,主要通过BBinder管理binder。

    template<typename INTERFACE>
    class BnInterface : public INTERFACE, public BBinder
    {
    public:
        virtual sp<IInterface>      queryLocalInterface(const String16& _descriptor);
        virtual const String16&     getInterfaceDescriptor() const;
    
    protected:
        typedef INTERFACE           BaseInterface;
        virtual IBinder*            onAsBinder();
    };
    

    一个最简单的binder服务端代码如下:

    int main(int argc __unused, char **argv __unused)
    {
        signal(SIGPIPE, SIG_IGN);
        
        hello::HelloService::instantiate();
        //打开线程池。            
        ProcessState::self()->startThreadPool();
        IPCThreadState::self()->joinThreadPool();
    
    }
    

    服务端本质就是一个线程池,阻塞式的调用binder文件的ioctl系统调用,式再rocessState::self()->startThreadPool()中进入一个死循环,当驱动中收到client发送的消息后,阻塞函数会开始调用,进而开始调用onTransact函数。

    客户端

    客户端代码如下

    class BpHelloService: public BpInterface<IHelloService>
    {
    public:
        BpHelloService(const sp<IBinder>& imp);
        int    SayHello(char *str);
        char* getHi();
    };
    
    BpHelloService::BpHelloService(const sp<IBinder>& imp) : BpInterface<IHelloService>(imp) {
        ALOGV("MediaTranscodingService is created");
    
    }
    
    int BpHelloService::SayHello(char *str) {
        // TODO(hkuang): Add implementation.
    	
    	const char *tmp = str;
    		ALOGE("---what the fuck---%s",str);
    	
    	Parcel data, reply;
            data.writeInterfaceToken(IHelloService::getInterfaceDescriptor());
            data.writeCString(tmp);
            status_t status __unused = remote()->transact(SAY_HELLO, data, &reply);
    	ALOGE("------%s",str);
    	return 1;
    }
    
    char* BpHelloService::getHi() {
    	Parcel data, reply;
            data.writeInterfaceToken(IHelloService::getInterfaceDescriptor());
            
            status_t status __unused = remote()->transact(GET_REPLAY, data, &reply);
            
            const char *rep = reply.readCString();
            
            char *ret = (char*)malloc(10);;
            strcpy(ret,rep);
        return ret;
    }
    
    
    //IMPLEMENT_META_INTERFACE(HelloService,"hello.world.service");
    //下半部分等效与宏定义
    const ::android::StaticString16                                     
            IHelloService_descriptor_static_str16(__IINTF_CONCAT(u, "hello.world.service"));
        const ::android::String16 IHelloService::descriptor(                 
            IHelloService_descriptor_static_str16);                        
        const ::android::String16&                                          
                IHelloService::getInterfaceDescriptor() const {              
            return IHelloService::descriptor;                                
        }                                                                   
        ::android::sp<IHelloService> IHelloService::asInterface(              
                const ::android::sp<::android::IBinder>& obj)               
        {                                                                   
            ::android::sp<IHelloService> intr;                               
            if (obj != nullptr) {                                           
                intr = static_cast<IHelloService*>(                          
                    obj->queryLocalInterface(                               
                            IHelloService::descriptor).get());               
                if (intr == nullptr) {                                      
                    intr = new BpHelloService(obj);                          
                }                                                           
            }                                                               
            return intr;                                                    
        }                                                                   
        std::unique_ptr<IHelloService> IHelloService::default_impl;           
        bool IHelloService::setDefaultImpl(std::unique_ptr<IHelloService> impl)
        {                                                                   
            /* Only one user of this interface can use this function     */ 
            /* at a time. This is a heuristic to detect if two different */ 
            /* users in the same process use this function.              */ 
            assert(!IHelloService::default_impl);                            
            if (impl) {                                                     
                IHelloService::default_impl = std::move(impl);               
                return true;                                                
            }                                                               
            return false;                                                   
        }                                                                   
        const std::unique_ptr<IHelloService>& IHelloService::getDefaultImpl() 
        {                                                                   
            return IHelloService::default_impl;                              
        }                                                                   
        IHelloService::IHelloService() { }                                    
        IHelloService::~IHelloService() { }         
        
    

    这里的核心就是remote()->transact(SAY_HELLO, data, &reply);原理是

    status_t BpBinder::transact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
    {
        
        ......
    
            status_t status = IPCThreadState::self()->transact()
    
    	......
    
        return DEAD_OBJECT;
    }
    

    就是通过IPCThreadState的transact函数完成任务

    status_t IPCThreadState::transact(int32_t handle,
                                      uint32_t code, const Parcel& data,
                                      Parcel* reply, uint32_t flags)
    {
    
        err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, nullptr);
    
        err = waitForResponse(reply);
          
        return err;
    }
    
    
    status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)
    {
    
        while (1) {
        	//把out通过iotl写入到驱动,然后被驱动程序处理,
            if ((err=talkWithDriver()) < NO_ERROR) break;
            //结果进行处理,返回到之前的函数,
              cmd = (uint32_t)mIn.readInt32();
    
            switch (cmd) {
            case BR_TRANSACTION_COMPLETE:
                if (!reply && !acquireResult) goto finish;
                break;
            case BR_ACQUIRE_RESULT:
                {
                    ALOG_ASSERT(acquireResult != NULL, "Unexpected brACQUIRE_RESULT");
                    const int32_t result = mIn.readInt32();
                    if (!acquireResult) continue;
                    *acquireResult = result ? NO_ERROR : INVALID_OPERATION;
                }
                goto finish;
    
            case BR_REPLY:
                {
                    binder_transaction_data tr;
                    err = mIn.read(&tr, sizeof(tr));
                    ALOG_ASSERT(err == NO_ERROR, "Not enough command data for brREPLY");
                    if (err != NO_ERROR) goto finish;
    
            default:
                err = executeCommand(cmd);
                if (err != NO_ERROR) goto finish;
                break;
            }
        }
    
        return err;
    }
    

    talkWithDriver就是通过ioctl把数据写入到binder中的,代码比较简单
    status_t IPCThreadState::talkWithDriver(bool doReceive)
    {

        if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)
    
    return err;
    

    }

    后记

    binder好复杂啊,整体原理还是比较简单的,但是binder中混入了一个无用的servicemanage以及多线程的支持,让代码晦涩难懂,以后有机会再分析一下。

    更多相关内容
  • binder

    2021-03-16 19:38:20
    mlr3图库到粘合剂
  • Binder是Android系统进程间通信(IPC)方式之一。Linux已经拥有管道,systemVIPC,socket等IPC手段,却还要倚赖Binder来实现进程间通信,说明Binder具有无可比拟的优势。深入了解Binder并将之与传统IPC做对比有助于...
  • Android系统启动完成后,ActivityManager,PackageManager等各大服务都运行在system_server进程,app应用需要使用系统服务都是通过binder来完成进程之间的通信,上篇文章彻底理解Android Binder通信架构,从整体架构...
  • 为什么Android非要用Binder来进行进程间通信呢.从我个人的理解角度,曾尝试着在知乎回答同样一个问题为什么Android要采用Binder作为IPC机制?.这是我第一次认认真真地在知乎上回答问题,收到很多网友的点赞与回复,让我...
  • AndroidBinder

    2021-02-23 23:10:37
    Binder是什么?Binder是一种进程间通信机制为什么是BinderBinder通信机制采用C/S架构,这很重要!!!@Binder架构|centerBinder框架中主要涉及到4个角色Client、Server、ServiceManager及Binder驱动,其中Client、...
  • 最近一段时间由于工作,接触到framework部分比较多一点,也难免要和Binder打一些交道,也整理了一些相关知识,但准备写这篇文章时,还是有些慌。而且关于整个Binder机制的复杂程度不是三言两语能描叙清楚的,也害怕...
  • android binder c++ 代码实现,添加内存共享、读写通知通过binder通行。代码再Android 9上测试无问题。
  • 一、Binder机制概述 在Android开发中,很多时候我们需要用到进程间通信,所谓进程间通信,实现进程间通信的机制有很多种,比如说socket、pipe等,Android中进程间通信的方式主要有三种: 1.标准Linux Kernel IPC ...
  • Binder做为Android中核心机制,对于理解Android系统是必不可少的,关于binder的文章也有很多,但是每次看总感觉看的不是很懂,到底什么才是binder机制?为什么要使用binder机制?binder机制又是怎样运行的呢?这些...
  • 当然了,Binder机制的底层驱动实现很复杂,本文的目的只是为了理清Binder的使用和在应用层的结构和流程,对于Binder在底层是如何实现的,目前能力还没到这一步去分析,不会涉及到。对于这部分,不妨将它看成是一个黑...
  • Binder通信机制说来简单,但是在使用的过程的遇到了一些问题,最后终于解决了,在这总结一下,一并分享给大家: 1、要使用Binder通信,首先要定义接口,然后实现服务端BnInterface***和客户端BpInterface***,说到底...
  • binder.zip

    2020-11-04 11:12:58
    1、Android Binder 进程通信应用实例 2、Android 基于linux内核开发,linux内核提供丰富的进程通信机制,如pipe、signal、message、share memory、socket,但android采用新的进程间通信机制binder。相比之下binder...
  • R在Jupyter中与Binder 如何在Jupyter笔记本中使用R,然后创建一个Binder环境以在Web上交互式运行它们的示例。 此回购源于在有关的讨论中的启发。 免责声明:我是物理学家,主要是Python和C ++程序员,并且我不使用/...
  • Binder的实现是比较复杂的,想要完全弄明白是怎么一回事,并不是一件容易的事情。这里面牵涉到好几个层次,每一层都有一些模块和机制需要理解。这部分内容预计会分为三篇文章来讲解。本文是第一篇,首先会对整个...
  • Binder是一种进程间通信机制,基于开源的OpenBinder实现;OpenBinder起初由BeInc.开发,后由PlamInc.接手。从字面上来解释Binder有胶水、粘合剂的意思,顾名思义就是粘和不同的进程,使之实现通信。一般Android应用...
  • Android进程间通信(Inter-Process Communication, IPC)采用Binder通信机制,是一种client/server结构。 AIDL(Android Interface Define Language):Android接口定义语言,帮助开发者自动生成实现Binder通信机制...
  • LuaBinder C ++ 11中的Lua Binder MinGW GNU 4.7.2进行编译。 例子: #include #include #include using namespace std; Lua::State g_lua; int32_t main(void) { g_lua.init(); g_lua.loadFile("test....
  • 1.背景 在前面的博客中,我们已经学会了使用AIDL进行跨...Binder中文意思是黏合剂,这个名称很贴切,生活中的黏合剂是将两种材料通过界面的粘附和内聚强度连接在一起的物质,而Android系统里,Binder则是将两个进程间
  • PDFBinder v1.2 内容: 安装及使用为项目做贡献发牌安装及使用可以使用漂亮的安装程序将PDFBinder安装在Microsoft Windows系统上,该安装程序可以从下载。 为了在其他平台上使用PDFBinder-或如果安装程序由于其他...
  • AIDL的底层是通过Binder进行通信的,通过追踪.aidl编译后自动生成的文件我们知道,文件中的Stub类用于服务端,Proxy类用于客户端调用,那么可否直接通过继承Binder类实现多进程通信呢?下面就来试一试。 效果图: ...
  • android中c++层binder例子

    2015-10-28 16:58:21
    3. sdkserver是binder服务(编译后生成sdkserver二进制),sdklib是binder的client(编译生成so),sdkclient(编译生成bin)是用来测试sdklib的。 4. 编译完成后把两个bin文件放到andoid系统的/system/bin目录下,...
  • Binder面试系列00-binder爱情例子.md
  • 如果要在本地复制这些笔记本,则binder夹文件夹中有一个requirements.txt文件。 使用此工具将所需的软件包安装到虚拟环境中。 请注意,某些笔记本是不确定的,因为我无法在某些点设置随机种子。 因此,如果再次运行...
  • PDF文件合并,PDFBinder 是一个非常简易的开源PDF合并软件,使用简便,只有合并PDF文件这一种功能。,可以很容易的将多个 PDF 合并为单一 PDF,支持排序。
  • 背景binder.js是JsBinder,由葡萄牙Sonaecom的PD-Portal团队使用一个lib的岔路口,在项目,如 , , , 和几个服务. 由于是从JsBinder V2的自然演进,binder.js的第一个版本有3.0.0版本.. binder.js的开发目标如下:...
  • 了解binder是用来干什么的? (binder是用来跨进程通信的) 应用里面哪些地方用到了binder机制? 应用的大致启动流程是怎样的? 一个进程是怎么启动binder机制的? 应用启动流程 什么时候支持binder机制的? ...
  • Android binder_test

    2020-07-14 16:22:57
    附件采用C++语言实现的binder sample测试代码,代码使用了server 和client端 供学习参考使用。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,761
精华内容 47,504
关键字:

binder