Android Binder机制基本原理

最新推荐文章于 2024-05-08 06:23:15 发布
最新推荐文章于 2024-05-08 06:23:15 发布
阅读量2.1k 收藏 16
点赞数 2
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kh896424665/article/details/110086164
版权

一、概述

  1. Binder是什么？

    • 从功能上讲：Binder是一种在Android设备上进行IPC(Inter-Process Communication，进程间通信)的主要方式，主要用来实现跨进程通信。
    • 从代码上讲：Binder是一个类，实现了IBinder接口。
    • 从Android Framwork角度来说，Binder是ServerManager连接各种Manager和ManagerService的桥梁。

  2. 为什么需要Binder？

    • 进程隔离：为了保证安全性&独立性，一个进程不能直接操作或者访问另一个进程，即Android的进程是相互独立、隔离的
    • IPC(跨进程通信)：在实际开发中，经常需要进程间的合作、交互和通信
    • 进程空间的分配：
      用户空间：数据不可共享，即不可共享空间
      内核空间：数据可以共享，即空闲空间
      在这里插入图片描述
    1. 通过上图可以看到，各个进程的用户空间是无法共享的，为了实现进程间的通信，则需要内核空间作为中介来进行数据的交换。如下图：
      工作流程: 发送进程通过系统调用，将需要发送的数据拷贝到内核空间的缓冲区中。内核服务程序唤醒接收进程的接收线程，通过系统调用将数据发送到接收进程的用户空间中，完成数据的发送。所以这里通过两次拷贝完成了一次数据的发送。在这里插入图片描述

  3. Binder IPC模型

    1. 原理图
      Binder跨进程通信机制模型是基于Cilent-Server模式，即cilent进程-server进程。
      说明：Client进程、Server进程、Service Manager之间的数据交互都需要通过Binder来完成。且Service Manager和Binder驱动都是Android基础架构已经帮写好了的，开发人员只需要创建Client进程和Server进程即可。
      在这里插入图片描述

    2. 模型相关角色

      作用备注
      Client进程使用服务的进程
      Server进程提供服务的进程
      ServerManager进程管理Service的注册和查询
      Binder驱动一种虚拟设备驱动，是链接Service进程、Client进程、Service Manager的桥梁。作用为：1.通过内存映射来传递进程间的数据 2.实现线程控制，采用Binder的线程池，并由Binder驱动自身进行管理

    3. 跨进程通信的基本原理
      核心原理：内存映射
      工作流程：

      1. Binder驱动创建一块接收缓冲区
      2. 在内核空间中确定一块用于接收数据的Buffer，然后将用户空间的Buffer与内核空间的Buffer映射到实际的物理内存上，实现用户空间Buffer与内核空间Buffer的同步化
      3. 由于内核缓冲区&接收进程的用户地址空间存在映射关系，故相当于也发送到了接收进程的用户地址空间，实现了跨进程通信
        在这里插入图片描述

二、根据代码进行分析Binder的工作过程

Android开发中，Binder主要用在Serviec中，包括AIDL和Messenger，其中普通Service中的Binder不涉及进程间通信，无法触及Binder的核心，而Message的底层其实是AIDL，所以可以用AIDL来分析Binder的工作机制。

  1. 创建Book.java Book.aidl IBookManager.aidl 三个文件

    Book.java 实现Parcelable接口

    package com.kanghui.demo.aidl;

import android.os.Parcel;
import android.os.Parcelable;

public class Book implements Parcelable {
    public String bookName;
    public int bookId;

    public Book(int bookId, String bookName) {
        this.bookId = bookId;
        this.bookName = bookName;
    }


    protected Book(Parcel in) {
        bookName = in.readString();
        bookId = in.readInt();
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(bookName);
        dest.writeInt(bookId);
    }
}

    Book.aidl 是Book类在AIDL中的声明

    // Book.aidl
package com.kanghui.demo.aidl;

// Declare any non-default types here with import statements

parcelable Book;

    IBookManager.aidl 对外提供获取书籍和添加书籍的方法

    // IBookManager.aidl
package com.kanghui.demo.aidl;

import com.kanghui.demo.aidl.Book;

// Declare any non-default types here with import statements

interface IBookManager {

     List<Book> getBookList();
     void addBook(in Book book);


    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
            double aDouble, String aString);
}

    通过上面写的相关类，系统会为IBookManager 生成Binder类，在build-generate 目录下生成了IBookManager.java的类

    /*
 * This file is auto-generated.  DO NOT MODIFY.
 */
package com.kanghui.demo.aidl;
// Declare any non-default types here with import statements

public interface IBookManager extends android.os.IInterface
{
  /** Default implementation for IBookManager. */
  public static class Default implements com.kanghui.demo.aidl.IBookManager
  {
    @Override public java.util.List<com.kanghui.demo.aidl.Book> getBookList() throws android.os.RemoteException
    {
      return null;
    }
    @Override public void addBook(com.kanghui.demo.aidl.Book book) throws android.os.RemoteException
    
    /**
         * Demonstrates some basic types that you can use as parameters
         * and return values in AIDL.
         */
    @Override public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException
    {
    }
    @Override
    public android.os.IBinder asBinder() {
      return null;
    }
  }
  /** Local-side IPC implementation stub class. */
  public static abstract class Stub extends android.os.Binder implements com.kanghui.demo.aidl.IBookManager
  {
    private static final java.lang.String DESCRIPTOR = "com.kanghui.demo.aidl.IBookManager";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.kanghui.demo.aidl.IBookManager interface,
     * generating a proxy if needed.
     */
    public static com.kanghui.demo.aidl.IBookManager asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.kanghui.demo.aidl.IBookManager))) {
        return ((com.kanghui.demo.aidl.IBookManager)iin);
      }
      return new com.kanghui.demo.aidl.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.kanghui.demo.aidl.Book> _result = this.getBookList();
          reply.writeNoException();
          reply.writeTypedList(_result);
          return true;
        }
        case TRANSACTION_addBook:
        {
          data.enforceInterface(descriptor);
          com.kanghui.demo.aidl.Book _arg0;
          if ((0!=data.readInt())) {
            _arg0 = com.kanghui.demo.aidl.Book.CREATOR.createFromParcel(data);
          }
          else {
            _arg0 = null;
          }
          this.addBook(_arg0);
          reply.writeNoException();
          return true;
        }
        case TRANSACTION_basicTypes:
        {
          data.enforceInterface(descriptor);
          int _arg0;
          _arg0 = data.readInt();
          long _arg1;
          _arg1 = data.readLong();
          boolean _arg2;
          _arg2 = (0!=data.readInt());
          float _arg3;
          _arg3 = data.readFloat();
          double _arg4;
          _arg4 = data.readDouble();
          java.lang.String _arg5;
          _arg5 = data.readString();
          this.basicTypes(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5);
          reply.writeNoException();
          return true;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
    private static class Proxy implements com.kanghui.demo.aidl.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;
      }
      @Override public java.util.List<com.kanghui.demo.aidl.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.kanghui.demo.aidl.Book> _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          boolean _status = mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().getBookList();
          }
          _reply.readException();
          _result = _reply.createTypedArrayList(com.kanghui.demo.aidl.Book.CREATOR);
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      @Override public void addBook(com.kanghui.demo.aidl.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);
          }
          boolean _status = mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().addBook(book);
            return;
          }
          _reply.readException();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      /**
           * Demonstrates some basic types that you can use as parameters
           * and return values in AIDL.
           */
      @Override public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          _data.writeInt(anInt);
          _data.writeLong(aLong);
          _data.writeInt(((aBoolean)?(1):(0)));
          _data.writeFloat(aFloat);
          _data.writeDouble(aDouble);
          _data.writeString(aString);
          boolean _status = mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().basicTypes(anInt, aLong, aBoolean, aFloat, aDouble, aString);
            return;
          }
          _reply.readException();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      public static com.kanghui.demo.aidl.IBookManager sDefaultImpl;
    }
    static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    static final int TRANSACTION_basicTypes = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
    public static boolean setDefaultImpl(com.kanghui.demo.aidl.IBookManager impl) {
      if (Stub.Proxy.sDefaultImpl == null && impl != null) {
        Stub.Proxy.sDefaultImpl = impl;
        return true;
      }
      return false;
    }
    public static com.kanghui.demo.aidl.IBookManager getDefaultImpl() {
      return Stub.Proxy.sDefaultImpl;
    }
  }
  public java.util.List<com.kanghui.demo.aidl.Book> getBookList() throws android.os.RemoteException;
  public void addBook(com.kanghui.demo.aidl.Book book) throws android.os.RemoteException;
  /**
       * Demonstrates some basic types that you can use as parameters
       * and return values in AIDL.
       */
  public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException;
}

    这个类IBookManager.java继承了IInterface，它本身也是一个接口。接口本身申明了两个方法：getBookList()和addBook。同时申明了两个ID标识这两个方法，这两个id用于表示在transact过程中客户端到底请求的是哪个方法。

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

    其次，申请了一个内部类Stub继承自Binder，当客户端和服务端都位于同一个进程时，方法调用不会走跨进程的transact过程，而当两者位于不同进程是，方法调用需要走transct过程。这个逻辑由Stub的内部代理类Proxy来完成。

    主要方法介绍：

    法介绍
    DESCRIPTORBinder的唯一标识，一般用当前的Binder的类名表示，如com.kanghui.demo.aidl.IBookManager
    asInterface(android.os.IBinder obj)将服务端的Binder对象转换成客户端所需的AIDL接口类型的对象。
    asBinder用于返回当前的Binder对象
    onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)这个方法运行在服务端的Binder线程池中，当客户端发起跨进程请求时，服务端根据code确定目标方法，从data参数中取出所需参数，执行完后向apply写入返回值。
康小孩
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BAT大咖助力Android面试6-Binder面试详解
superjunjin的专栏
05-03 846
一，Linux内核的基础知识 二，Binder机制 在Android中的具体实现原理 三. 优点 参考自：https://blog.csdn.net/carson_ho/article/details/73560642 一，Linux内核的基础知识 1，进程隔离/虚拟地址空间 为了保证 安全性 &amp; 独立性，一个进程不能直接操作或者访问另一个进程，即Android的进...
Android Binder机制
02-26
- **Binder原理**：Binder机制基于C/S架构，服务端（Server）在自己的进程中提供服务，客户端（Client）通过Binder接口请求服务。Binder在用户空间和内核空间之间传递数据，实现进程间的通信。 - **三角色模型**：...
Android Binder机制 原理
ch853199769的博客
05-11 1079
Linux进程空间 内核模块/驱动 Binder 架构 Binder 机制 Binder 进程与线程 ServiceManager ServiceManager 启动 ServiceManager 注册服务 ServiceManager 获取服务 进行一次完整通讯 Linux进程空间 一个进程空间分为 用户空间 &amp;amp;amp; 内核空间（Kernel），即把进程内 用户 &amp;amp;a...
Android 进程间通信机制binder原理
知识应该共享，创造才应收费
07-21 1643
Android的binder机制在面试的时候经常被问到，说明它对咱们android开发非常的重要，咱们Android的系统中很多地方都使用了binder的通信，而说到binder，咱们就不得不提进程间的通信（IPC），那为什么需要进程间的通信呢？进程间的通信有啥好处和优势？读完本篇文章，相信你会得到答案。这个比较简单，我们大家都知道操作系统在最初的时候是单进程的，也就是一个操作系统上面只能跑一个进程。到后面随着技术的发展，所以有了多进程。...
2024年最全Android进程间通信（IPC）机制Binder介绍，android面试java
最新发布
2401_84545553的博客
05-08 1001
其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。下图是我进阶学习所积累的历年腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节祝大家都能得到自己心仪工作。
Android Binder机制原理
alankin的博客
05-22 6623
Android Binder机制原理 说起Binder，其实在我们开发中总是没有感觉到它的存在，但是往往在很多地方都间接的在使用它，比如我们再startAcivity的时候，必定要去调用ActivityManagerService，因为我们都知道Activity并不是我们直接new出来的，而是通过这个service创建出来的，然而这个service是处于另外的进程，我们就必须要通过binder获...
Android的Binder机制
m0_56144365的博客
03-19 870
Android中Activity,Service等组件需要和AMS通信，这种跨进程通信都是通过Binder完成的。
Binder机制原理解析
08-17
Binder机制是Android系统的核心组成部分，它是实现Android应用跨进程通信（IPC）的关键技术。相比于其他IPC方式，如Socket、Shared Memory、Signal，Binder在效率和内存管理方面具有显著优势，因为它只需要一次数据...
理解Android系统Binder机制
01-06
一、Binder机制概述 在Android开发中，很多时候我们需要用到进程间通信，所谓进程间通信，实现进程间通信的机制有很多种，比如说socket、pipe等，Android中进程间通信的方式主要有三种： 1.标准Linux Kernel IPC ...
Android Binder Aidl原理.pdf
12-24
Android Binder的AIDL（Android Interface Definition Language）原理是指Binder机制中使用AIDL语言来定义接口的原理。AIDL是一种IDL（Interface Definition Language），用于定义Binder接口的结构和行为。通过使用...
图解android Binder 实现机制
05-05
通过图解的方式，将Android Binder通信的根本原理呈现出来。
Android Binder机制完全解析
10-31
详见http://blog.csdn.net/huaxun66/article/details/52966087
安卓binder机制详解，技术总监都拍手叫好
m0_60635245的博客
03-10 1354
更多学习和讨论，欢迎加入我们的知识星球！
Android Binder机制浅析
singwhatiwanna
02-23 2万+
摘要Binder是android中一个很重要且很复杂的概念，它在系统的整体运作中发挥着极其重要的作用，不过本文并不打算从深层次分析Binder机制，有两点原因：1是目前网上已经有2篇很好的文章了，2是对Binder机制进行深入底层乃至驱动的分析这一过程相当困难且相当耗时，因此并不适合重复造轮子。本文的角度是对Android的Binder机制从整体和概念上进行分析，能够让大家很快明白到底什么是Bin
Andriod Binder原理解析
u010425418的博客
03-20 250
Andriod Binder原理解析 概述: Binder通信涉及的源码纷繁复杂,细节更是深得难以细究,本文试图以简洁的语言说明binder原理,以让读者理解binder大致框架和流程,至于具体的细节这里不错陈述，需要读者自己研读源码了. 由于java层的binder只是对c++层binder的封装调用,要想真正理解binder还是要从c++层分析,因此本文所涉及的代码均是c++层.文章最后也会贴个小demo 首先,binder是什么? 简单来说binder就是一套通信协议,可以和网络通信类.
Ubuntu Android binder 编译
kaerwar的博客
12-05 1899
binder驱动代码在drivers/android。在标准linux内核下，默认是不编译进去的通过官网下载通过命令下载1、命令下载使用1、编译内核代码依赖安装2、在源码根目录运行sudo make menuconfig 3、在menuconfig中敲入 “/” 回车搜索 CONFIG_ANDROID_BINDER_IPC 4、第4步中找到配置路径 drivers/android/Kconfig 5、运行sudo make bzImage -j46、如果出现如下报错修改源码目录的.config文件
Android AIDL最简单易懂的使用与解析（2）
acesheep_911的博客
09-12 216
在上篇文章 Android AIDL最简单易懂的使用与解析（1）中，我们学会了如何编写一个简单的 AIDL 来进行跨进程通信，本着知其然更要知其所以然的道理，在这一篇中我们就来具体看看 AIDL帮我们生成了一套基于 Binder 的怎样的接口吧~ 我们先来看看testAIDL的结构： 可以看到，testAIDL是一个接口，继承了 IInterface，而IInterface 就是进程间通信...
安卓binder机制浅析
m0_62089210的博客
10-11 368
Service是安卓服务组件，类似于一个没有界面的Activity，常用于耗时服务进程，例如音乐播放器，下载器等。与activity不同的是，实际应用service与activity的交流更加频繁。因此，这种利用intent传递数据的方式显然是不合适的。其中，Service与Activity的交互通信使用到了这一机制。为此，我写了service的小案例，以此来方便更好地理解binder通信机制。activity先获取了binder实例，再利用binder实例获取到了Service实例。
Android Binder机制原理（史上最强理解，没有之一）
热门推荐
可乐
07-23 12万+
Binder是Android系统进程间通信（IPC）方式之一
android binder机制原理
06-06
Android Binder机制是一种进程间通信（IPC）机制，它是Android系统中的核心组件之一。Binder机制通过将进程间的对象引用传递给其他进程来实现通信。它使用了一种称为Binder驱动程序的内核模块来管理进程间通信。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值