安卓IPC机制之Binder详解

原创 2016年06月02日 12:17:05

IPC(Inter-Process Communication,跨进程通信)是指两个进程之间数据交换的过程,因此我们首先必须了解什么是进程,什么是线程。

进程:进程是正在运行的程序的实例,与程序相比,它更强调动态的概念,与线程相比,进程是线程的容器,一个进程可以包含多个线程但至少包含一个线程。进程是任务调度的基本单位,是系统资源的分配单位。

线程:线程是进程中的一条执行路径,它只能隶属于某一个进程,在支持多线程的操作系统或程序设计语言中(如java),线程是任务调度的单位,但它不是系统资源分配的单位,线程完全继承父进程占有的资源,但它执行时,也有属于自己的运行现场,如PC寄存器的值,栈空间等。

关于进程与线程内存资源方面的知识请参看我的博文:http://blog.csdn.net/htq__/article/details/50822582

IPC机制不是安卓独有的,任何一个操作系统都需要IPC机制,如linux中可以通过命名管道,共享主存,信号量,Socket,消息队列等方式来呢实现IPC机制,安卓虽然是基于linux内核的,但是安卓中的IPC机制与linux不完全相同,如Binder机制就是安卓的IPC中的一大特色,这种IPC机制在linux中是不存在的。本博客将详细讲解安卓中的Binder机制。

在安卓开发中Binder主要用在Service中,包括AIDL与Messenger,而Messenger的底层仍然是AIDL,关于这些内容,读者可以参看我的博客:点击打开链接。所以本博客将以AIDL为例详细讲解Binder的IPC原理。


首先创建一个AIDL的java包,在该包中创建三个文件Book.java,Book.aidl和IBookManager.aidl代码如下:

public class Book implements Parcelable {  //Book.java

    public int bookId;
    public String bookName;

    public Book() {

    }

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

    public int describeContents() {
        return 0;
    }

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

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

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

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

    @Override
    public String toString() {
        return String.format("[bookId:%s, bookName:%s]", bookId, bookName);
    }

}

parcelable Book;//Book.aidl


interface IBookManager {  //IBookManager.aidl
     List<Book> getBookList();
     void addBook(in Book book);
}

其中Book.java是一个表示图书信息的java类,它实现了Parcelable接口,Book.aidl是Book类在AIDL中的声明,IBookManager.aidl是我们定义的一个接口,注意尽管Book类与IBookManager类位于同一个包中,但是在IBookManager.aidl文件中仍需要导入Book类,这是aidl文件与普通java的class文件的不同之处。

当我们定义好上述文件后Eclipse会自动为我们在工程的gen目录下生成一个与IBookManager.aidl文件相对应的java类IBookManager.java,我们来看一下其源码:

public interface IBookManager extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.test.aidl.IBookManager
{
private static final java.lang.String DESCRIPTOR = "com.test.aidl.IBookManager";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
 * Cast an IBinder object into an com.test.aidl.IBookManager interface,
 * generating a proxy if needed.
 */
public static com.test.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.test.aidl.IBookManager))) {
	  return ((com.test.aidl.IBookManager)iin);
	}
        return new com.test.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
{
	switch (code)
    {
	case INTERFACE_TRANSACTION:
      {
	   reply.writeString(DESCRIPTOR);
          return true;
      }
       case TRANSACTION_getBookList:
     {
 	data.enforceInterface(DESCRIPTOR);
	java.util.List<com.test.aidl.Book> _result = this.getBookList();
	reply.writeNoException();
	reply.writeTypedList(_result);
	return true;
      }
      case TRANSACTION_addBook:
     {
	data.enforceInterface(DESCRIPTOR);
	com.test.aidl.Book _arg0;
	if ((0!=data.readInt())) {
		_arg0 = com.test.aidl.Book.CREATOR.createFromParcel(data);
	}
	else {
	_arg0 = null;
	}
	this.addBook(_arg0);
	reply.writeNoException();
	return true;
	}
      }
	return super.onTransact(code, data, reply, flags);
}

private static class Proxy implements com.test.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.test.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.test.aidl.Book> _result;
	try {
		_data.writeInterfaceToken(DESCRIPTOR);
		mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
		_reply.readException();
		_result = _reply.createTypedArrayList(com.test.aidl.Book.CREATOR);
	}
	finally {
	_reply.recycle();
	_data.recycle();
	}
	return _result;
     }

@Override 
public void addBook(com.test.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);
   }
     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);

	public java.util.List<com.test.aidl.Book> getBookList() throws android.os.RemoteException;
	public void addBook(com.test.aidl.Book book) throws android.os.RemoteException;

}
可以看到系统为我们自动创建的IBookManager文件仍然是一个接口,它继承自android.os.IInterface。在其内部创建了一个抽象的静态类Stub,它继承自Binder类同时实现了IBookManager接口(但未实现该接口中的方法,因为该接口中的方法是我们在创建一个Service时在其内部创建Binder类时实现的,因此该Stub仍然属于一个抽象类)。


我们首先来梳理一下IBookManager接口的内容,可以看到,首先包含两个方法的声明getBookList和addBook,显然这两个方法是我们在IBookManager.aidl文件中声明的两个方法,另外它还定义了两个整型的id用于标识这两个方法,这两个id在其内部代理类Proxy的方法的transact过程中用于判断客户端请求的是哪一个方法。另外还包含一个内部类Stub,该Stub是一个Binder类,在这个Stub类中定义了一个内部类Proxy。


下面介绍一下上述代码中的一些重要方法:

public static com.test.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.test.aidl.IBookManager))) {//此时表示客户端与服务端位于同一个进程中,直接返回IInterface对象
	  return ((com.test.aidl.IBookManager)iin);
	}
        return new com.test.aidl.IBookManager.Stub.Proxy(obj);<span style="font-family: Arial, Helvetica, sans-serif;">//此时表示客户端与服务端不在同一个进程中,此时返回代理类Proxy对象</span>

 }
asInterface正是我们在bindServide的组件中使用ServiceConnection时首先要使用的一个方法,可以看到在方法中首先通过obj.queryLocalInterface(DESCRIPTOR)根据传入的参数获取IInterface对象,然后判断该对象是否为IBookManager类,若是则直接返回该对象,此时表示客户端与服务端位于同一个进程中,即绑定的是本地服务,即在ServiceConnection的onServiceConnected中我们是这么调用的Binder对象

public void onServiceConnected(ComponentName name, IBinder service) {    
            myBinder = (MyService.MyBinder) service;   //绑定的是本地服务 
            myBinder.doSomething();    
        }  


否则返回IBookManager类的内部代理对象IBookManager.Stub.Proxy(obj),也就意味着客户端与服务端位于不同的进程中,此时客户端调用的方法将会是Proxy代理类中定义的方法,而不是直接调用的在Service中实现的IBookManager.aidl文件中的方法。即绑定的是远程服务,即在ServiceConnection的onServiceConnected中我们是这么调用的Binder对象

public void onServiceConnected(ComponentName name, IBinder service) {    
            myBinder = MyAIDL.Stub.asInterface(service)  //绑定的是远程服务
            myBinder.doSomething();    
        }   

通过上面的分析可知,当绑定的是远程服务时,当在客户端调用addBook将会调用代理类中的 addBook方法,因此我们接下来看一下Proxy#addBook

@Override 
public void addBook(com.test.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);
   }
     mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
     _reply.readException();
  }
     finally {
    _reply.recycle();
     _data.recycle();
     }
 }
可以看到在该方法中首先创建了一个输入型参数Parce对象_data与输出型Parcel对象_reply,然后向该输入型参数Parce对象_data中写入一些数据,然后调用了mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);语句,当执行该语句时,即表示客户端发起RPC(远程过程调用)请求,此时当前线程会被挂起,直至RPC过程返回后,当前线程继续执行。注意该mRemote对象即为在创建该Proxy对象时传入的Binder对象,即mRemote是一个Binder对象,我们看一下Binder中的transact函数,代码如下:

 /**
     * Default implementation rewinds the parcels and calls onTransact.  On
     * the remote side, transact calls into the binder to do the IPC.
     */
    public final boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        if (false) Log.v("Binder", "Transact: " + code + " to " + this);
        if (data != null) {
            data.setDataPosition(0);
        }
        boolean r = onTransact(code, data, reply, flags);
        if (reply != null) {
            reply.setDataPosition(0);
        }
        return r;
    }

可以看到transact函数被final修饰,即该函数是不允许被继承重写的,在该函数中最重要的一个语句: boolean r = onTransact(code, data, reply, flags);即在transact函数中调用了onTransact函数,而onTransact函数一般是要求被重写的,而重写的过程是根据我们自己定义的aidl文件IDE自动帮我们完成的,如上面所示的根据IBookManager.aidl文件自动生成IBookManager.java文件,在这个IBookManager.java文件中onTransact函数被重写。

这个onTransact函数是Binder机制运行的关键,该函数运行在服务端的Binder线程池中,当客户端发起跨进程请求时,即调用transact函数时,远程请求的数据会通过系统底层交给该函数来执行,该函数的完整签名为: public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags),服务端通过code可以确定客户端调用的是那个方法,然后从data中取出目标方法所带的参数(如果目标方法带参数的话),然后执行目标方法,当目标方法执行完毕后,就向reply中写入返回值(如果目标方法存在返回值的话),需要注意的是如果该函数返回false,则客户端的请求会失败,利用该特性可以做权限验证,因为我们也不希望任意一个进程都可以随意访问我们的服务。

通过上述的分析相信读者对Binder的运行机制的整个过程已经非常熟悉了,至于系统底层的Binder是如何传输数据的这个不重要,也不需要我们去理解,我们只需要知道Binder的运行机制的整个过程,下面用图示的方式来讲上述过程表示出来。注意下面图示仅仅表示绑定远程服务的过程,因为绑定本地服务不涉及IPC机制。如下:


对上述图示还是稍作解释,首先在客户端Client的ServiceConnection的onServiceConnected(ComponentName name, IBinder service) 方法中我们是通过   myBinder = MyAIDL.Stub.asInterface(service)语句将service转换为Binder对象,即调用的是asInterface方法而不是使用(MyService.MyBinder) service的类型转换的方式,则表示我们要获取的是远程服务而不是本地服务,那么接下来 myBinder调用的addBook(book);这个方法将会在其内部调用Binder的transact方法用来发起RPC请求,此时客户端Client被挂起,Binder的transact方法是一个final方法,不允许被修改,在该方法中调用了onTransact方法,该方法运行在服务端的Binder线程池中,该方法是整个Binder机制运行的关键,在该方法中完成IPC数据的读取与写入,该方法返回值将写入_reply参数中,然后RPC过程结束,返回数据给客户端,客户端Client被唤醒。

另外因为服务端的Binder方法是运行在Binder线程池中的,所以Binder中的方法不管是否耗时都应该采用同步的方式去实现,因为它已经运行在一个线程中。







版权声明:本文为博主原创文章,未经博主允许不得转载。转载请注明出处http://blog.csdn.net/htq__

相关文章推荐

《老罗的Android之旅》阅读笔记——IPC机制Binder

Binder真心复杂,看了两天好多内容没懂!决定再给自己一个星期的时间,加油! 下面先简单整理下这两天看的内容: Android系统Binder机制中的四个组件Client、Server、Ser...
  • WYYZ5
  • WYYZ5
  • 2014年12月12日 11:06
  • 865

填坑法---快速搞定快速排序算法

填坑法快速搞定快速排序

安卓IPC之利用AIDL分析Binder的工作过程

Binder是安卓中的一个类,实现了IBinder接口,是安卓中的一种跨进程通信手段。 在安卓开发中,Binder主要应用于服务中,包括AIDL和Messenger,而Messenger的底层实现也是...
  • NKPDQZ
  • NKPDQZ
  • 2017年03月02日 14:46
  • 157

Android的IPC机制Binder的详解(转发)

第一部分 Binder的组成 1.1 驱动程序部分驱动程序的部分在以下的文件夹中:Java代码  kernel/include/linux/binder.h    kernel/drive...
  • sdhjob
  • sdhjob
  • 2011年01月04日 19:19
  • 1396

android进程通信IPC机制之Binder详解

Android Binder机制原理(史上最强理解,没有之一) 2015-07-23 14:07 37876人阅读 评论(10) 收藏 举报 本文章已收录于: ...

Android IPC机制——Binder详解

IPC是指Android中的进程间通信,即在不同进程之间传递消息数据,Android中可实现进程通信的方法有很多,比如Intent、ContentProvider、Messenger、Binder或是...
  • Mr_Sk
  • Mr_Sk
  • 2016年02月25日 22:33
  • 679

Android的IPC机制Binder的详解汇总

转载自:http://java-admin.iteye.com/blog/717888 第一部分 Binder的组成  1.1 驱动程序部分驱动程序的部分在以下的文件夹中: Ja...

Android的IPC机制Binder的详解汇总

1.1 驱动程序部分驱动程序的部分在以下的文件夹中: Java代码  kernel/include/linux/binder.h  kernel/drivers/android/binder.c   ...

Android IPC机制Binder简要介绍

  • 2016年07月16日 07:37
  • 399KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:安卓IPC机制之Binder详解
举报原因:
原因补充:

(最多只允许输入30个字)