码迷,mamicode.com
首页 > 其他好文 > 详细

Binder详解

时间:2016-04-26 20:08:44      阅读:193      评论:0      收藏:0      [点我收藏+]

标签:

        本篇开始去了解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()之谜。

Binder详解

标签:

原文地址:http://blog.csdn.net/u012481172/article/details/51093846

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!