Binder详解

本篇开始去了解Binder的调用过程和运行机制，本文不会深入探讨Binder驱动以及底层的实现，而是以AIDL的使用理清Java层面的Binder的实现和通信过程。

本文依然按照惯例，先总结下AIDL的使用步骤，然后根据日志、调试等信息整理其调用逻辑。如果还不知道AIDL的使用方法的请参考http://blog.csdn.net/u012481172/article/details/50925381。

AIDL的使用步骤

AIDL通常用于Service和其它组件（如Activity）的通信。为什么要用AIDL呢，因为AIDL可以帮我们快速实现跨进程通信，如果项目中的Service和Activity分别位于不同的两个进程，而他们又需要互相通信，这时就涉及到跨进程通信了，此时就是AIDL的使用场景了。

（1）编写AIDL文件

这一步请注意，AIDL文件只支持基本类型数据的远程传输，而对于我们自定义的实体对象，需要实现Parcelable接口才行，具体不再赘述，看之前的文章。

（2）在Service中继承Stub类，并重写aidl文件中接口定义的方法实现自己的业务。编译器会自动提示你去继实现哪些方法的，因为Stub是一个抽象类，并且在aidl中的方法在Stub中仍然是待实现的空方法。以下是根据AIDL生成的类：

package com.example.appa;

import android.os.IInterface;
import android.util.Log;

public interface CustomBinder extends android.os.IInterface {
	final String TAG = "Binder";

	public static abstract class Stub extends android.os.Binder implements
			com.example.appa.CustomBinder {
		private static final java.lang.String DESCRIPTOR = "com.example.appa.Test";

		public Stub() {
			this.attachInterface((IInterface) this, DESCRIPTOR);
			Log.e(TAG, "CustomBinder.Stub-->" + "Stub()构造器执行");
		}

		/**
		 * 将IBinder对象转换成Test接口实例
		 *
		 * @param obj
		 *            这是一个Binder实例，如果Service另外开启了一个进程那么此obj就是一个Binder.
		 *            BinderProxy实例，
		 *            如果Service没有另外开启一个进程，那么此obj就是一个Binder实例。总之，obj的类型取决于Binder是本地的还是服务端的
		 *            通常我们把Service另外开启一个进程当做服务端
		 * @return
		 */
		public static com.example.appa.CustomBinder asInterface(
				android.os.IBinder obj) {
			if ((obj == null)) {
				return null;
			}
			// 这里就会查找本地Binder对象，如果找到即iin不为null就说明Server端和Client端在同一个进程，那么此时obj就是一个Binder实例
			// 如果没有找到即iin为null就说明Server和Client不在同一个进程，此时iin就是null了。然后就要去创建Test.Stub.Proxy实例
			android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
			if (((iin != null) && (iin instanceof com.example.appa.Test))) {
				return ((com.example.appa.CustomBinder) iin);
			}
			Log.e(TAG, "CustomBinder.Stub-->" + "asInterface()执行：" + iin);
			return new com.example.appa.CustomBinder.Stub.Proxy(obj);
		}

		@Override
		public android.os.IBinder asBinder() {
			Log.e(TAG, "CustomBinder.Stub-->" + "asBinder()");
			return this;
		}

		/*
		 * Client调用hello方法的线程挂起等待返回；驱动完成一系列的操作之后唤醒Server进程，
		 * 调用了Server进程本地对象的onTransact函数（实际上由Server端线程池完成）。 (non-Javadoc)
		 *
		 * @see android.os.Binder#onTransact(int, android.os.Parcel,
		 * android.os.Parcel, int)
		 */
		@Override
		public boolean onTransact(int code, android.os.Parcel data,
				android.os.Parcel reply, int flags)
				throws android.os.RemoteException {
			Log.e(TAG, "CustomBinder.Stub-->" + "onTransact()执行");
			switch (code) {
			case INTERFACE_TRANSACTION: {
				reply.writeString(DESCRIPTOR);
				return true;
			}
			case TRANSACTION_hello: {
				Log.e(TAG, "CustomBinder.Stub-->"
						+ "TRANSACTION_hello执行:服务端执行本地hello方法");
				data.enforceInterface(DESCRIPTOR);
				java.lang.String _arg0;
				_arg0 = data.readString();
				// 这里调用了服务端本地的hello（）方法，并且获得结果，将结果写回驱动，
				// 然后驱动唤醒挂起的Client进程里面的线程并将结果返回。于是一次跨进程调用就完成了。
				java.lang.String _result = this.hello(_arg0);
				reply.writeNoException();
				reply.writeString(_result);
				return true;
			}
			}
			return super.onTransact(code, data, reply, flags);
		}

		/**
		 * Stub的代理类，也就是服务端的代理对象
		 *
		 * @author Administrator
		 *
		 */
		private static class Proxy implements com.example.appa.CustomBinder {
			private android.os.IBinder mRemote;

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

			@Override
			public android.os.IBinder asBinder() {
				Log.e(TAG, "CustomBinder.Stub.Proxy-->" + "asBinder()执行");
				return mRemote;
			}

			public java.lang.String getInterfaceDescriptor() {
				Log.e(TAG, "CustomBinder.Stub.Proxy-->"
						+ "getInterfaceDescriptor()执行");
				return DESCRIPTOR;
			}

			@Override
			public java.lang.String hello(java.lang.String content)
					throws android.os.RemoteException {
				Log.e(TAG, "CustomBinder.Stub.Proxy-->" + "hello()执行");
				android.os.Parcel _data = android.os.Parcel.obtain();
				android.os.Parcel _reply = android.os.Parcel.obtain();
				java.lang.String _result;
				try {
					_data.writeInterfaceToken(DESCRIPTOR);
					_data.writeString(content);
					// 前面说过，只有当Server和Client不在同一个进程才会执行此代理的方法，而如果Server和Client不在同一个进程
					// 那mRemote就是一个Binder.BinderProxy实例，那么此transact（）方法就是Binder.BinderProxy的方法，他是一个本地方法
					//
					mRemote.transact(Stub.TRANSACTION_hello, _data, _reply, 0);
					_reply.readException();
					_result = _reply.readString();
				} finally {
					_reply.recycle();
					_data.recycle();
				}
				return _result;
			}
		}

		static final int TRANSACTION_hello = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
	}
    /**
     * 这个方法只是Stub的一个抽象方法，是在TestService中继承的时候重写了
     * @param content
     * @return
     * @throws android.os.RemoteException
     */
	public java.lang.String hello(java.lang.String content)
			throws android.os.RemoteException;
}

在以上两不完成以后实际上就是创建了一个Server端，接下来就是Client的使用了。

（3）在Service（此处demo中是TestService）中继承Stub定义自己的Binder。

	private class MyBinder extends CustomBinder.Stub {
		@Override
		public String hello(String content) throws RemoteException {
			String con = "这是从Service发出来的内容..." + content;
			Log.e(TAG, "TestService.MyBinder-->"+"hello()执行");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return con;
		}

	}

（4）在Activity中实现ServiceConnection接口，创建其实例。

	private class MyServiceConnection implements ServiceConnection {
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			showToast("服务已连接");
			//mBinderConnection是CustomBinder类型的，这里就是将Binder驱动返回的IBinder对象转换成具体的我们定义的CustomBinder
			mBinderConnection = CustomBinder.Stub.asInterface(service);
			try {
				//这里就是客户端调用远程的hello（）方法了。
				String str = mBinderConnection.hello("来自Activity的问候");
				Log.e(TAG,
						"MainActivity.MyServiceConnection-->"
								+ "onServiceConnected()执行，此时Service已经连接上，Server和Client可以通信了");
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}
		@Override
		public void onServiceDisconnected(ComponentName name) {
			mBinderConnection = null;
		}
	}

（5）调用bindService（）即可。

AIDL跨进程的调用过程

当我们Server端（TestService）和Client端（MainActivity）都准备好了之后，客户端发起调用时，比如MainActivity中需要调用hello（）方法，我们调用hello（）之后这中间发生了什么呢？他的调用顺序是按照如下过程来的：

第一步：执行Stub的构造器，因为当我们调用bindService（）的时候在Service中的onCreate中new了CustomBinder.Stub对象，从而调用了Stub的构造器。

第二步：执行了Stub的asInterface（）：这个是onServiceConnected（）中获取Binder驱动发送过来的Stub实例。

第三步：就调用了Stub.Proxy的hello（）方法了，因为TestService和当前Activity不是一个进程的，所以会使用Stub.Proxy实例的hello（），这个hello（）会通过BinderProxy去调用Stub的onTransact（）方法，然后就进入第四步。

第四步：调用了Stub的onTransact（）方法，此方法就是用于调用服务端本地的hello（）方法，在这里，这个“服务端本地”就是指Stub.hello()具体来说就是我们在TestService中继承Stub重写的那个hello（）方法，也就是TestService.MyBinder.hello()。

AIDL源码分析

1、Client端获取远程Binder对象

就像上面我们的ServiceConnection中的onServiceConnected（）方法中的那样，是客户端是通过Stub的asInterface（）方法来获取远程具体对象的：

public void onServiceConnected(ComponentName name, IBinder service) {
			showToast("服务已连接");
			//mBinderConnection是CustomBinder类型的，这里就是将Binder驱动返回的IBinder对象转换成具体的我们定义的CustomBinder
			mBinderConnection = CustomBinder.Stub.asInterface(service);

这一步要注意，因为，如果服务端（TestService）和客户端(mainActivity)不在同一个进程，那么此处的onServiceConnectd（）中的service参数就是一个TestService中我们定义的MyBinder实例，它对于程序员来说是一个本地的Binder；如果服务端和客户端不在一个进程中，此处的service参数就是一个android.os.Binder.BinderProxy实例，一定要记住这一点。好，接下来我们去看看CustomBinder.Stub的asInterface（）方法如下：

	public static com.example.appa.CustomBinder asInterface(
				android.os.IBinder obj) {
			// 如果客户端和服务端还没建立连接就直接return null
			if ((obj == null)) {
				return null;
			}
			// 这里就会查找本地Binder对象，如果找到即iin不为null就说明Server端和Client端在同一个进程，
		    //那么此时obj就是一个Binder实例
			android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
			if (((iin != null) && (iin instanceof com.example.appa.Test))) {
				return ((com.example.appa.CustomBinder) iin);
			}
			Log.e(TAG, "CustomBinder.Stub-->" + "asInterface()执行：" + iin);
			// 如果没有找到即iin为null就说明Server和Client不在同一个进程，此时iin就是null了。
		    //然后就要去创建Test.Stub.Proxy实例,注意，这里创建Proxy的时候传递了一个obj，这个obj一定是Binder.BinderProxy的实例

			return new com.example.appa.CustomBinder.Stub.Proxy(obj);
		}

正如上面的注释那样，如果Server（此处的Server就是TestService）和Client（就是MainActivity）是同一个进程那么就会直接返回Binder实例，如果不在同一个进程就会返回一个Stub.Proxy实例。这是有很大区别的，如果在同一个进程那么方法调用就是直接本地调用了，如果不在同一个进程就需要代理Proxy去利用BinderProxy进行远程调用了。

2、客户端调用服务端方法

（1）服务端和客户端在同一个进

如果说服务端和客户端在同一个进程，即不指定TestService和Activity的process属性，那么当我们在客户端调用CustomBinder的hello（）方法时就是直接调用了Stub的hello（实际上是TestService中的MyBinder重写的hello方法）方法，不需要走Stub.Proxy的流程。

（2）服务端和客户端不在同一个进程

这里我们将TestService的process属性取一个别名，就是让TestService运行在另一个进程，此时服务端和客户端就不在一个进程了，这时候我们在客户端调用服务端的hello（）方法时，情况就不一样了，因为上面说了，当服务端和客户端不在一个进程时，实际上调用的就是Stub.Proxy的hello（）方法，下面我们去看下Stub.Proxy的hello（）方法：

			@Override
			public java.lang.String hello(java.lang.String content)
					throws android.os.RemoteException {
				Log.e(TAG, "CustomBinder.Stub.Proxy-->" + "hello()执行");
				android.os.Parcel _data = android.os.Parcel.obtain();
				android.os.Parcel _reply = android.os.Parcel.obtain();
				java.lang.String _result;
				try {
					_data.writeInterfaceToken(DESCRIPTOR);
					_data.writeString(content);
					// 前面说过，只有当Server和Client不在同一个进程才会执行此代理的方法，而如果Server和Client不在同一个进程
					// 那mRemote就是一个Binder.BinderProxy实例，那么此transact（）方法就是Binder.BinderProxy的方法，
					//他是一个本地方法,是交由Binder驱动去告诉服务端去执行onTransact（0方法。
					mRemote.transact(Stub.TRANSACTION_hello, _data, _reply, 0);
					_reply.readException();
					_result = _reply.readString();
				} finally {
					_reply.recycle();
					_data.recycle();
				}
				return _result;
			}
		}

		static final int TRANSACTION_hello = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
	}

其实Stub.Proxy的hello（）方法什么也没做，只是将一些必要的数据写入和读出Parcel，然后通过mRemote来调用transact（）方法去告诉Binder驱动通知服务端调用真实的hello（）方法。mRemote之前说过了，当服务端和客户端不在同一个进程时才会创建Stub.Proxy并且传递一个Binder.BinderProxy实例进来，此mRemote就是一个Binder.BinderProxy实例，transact（）方法自然就是BinderProxy的方法了，他是一个native方法，用于告诉Binder驱动去通知服务端调用onTransact（）方法调用真实的hello（）方法！也就是TestService.MyBinder的hello（）方法！！！好，这一步我们说了客户端向服务端请求调用hello（）方法，然而代理Stub.Proxy并没有直接去调用，而是告知Binder驱动。当我们通过mRemote调用transact（）时客户端线程会被挂起，直到服务端有结果返回，确切的说是要等到Stub的onTransact（）方法返回。

3、服务端响应客户端请求

注意：如果服务端和客户端不在一个进程，那么就不存在这一步了，请忽略。

上一步说了，客户端已经调用hello（）向服务端发起请求，而那时候服务端还没有收到通知，因为客户端的请求被服务端的代理Stub.Proxy发送给Binder驱动了（通过BinderProxy的transac方法实现的），Binder驱动做一些必要的操作后再通知服务端有客户端请求了，你快去执行onTransact（）方法来响应请求吧！接下来我们看下Stub的onTransact（）方法：

		@Override
		public boolean onTransact(int code, android.os.Parcel data,
				android.os.Parcel reply, int flags)
				throws android.os.RemoteException {
			Log.e(TAG, "CustomBinder.Stub-->" + "onTransact()执行");
			switch (code) {
			case INTERFACE_TRANSACTION: {
				reply.writeString(DESCRIPTOR);
				return true;
			}
			case TRANSACTION_hello: {
				Log.e(TAG, "CustomBinder.Stub-->"
						+ "TRANSACTION_hello执行:服务端执行本地hello方法");
				data.enforceInterface(DESCRIPTOR);
				java.lang.String _arg0;
				_arg0 = data.readString();
				// 这里调用了服务端本地的hello（）方法，并且获得结果，将结果写回驱动，
				// 然后驱动唤醒挂起的Client进程里面的线程并将结果返回。于是一次跨进程调用就完成了。
				java.lang.String _result = this.hello(_arg0);
				reply.writeNoException();
				reply.writeString(_result);
				return true;
			}
			}
			return super.onTransact(code, data, reply, flags);
		}

其它不用管，我们就看上面注释的地方，这一行代码：java.lang.String _result = this.hello()，它就是去调用了服务端（我们此时是处于服务端的情景之中）自己的hello（）方法，也就是TestService.MyBinder的hello（）方法，并返回结果，将结果写到reply中去，即写回Binder驱动，之后Binder驱动就唤醒还挂着的客户端线程，并将结果返回，这样，一个跨进程通信的过程就结束了。

小结

如果Server和Clienr在同一个进程，那么Server会直接调用Service中的相关方法，如果Server和Clienr不在同一个进程，那么就会通过跨进程通信远程调用，首先是Stub的代理类使用BinderProxy执行其transact（），这个方法是一个native的，里面进行了一系列的函数调用，最后就交给Binder驱动完成了；在通信过程中，Client进程陷入内核态，Client调用hello方法的线程挂起等待返回；驱动完成一系列的操作之后唤醒Server进程，调用了Server进程本地对象（Stub）的onTransact函数（实际上由Server端线程池完成）。我们再看Binder本地对象的onTransact方法（这里就是Stub类里面的此方法），然后onTransact（）就调用了服务端的hello（）方法并将结果写回Binder驱动，然后驱动唤醒挂起的Client进程里面的线程并将结果返回，一次跨进程远程调用就结束了。

Android中Binder相关接口

（1）IBinder

IBinder是一个接口，它代表了一种跨进程传输的能力；只要实现了这个接口，就能将这个对象进行跨进程传递；这是驱动底层支持的；在跨进程数据流经驱动的时候，驱动会识别IBinder类型的数据，从而自动完成不同进程Binder本地对象以及Binder代理对象的转换。

（2）Binder

代表的其实就是Binder本地对象。BinderProxy类是Binder类的一个内部类，它代表远程进程的Binder对象的本地代理；这两个类都继承自IBinder, 因而都具有跨进程传输的能力；实际上，在跨越进程的时候，Binder驱动会自动完成这两个对象的转换。

到此，我们基本理清了Server端和Client端的跨进程通信过程，那么我们是否想过，这一切都是建立在客户端获取到服务端对象的基础上的，也就是我们在Activity中实现ServiceConnection接口，他的onServiceConnected（）方法返回给我们一个远程的服务端对象。那么我们是否考虑过，这个onServiceConnected（）方法何时调用，即何时会返回给我们一个远程的对象？这就是bindService（）所处理的了，下一篇我们就解开bindService（）之谜。

时间： 2024-11-10 12:04:52

Binder详解的相关文章

[gitbook] Android框架分析系列之Android Binder详解

请支持作者原创: https://mr-cao.gitbooks.io/android/content/android-binder.html Android Binder详解 Table of Contents 1. binder简介 2. binder的实现 2.1. IBinder类简介 2.2. IInterface类简介 2.3. BpBinder和BBinder简介 2.4. ProcessState和IPCThreadState简介 2.5. ServiceManager简介 2.

安卓IPC机制之Binder详解

IPC(Inter-Process Communication,跨进程通信)是指两个进程之间数据交换的过程,因此我们首先必须了解什么是进程,什么是线程. 进程:进程是正在运行的程序的实例,与程序相比,它更强调动态的概念,与线程相比,进程是线程的容器,一个进程可以包含多个线程但至少包含一个线程.进程是任务调度的基本单位,是系统资源的分配单位. 线程:线程是进程中的一条执行路径,它只能隶属于某一个进程,在支持多线程的操作系统或程序设计语言中(如java),线程是任务调度的单位,但它不是系统资源分配的

学习ASP .NET MVC5官方教程总结（七）Edit方法和Edit视图详解

学习ASP .NET MVC5官方教程总结(七)Edit方法和Edit视图详解 在本章中,我们研究生成的Edit方法和视图.但在研究之前,我们先将 release date 弄得好看一点.打开Models\Movie.cs 文件.先添加一个引用: <span style="font-size:14px;">using System.ComponentModel.DataAnnotations;</span> 然后在Movie类中添加以下代码: [Display(

【转】@RequestParam @RequestBody @PathVariable 等参数绑定注解详解

@RequestParam @RequestBody @PathVariable 等参数绑定注解详解 2014-06-02 11:24 23683人阅读 评论(2) 收藏 举报 目录(?)[+] 引言: 接上一篇文章,对@RequestMapping进行地址映射讲解之后,该篇主要讲解request 数据到handler method 参数数据的绑定所用到的注解和什么情形下使用: 简介: handler method 参数绑定常用的注解,我们根据他们处理的Request的不同内容部分分为四类:(主

Android 4.4 KitKat NotificationManagerService使用详解与原理分析(一)__使用详解

概况 Android在4.3的版本中(即API 18)加入了NotificationListenerService,根据SDK的描述(AndroidDeveloper)可以知道,当系统收到新的通知或者通知被删除时,会触发NotificationListenerService的回调方法.同时在Android 4.4 中新增了Notification.extras 字段,也就是说可以使用NotificationListenerService获取系统通知具体信息,这在以前是需要用反射来实现的. 转载请

WebApi 接口参数不再困惑：传参详解

转自:http://www.cnblogs.com/landeanfen/p/5337072.html 阅读目录 一.get请求 1.基础类型参数 2.实体作为参数 3.数组作为参数 4.“怪异”的get请求 二.post请求 1.基础类型参数 2.实体作为参数 3.数组作为参数 4.后台发送请求参数的传递 三.put请求 1.基础类型参数 2.实体作为参数 3.数组作为参数 四.delete请求 五.总结 正文 前言:还记得刚使用WebApi那会儿,被它的传参机制折腾了好久,查阅了半天资料.如

SpringMVC学习总结(三)——Controller接口详解(2)

4.5.ServletForwardingController 将接收到的请求转发到一个命名的servlet,具体示例如下: package cn.javass.chapter4.web.servlet; public class ForwardingServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws Servle

.Net AppDomain详解（二）

AppDomain 类 表示应用程序域,它是一个应用程序在其中执行的独立环境. 此类不能被继承. 命名空间:   System程序集:  mscorlib(位于 mscorlib.dll) 继承层次结构 System.Object??System.MarshalByRefObject????System.AppDomain [ClassInterfaceAttribute(ClassInterfaceType.None)] [ComVisibleAttribute(true)] public s

Android 4.4 KitKat NotificationManagerService使用详解与原理分析(二)__原理分析

前置文章: <Android 4.4 KitKat NotificationManagerService使用详解与原理分析(一)__使用详解> 转载请务必注明出处:http://blog.csdn.net/yihongyuelan 概况 在上一篇文章<Android 4.4 KitKat NotificationManagerService使用详解与原理分析(一)__使用详解>中详细介绍了NotificationListenerService的使用方法,以及在使用过程中遇到的问题和