Binder的工作原理以及如何手动写一个Binder

最新推荐文章于 2023-01-28 00:14:40 发布
最新推荐文章于 2023-01-28 00:14:40 发布
阅读量440 收藏
点赞数
分类专栏： android 文章标签： android 进程间通信 binder 原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maguifen2012/article/details/90106086
版权

Binder的工作原理以及如何手动写一个Binder

上一篇文章我们详细介绍了AIDL的使用。如果对AIDL的使用还不熟悉的话，可以去看看我上一篇的博客,上一篇博客写到，我们通过自己写好的aidl文件，系统会自动帮我们生成文件。下面，我们根据系统生成的代码，来简单分析一下Binder的工作原理。

Binder的工作原理

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: D:\\maguifeng\\android-code\\AIDLService\\app\\src\\main\\aidl\\com\\demo\\aidlservice\\IBookManager.aidl
 */
package com.demo.aidlservice;
// Declare any non-default types here with import statements

public interface IBookManager extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.demo.aidlservice.IBookManager {
        private static final java.lang.String DESCRIPTOR = "com.demo.aidlservice.IBookManager";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.demo.aidlservice.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.demo.aidlservice.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.demo.aidlservice.IBookManager))) {
                return ((com.demo.aidlservice.IBookManager) iin);
            }
            return new com.demo.aidlservice.IBookManager.Stub.Proxy(obj);
        }

        @Override
        public android.os.IBinder asBinder() {
            return this;
        }

        @Override
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
            java.lang.String descriptor = DESCRIPTOR;
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(descriptor);
                    return true;
                }
                case TRANSACTION_getBookList: {
                    data.enforceInterface(descriptor);
                    java.util.List<com.demo.aidlservice.Book> _result = this.getBookList();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(descriptor);
                    com.demo.aidlservice.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.demo.aidlservice.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
                default: {
                    return super.onTransact(code, data, reply, flags);
                }
            }
        }

        private static class Proxy implements com.demo.aidlservice.IBookManager {
            private android.os.IBinder mRemote;

            Proxy(android.os.IBinder remote) {
                mRemote = remote;
            }

            @Override
            public android.os.IBinder asBinder() {
                return mRemote;
            }

            public java.lang.String getInterfaceDescriptor() {
                return DESCRIPTOR;
            }

            /**
             * Demonstrates some basic types that you can use as parameters
             * and return values in AIDL.
             */
            @Override
            public java.util.List<com.demo.aidlservice.Book> getBookList() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.demo.aidlservice.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.demo.aidlservice.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public void addBook(com.demo.aidlservice.Book book) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((book != null)) {
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

        static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    }

    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    public java.util.List<com.demo.aidlservice.Book> getBookList() throws android.os.RemoteException;

    public void addBook(com.demo.aidlservice.Book book) throws android.os.RemoteException;
}

DESCRIPTOR
Binder唯一标识，一般用当前Binder的全路径包名来表示，例如上面的代码为：“com.demo.aidlservice.IBookManager”;

Stub()
Stub的构造方法，这个没什么好说的。

asInterface(android.os.IBinder obj)
将服务端的Binder对象转换成客户端所需要的AIDL接口类型的对象。此方便有两种返回值，如果是服务端和客户端处于同一个进程，那么返回的就是Stub本身。如果处于不同的进程，那么返回的是Stub.proxy对象

asBinder()
返回当前的Binder对象

onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)
这个方法只有在多进程通信才会调用，同一个进程是不会调用。
这个方法运行在Binder的线程池中，当客户端发起请求时，远程请求会通过系统底层的一些封装来调用此方法。通过code来区分客户端请求的目标方法，data取出目标方法所需的参数，然后由reply写入返回值。onTransact的执行过程就是这样。注意：这个方法返回都是true,如果返回false，客户端请求会失败。因此，我们可以通过这个特性来做权限认证。如何做这个权限认证，这里不做详细的介绍。

Proxy&getBookList()
这个方法由客户端调用。内部的实现是：首先，会创建三个对象：输入Parcel对象_data，输出Parcel对象_reply，List对象_result。接着会将此方法的参数写入到_data中，然后调用transact方法，发起RPC远程调用请求，同时当前线程会被挂起。接着回调服务端onTransact方法。直到RPC过程完成后，当前线程继续执行，从_reply中取出RPC返回值。最后返回_reply的结果。
Proxy&addBook(Book book)
这个方法由客户端调用。实现的流程与getBookList()一样。不同的一点是，此方法并不需要从_reply取出返回值，所以没有返回值。
通过上面的分析，我们应该对Binder的工作机制有一个大概的了解。此外，还有两点需要注意：
1.如果远程请求耗时，不能在UI线程去发起远程请求
2.Binder方法应采取同步的方式去实现
为了更好的了解Binder的工作机制，画了Binder的工作机制图，相信会对Binder的工作机制会有更深的理解。
在这里插入图片描述
从上面的分析来看，我们可以不提供aidl文件来实现Binder.我们可以根据系统生成的文件，手动写一个Binder.

手动实现Binder

根据上面的思想， 手动实现一个Binder可以通过如下步骤来完成：
（1）定义一个接口继承IInterface接口。这个接口实现如下：

package com.demo.aidlservice2;

import android.os.IBinder;
import android.os.IInterface;
import android.os.RemoteException;

import java.util.List;

/**
 * <pre>
 *
 * Created by MarvinMa
 * Time : 2019/5/10-17:20
 * Desc :
 * </pre>
 */
public interface IBookManager extends IInterface {
    String DESCRIPTOR = "com.demo.aidlservice2.IBookManager";
    int TRANSACTION_getBookList = (IBinder.FIRST_CALL_TRANSACTION + 0);
    int TRANSACTION_addBook = (IBinder.FIRST_CALL_TRANSACTION + 1);

    List<Book> getBookList() throws RemoteException;
    void addBook(Book book) throws RemoteException;
}

（2）定义一个类继承Binder并且实现上面定义的接口IBookManager

package com.demo.aidlservice2;

import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;


import java.util.List;

/**
 * <pre>
 *
 * Created by MarvinMa
 * Time : 2019/5/10-17:27
 * Desc :
 * </pre>
 */
public abstract class BookManagerImp extends Binder implements IBookManager {

    public BookManagerImp() {
        this.attachInterface(this, DESCRIPTOR);
    }

    public static IBookManager asInterface(IBinder obj) {
        if ((obj == null)) {
            return null;
        }
        IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
        if (((iin != null) && (iin instanceof IBookManager))) {
            return ((IBookManager) iin);
        }
        return new BookManagerImp.Proxy(obj);
    }

    @Override
    public IBinder asBinder() {
        return this;
    }

    @Override
    public boolean onTransact(int code, Parcel data,Parcel reply, int flags) throws RemoteException {
        String descriptor = DESCRIPTOR;
        switch (code) {
            case INTERFACE_TRANSACTION: {
                reply.writeString(descriptor);
                return true;
            }
            case TRANSACTION_getBookList: {
                data.enforceInterface(descriptor);
                List<Book> _result = this.getBookList();
                reply.writeNoException();
                reply.writeTypedList(_result);
                return true;
            }
            case TRANSACTION_addBook: {
                data.enforceInterface(descriptor);
                Book _arg0;
                if ((0 != data.readInt())) {
                    _arg0 = Book.CREATOR.createFromParcel(data);
                } else {
                    _arg0 = null;
                }
                this.addBook(_arg0);
                reply.writeNoException();
                return true;
            }
            default: {
                return super.onTransact(code, data, reply, flags);
            }
        }
    }

    private static class Proxy extends BookManagerImp {
        private IBinder mRemote;

        Proxy(IBinder remote) {
            mRemote = remote;
        }

        @Override
        public IBinder asBinder() {
            return mRemote;
        }

        public String getInterfaceDescriptor() {
            return DESCRIPTOR;
        }

        @Override
        public List<Book> getBookList() throws RemoteException {
            Parcel _data = Parcel.obtain();
            Parcel _reply = Parcel.obtain();
            List<Book> _result;
            try {
                _data.writeInterfaceToken(DESCRIPTOR);
                mRemote.transact(TRANSACTION_getBookList, _data, _reply, 0);
                _reply.readException();
                _result = _reply.createTypedArrayList(Book.CREATOR);
            } finally {
                _reply.recycle();
                _data.recycle();
            }
            return _result;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            Parcel _data = Parcel.obtain();
            Parcel _reply =Parcel.obtain();
            try {
                _data.writeInterfaceToken(DESCRIPTOR);
                if ((book != null)) {
                    _data.writeInt(1);
                    book.writeToParcel(_data, 0);
                } else {
                    _data.writeInt(0);
                }
                mRemote.transact(TRANSACTION_addBook, _data, _reply, 0);
                _reply.readException();
            } finally {
                _reply.recycle();
                _data.recycle();
            }
        }
    }

}

通过上面的代码可以发现，其实和系统生成的代码是并没有什么不同。手动去写的意义在于可以让我们更深的去理解Binder原理。所以建议大家，还是用aidl的方法自动生成代码。这样比较快捷高效，而且不容易出错。

maguifeng2012
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
进程的Binder线程池工作过程
01-27
Android系统启动完成后，ActivityManager,PackageManager等各大服务都运行在system_server进程，app应用需要使用系统服务都是通过binder来完成进程之间的通信，上篇文章彻底理解Android Binder通信架构，从整体架构以及通信协议的角度来阐述了Binder架构。那对于binder线程是如何管理的呢，又是如何创建的呢？其实无论是system_server进程，还是app进程，都是在进程fork完成后，便会在新进程中执行on
Android通信篇--深入剖析Binder原理
02-25
Binder是一种进程间通信机制，基于开源的OpenBinder实现；OpenBinder起初由BeInc.开发，后由PlamInc.接手。从字面上来解释Binder有胶水、粘合剂的意思，顾名思义就是粘和不同的进程，使之实现通信。一般Android应用...
Binder使用
Joel
03-01 323
Binder使用AIDL实现 1.新建aidl包、新建需要传输的自定义类（实现Parcelable） package com.example.aidltest.aidl; /** * Created by joel. * Date: 2019/6/7 * Time: 15:56 * Description: */ import android.os.Parcel; import android.o...
Android 手写Binder 教你理解android中的进程间通信
fanleiym的专栏
11-08 184
关于Binder，我就不解释的太多了，网上一搜资料一堆，但是估计还是很多人理解的有困难。今天就教你如何从 app层面来理解好Binder。 其实就从我们普通app开发者的角度来看，仅仅对于android应用层的话，Binder就是客户端和服务端进行通信的媒介。 AIDL就是我们理解Binder 最好的事例。 我们都知道 我们写好aidl 文件以后，开发工具 会自动帮我们生成好代码。实际上 我...
android Binder 实现—— AIDL demo
sjh_389510506的博客
03-27 568
服务间进程通信大部分使用AIDL，其其次原理是Binder ，先写一个Demo， 可以参考这里。 一 、AIDL 使用教程 1.1创建要操作的实体类，实现Parcelable接口，以便序列化/反序列化 （Serizable没试过，不知道行不行） public class Book implements Parcelable { private int bookId; ...
Android进程间通信机制Binder学习
weixin_38251977的博客
02-17 214
Android 系统是基于 Linux 内核的，Linux 已经提供了管道、消息队列、共享内存和 Socket 等 IPC (跨进城通信)机制。但是由于性能、稳定性和安全性几方面的原因，Android系统设计了Binder机制来实现IPC. 性能 稳定 Binder 基于 C/S 架构，客户端（Client）有什么需求就丢给服务端（Server）去完成，架构清晰、职责明确又相互独立，自然...
Android：让我们来写一写Binder
bdmh的专栏
03-12 503
Binder作为Android中跨进程通信的一部分，在源码中是起了极其重要的作用。比如ActivityManagerService，就是通过Binder来控制Activity的操作。至于Binder的通信，很多文章都是通过创建AIDL工程，由工具自动生成代码，就会看到诸如Stub、Proxy等内部类，看的是一头雾水。所以要想明明白白的使用Binder，自己手写一遍，对理解是非常有效的。 以下以在两个进程间通信为例来写一个Binder。 客户端 首先定义一个接口，包括Binder标识，发送Transac
android binder作用,Android Binder 分析系列——原理（上）
weixin_31180441的博客
05-26 422
一、原理首先 binder 在最底层有 kernel 的驱动支持。/dev/binder 是 binder 的设备文件。然后 android 通过这个驱动在 native 层整了一套 C/S 架构的框架出来，最后在 java 对应也封装了一层(可以理解为 native 的马甲)。这些东西后面再慢慢分析。二、应用基于 binder android 弄了很多 manager services，不过小编...
AIDL中的Binder机制
Arthas的博客
10-04 807
来到应用层，使用binder的方法一般就是利用系统提供的AIDL来实现。AIDL的作用就是再编译的时候自动生成一个java文件实现binder的功能。
Binder机制原理
Android小白
04-15 5979
Binder是什么？ 可以理解为Android的血管。是一种进程间通信的机制。比如Activity，Service需要和AMS通信的时候，就需要Binder 除了进程间通信，也可以把Binder理解为一种虚拟物理设备驱动。虚拟表示没有实体，和键盘鼠标不一样。Binder是虚拟的。 在应用层，也可以把Binder理解为一个是一个能发起进程间通信的Java类 为什么是Binder？ Linux也有一些很优秀的进程间通信机制，例如管道，消息队列，共享内存，socket等，但是为什么Android使用Binder而
Binder原理系列
jiang19921002的博客
11-12 534
一直关注皇叔，他的分享干货满满，写的博客条理清晰对framework层原理分析的很是透彻，适合大家学习。下面推荐几篇皇叔的Binder原理系列文章： 刘望舒Binder系列 下面从概述->Java层Binder->Native层Binder->Binder驱动大致流程进行分析Binder原理： 1.Linux的IPC通信原理 用户空间需要访问内核空间，就需要借助系统调用来...
Binder机制原理解析
08-17
Android Binder机制全解析，从Kernel binder层到native binder到java binder。很详细值得推荐阅读
Binder原理剖析.pptx
11-13
介绍Binder原理，PPT中含有备注，这些备注有利于理清讲解思路。希望通过这个PPT能让大家对Binder的原理有一个宏观的认识。
Android Binder Aidl原理.pdf
12-24
Android Binder为什么只需要一次copy
android使用第三方平台(蒲公英)和DownloadManager实现APP自动更新
maguifen2012的博客
12-13 5122
对于安卓用户来说，手机应用更新是很频繁的，我们不能在每一次升级版本的时候，都让用户再去应用市场上重新下载一遍，这样是很不友好的。因此，在app里实现自动更新的功能，就显得很有必要了。 今天，就来聊一下，如何使用蒲公英第三方平台和DownLoadManager来实现app自动更新的功能。从以下三个方面来说明:** app自动更新流程阐述 如何集成第三方平台（蒲公英） 如何使用系统自带类Downloa
Android5.0-10.0各版本行为变更
maguifen2012的博客
06-30 3223
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Android热修复技术总结
maguifen2012的博客
01-28 1373
主要是介绍Tinker热修复框架和Tinker热修复集成和修复bug流程
使用Kotlin + buildSrc的方式，方便管理gradle依赖
maguifen2012的博客
07-09 937
原文 https://handstandsam.com/2018/02/11/kotlin-buildsrc-for-better-gradle-dependency-management/ 管理gradle依赖三种方式： 1.手动管理 2.使用Google推荐的“ext” 3.使用kotlin+buildSrc (1)手动管理 这是我们最初使用的gradle管理依赖的方式，在每个module里面直接引入依赖库。这种管理方式的缺点是，可能存在相同的依赖库，而且很难去管理依赖库的版本更新 dependenci
Retrofit和RxJava网络请求二次封装
maguifen2012的博客
03-28 471
目前Retrofit和RxJava结合使用已经是非常普遍了，也是现在最热门的一种网络请求方式,今天我们来聊聊，如何对Retrofit + RxJava 网络请求框架实现二次封装，以供大家在项目中可以应用到，也供大家学习和参考首先我们先来看看关于Retrofit和RxJava最基本的使用 我们需要去定义一个对应接口的Service和返回的实体类 public class Content<T> {
安卓binder工作原理
最新发布
10-03
2. 服务端：服务端进程通过创建一个Binder对象（Binder对象实际上是一个带有特定接口的对象）并将其注册到Binder驱动中，以提供服务。服务端可以通过Binder对象的接口来响应客户端的请求，这个接口需要继承自Binder...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值