IPC-AIDL的使用实例和分析

IPC-AIDL的使用实例

这份笔记主要是为了记录跨进程通信IPC的其中方法之一的AIDL 的使用.

需求假设:现在2个不同的应用需要相互直接传递消息,并且客户端还需要调用服务器的方法.这个时候使用AIDL 就是很好的选择.为了使这份笔记有更好的价值,这里客户端要求可以接到服务器的通知也就是说客户端让服务器做了一件事件,服务端做好了之后需要告诉客户端.也就是观察者模式.

当然在某些情况下使用Messenger也能解决这个需求,但是Messenger本质也是AIDL.后面也会在其他笔记里面记录如果使用Messenger来实现.

注意:  Messenger的消息传递是串行的,也就是说服务端是按照顺序一个个来来处理.不适合有大量并发请求的.这个时候用使用AIDL就合适一些.

这里为了方便,客户端就是一个Activity,服务端就是一个Service.2者在同一个app内,只是在不同的进程中.如果2个不同的应用需要实现上面的需求,只要把这里服务端的AIDL 文件拷贝到客户端的应用可以的.原理是移植的.

1.服务端

    服务端首先创建一个Service用来监听客户端发起的请求,然后创建一个AIDL文件,将暴露给客户端的的接口在这个AIDL文件里面声明,最后在Servie中实现这个AIDL接口就可以了.

2.客户端

先绑定到服务端的Service,绑定成功之后,将服务端返回的Binder对象转换为AIDL接口类型,接口就可以调用AIDL中的方法了.

3.实现代码

这里以客户端向服务端添加书籍为例

相关代码目录截图:

3.1AIDL文件

Book.aidl

package com.example.aidl;

parcelable Book;  

Book.java

   
   
package com.example.aidl;
import android.os.Parcel;
import android.os.Parcelable;
public class Book implements Parcelable{
	public int bookId;
	public String bookName ;
	
	public Book(int bookId, String bookName) {
		super();
		this.bookId = bookId;
		this.bookName = bookName;
	}
	public Book(Parcel in){
		bookId = in.readInt();
		bookName = in.readString();
	}
	
	
	@Override
	public int describeContents() {
		return 0;
	}
	@Override
	public void writeToParcel(Parcel dest, int flags) {
		dest.writeInt(bookId);
		dest.writeString(bookName);
		
	}
	
	public static final Parcelable.Creator<Book> CREATOR = new Creator<Book>() {
		
		@Override
		public Book[] newArray(int size) {
			return new Book[size];
		}
		
		@Override
		public Book createFromParcel(Parcel source) {
			return new Book(source);
		}
	};
	
	
	
}

IBookManager.aidl

package com.example.aidl;

import com.example.aidl.Book;

import com.example.aidl.IOnNewBookListener;

interface IBookManager{

List<Book> getBookList();

void addBook(in Book book);

void registerListener(IOnNewBookListener listener);

void unregistenerListener(IOnNewBookListener listener);

}

IOnNewBookListener.aidl

package com.example.aidl;

import com.example.aidl.Book;

interface IOnNewBookListener{

    void onNewBook(in Book newBook);

}  

3.2服务端代码

   
   
package com.example.binder;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import com.example.aidl.Book;
import com.example.aidl.IBookManager;
import com.example.aidl.IOnNewBookListener;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log;
public class ServerService extends Service {
	private static final String TAG = "ServerService";
	//使用CopyOnWriteArrayList是为了支持并发读写
	private CopyOnWriteArrayList<Book> mList = new CopyOnWriteArrayList<Book>();
	private CopyOnWriteArrayList<IOnNewBookListener> mListeners = new CopyOnWriteArrayList<IOnNewBookListener>();
	
	@Override
	public IBinder onBind(Intent intent) {
		return mStub;
	}
	
	public final IBookManager.Stub mStub = new IBookManager.Stub() {
		
		@Override
		public List<Book> getBookList() throws RemoteException {
			Log.d(TAG,"addBook-size" + mList.size());
			return mList;
		}
		
		@Override
		public void addBook(Book book) throws RemoteException {
			Log.d(TAG,"addBook name=" + book.bookName);
			if(!mList.contains(book)){
				mList.add(book);
				
				for (int i = 0; i < mListeners.size(); i++) {
					IOnNewBookListener listener = mListeners.get(i);
					listener.onNewBook(book);
					
				}
			}else{
				Log.d(TAG,"addBook already exit" );
			}
			
		}
		@Override
		public void registerListener(IOnNewBookListener listener)
				throws RemoteException {
			if(!mListeners.contains(listener)){
				Log.d(TAG,"addBook registerListener" );
				mListeners.add(listener);
			}else{
				Log.d(TAG,"addBook registerListener exit" );
			}
			
		}
		@Override
		public void unregistenerListener(IOnNewBookListener listener)
				throws RemoteException {
			if(mListeners.contains(listener)){
				mListeners.remove(listener);
				Log.d(TAG,"addBook registerListener remove" );
			}else{
				Log.d(TAG,"addBook registerListener not found,error." );
			}
			
		}
	};
}

同时这里并不是在2个应用之间通讯,而且在同一个应用的2个进程之间通信,所以要把服务端的进程区别一下.关键是 android:process = ":other"就表示在进程名称为other进程里面(xxxx.xxxx:other)

AndroidManifest.xml

    
    
<service android:name="com.example.binder.ServerService"
            android:process=":other">
      <intent-filter>
           <action android:name="android.intent.action.MAIN" />
       </intent-filter>
</service>  

3.3客户端代码:

BinderActivity.java

   
   
package com.example.binder;
import com.example.aidl.Book;
import com.example.aidl.IBookManager;
import com.example.aidl.IOnNewBookListener;
import com.example.demo1.R;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
public class BinderActivity extends Activity implements OnClickListener{
	
	private IBookManager mIBookManager = null;
	private int i = 0;
	private TextView tv;
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_binder);
		Button send = (Button)findViewById(R.id.bt_send);
		send.setOnClickListener(this);
		tv = (TextView)findViewById(R.id.tv_msg_response);
		
		Intent intent = new Intent(this, ServerService.class);
		bindService(intent, sc, Context.BIND_AUTO_CREATE);
	}
	ServiceConnection sc = new ServiceConnection() {
		
		@Override
		public void onServiceDisconnected(ComponentName name) {
			mIBookManager = null;
			
			try {
				mIBookManager.unregistenerListener(mIOnNewBookListener);
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}
		
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			mIBookManager = IBookManager.Stub.asInterface(service);
			try {
				mIBookManager.registerListener(mIOnNewBookListener);
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}
	};
	
	private IOnNewBookListener mIOnNewBookListener = new IOnNewBookListener.Stub() {
		@Override
		public void onNewBook(Book newBook) throws RemoteException {
			tv.setText("第" + i + "本书添加成功,名称是:"+ newBook.bookName);
		}
	};
	@Override
	public void onClick(View v) {
		try {
			i++;
			mIBookManager.addBook(new Book(1, "第" + i + "本书"));
		} catch (RemoteException e) {
			e.printStackTrace();
			i--;
		}
	}
	
	@Override
	protected void onDestroy() {
		try {
			if(mIBookManager != null && mIBookManager.asBinder().isBinderAlive()){
				mIBookManager.unregistenerListener(mIOnNewBookListener);
			}
		} catch (RemoteException e) {
			e.printStackTrace();
		}
		unbindService(sc);
		super.onDestroy();
	}
}

如果客户端的 onNewBook() 方法中需要执行UI操作最后使用Handlder切换到UI线程来操作.因为 onNewBook()有可能 是执行在Binder线程池的,如果在服务端调用客户端的listener的 onNewBook 时是单独创建的一个Thread在里面执行的话,那么客户端这边执行UI操作时就会报异常.

(在打印出Thread名称的时候的,发现依然是main进程.后续再研究为什么?)

上面的客户端代码如果想取消一解注册 mIOnNewBookListener 的时候会发现解注册失败,因为找不到那个listener了.这个是因为Binder会把客户端彻底的对象重新序列化.这个时候可以使用RemoteCallBackList来解决这个问题.这个是系统专门提供用来删除跨进程listener的接口的.

这个时候需要更新服务器代码如下:

ServerService.java

   
   
package com.example.binder;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import com.example.aidl.Book;
import com.example.aidl.IBookManager;
import com.example.aidl.IOnNewBookListener;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;
public class ServerService extends Service {
	private static final String TAG = "ServerService";
	
	//使用CopyOnWriteArrayList是为了支持并发读写
	private CopyOnWriteArrayList<Book> mList = new CopyOnWriteArrayList<Book>();
	private RemoteCallbackList<IOnNewBookListener> mListeners = new RemoteCallbackList<IOnNewBookListener>();
	
	@Override
	public IBinder onBind(Intent intent) {
		return mStub;
	}
	
	public final IBookManager.Stub mStub = new IBookManager.Stub() {
		@Override
		public List<Book> getBookList() throws RemoteException {
			Log.d(TAG,"addBook-size" + mList.size());
			return mList;
		}
		
		@Override
		public void addBook(Book book) throws RemoteException {
			Log.d(TAG,"addBook name=" + book.bookName);
			if(!mList.contains(book)){
				mList.add(book);
				int N = mListeners.beginBroadcast();
				for (int i = 0; i < N ; i++) {
					IOnNewBookListener listener = mListeners.getBroadcastItem(i);
					try {
						listener.onNewBook(new Book(111, "Android xxx"));
					} catch (RemoteException e) {
						Log.d(TAG,"error");
						e.printStackTrace();
					}
				}
				mListeners.finishBroadcast();
			}else{
				Log.d(TAG,"addBook already exit" );
			}
		}
		@Override
		public void registerListener(IOnNewBookListener listener)
				throws RemoteException {
			mListeners.register(listener);
		}
		@Override
		public void unregistenerListener(IOnNewBookListener listener)
				throws RemoteException {
			mListeners.unregister(listener);
		}
	};
}

3.4 Android.mk 与AIDL 编译问题

LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src)

在这句后面添加 \ 然后回车

aidl 路径 \

以下为例

LOCAL_SRC_FILES := $(call all-java-files-under, src) $(call all-renderscript-files-under, src)   \

src/com/testaidl/aidl/SettingService.aidl  \

就是src 加文件-包名全路径。  注意\后要回车

4.通过AIDL来分析Binder

在这里为了加深对AIDL的理解,我们分析一下工具根据ADIL文件生成的java文件(eclipse在gen目录下面的aidl目录里面有),这里只分析 IBookManager.java 文件.

为了更清晰对这个文件结构有个认识,这里将eclipse的outline里面图保存如下

很显然,这里接口IBookManager里面有2个静态内部类.抽象类Stub和Proxy.我们已经说了 IBookManager只是接口,确实它的getBookList()等方法它自己并没有实现.

抽象类Stub和Proxy都实现了这个接口,但是 抽象类Stub并没有实现 接口IBookManager的方法.并且 抽象类Stub继承了Ibinder

但是 Proxy可不是抽象类,它也确实实现了 IBookManager接口的相关方法.但是正如它的名字他只是一个代理,是 Stub的一个内部代理.看上面的Proxy构造函数有一个Ibinder类型的参数,

下面就来分析抽象类 Stub和 Stub 的代理类 Proxy.

既然ADIL就是为了跨进程通信的,那就来看看我们实现业务逻辑的服务端,这里我们的服务端就是一个没有页面的Service,这个Service服务其实就是在内部创建了一个继承抽象类 Stub变量,并在客户端使用bindserive()连接服务端的时候,将自己创建的变量作为onBind()方法的返回参数.

在客户端使用bindService()成功连接之后,在ServiceConnection对象的onServiceConnectioned()方法的参数列表中有一个参数就是Ibinder类型.客户端想直接使用IBookManager的相关方法就要讲这个Ibinder类型的对象转换成实现了 IBookManager接口类型的对象,还是看上面截图,发现Stub有一个静态方法asInterface(xx)就是干这个的.后面客户端想干啥都可以使用这个 静态方法asInterface(xx)得到的 IBookManager对象.

注意:在这个 asInterface()内部也是会判断的,如果是同一个进程内部调用会直接获取Stub自己本身来处理(结合Stub的构造函数和 Stub的 asInterface()方法一起看就可以明白 ).如果是不同的2个进程那就创建一个 IBookManager 代理类Proxy来处理,其实就是把上面说的 Ibinder类型的对象传递给 Proxy的构造函数来处理,但是我们结合上面对服务端的分析就会发现这个客户端得到的 Ibinder类型对象与服务端的 onBind()方法的返回的IBinder肯定是有关联的.

总结起来说就是Stub类主要是负责服务端的工作,Proxy类主要是负责客户端的工作,但是客户端并不是直接创建Proxy来处理,而是使用Stub的静态方法asInterface()来将服务端返回给客户端的Ibinder变成实现了IBookManager接口的一个对象来工作的.

    
    
package com.example.aidl;
public interface IBookManager extends android.os.IInterface {
	/** Local-side IPC implementation stub class. */
	public static abstract class Stub extends android.os.Binder implements
			com.example.aidl.IBookManager {
		private static final java.lang.String DESCRIPTOR = "com.example.aidl.IBookManager";
		/** Construct the stub at attach it to the interface. */
		public Stub() {
			this.attachInterface(this, DESCRIPTOR);
		}
		/**
		 * Cast an IBinder object into an com.example.aidl.IBookManager
		 * interface, generating a proxy if needed.
		 */
		public static com.example.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.example.aidl.IBookManager))) {
				return ((com.example.aidl.IBookManager) iin);
			}
			return new com.example.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.example.aidl.Book> _result = this
						.getBookList();
				reply.writeNoException();
				reply.writeTypedList(_result);
				return true;
			}
			case TRANSACTION_addBook: {
				data.enforceInterface(DESCRIPTOR);
				com.example.aidl.Book _arg0;
				if ((0 != data.readInt())) {
					_arg0 = com.example.aidl.Book.CREATOR
							.createFromParcel(data);
				} else {
					_arg0 = null;
				}
				this.addBook(_arg0);
				reply.writeNoException();
				return true;
			}
			case TRANSACTION_registerListener: {
				data.enforceInterface(DESCRIPTOR);
				com.example.aidl.IOnNewBookListener _arg0;
				_arg0 = com.example.aidl.IOnNewBookListener.Stub
						.asInterface(data.readStrongBinder());
				this.registerListener(_arg0);
				reply.writeNoException();
				return true;
			}
			case TRANSACTION_unregistenerListener: {
				data.enforceInterface(DESCRIPTOR);
				com.example.aidl.IOnNewBookListener _arg0;
				_arg0 = com.example.aidl.IOnNewBookListener.Stub
						.asInterface(data.readStrongBinder());
				this.unregistenerListener(_arg0);
				reply.writeNoException();
				return true;
			}
			}
			return super.onTransact(code, data, reply, flags);
		}
		private static class Proxy implements com.example.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.example.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.example.aidl.Book> _result;
				try {
					_data.writeInterfaceToken(DESCRIPTOR);
					mRemote.transact(Stub.TRANSACTION_getBookList, _data,
							_reply, 0);
					_reply.readException();
					_result = _reply
							.createTypedArrayList(com.example.aidl.Book.CREATOR);
				} finally {
					_reply.recycle();
					_data.recycle();
				}
				return _result;
			}
			@Override
			public void addBook(com.example.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();
				}
			}
			@Override
			public void registerListener(
					com.example.aidl.IOnNewBookListener listener)
					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.writeStrongBinder((((listener != null)) ? (listener
							.asBinder()) : (null)));
					mRemote.transact(Stub.TRANSACTION_registerListener, _data,
							_reply, 0);
					_reply.readException();
				} finally {
					_reply.recycle();
					_data.recycle();
				}
			}
			@Override
			public void unregistenerListener(
					com.example.aidl.IOnNewBookListener listener)
					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.writeStrongBinder((((listener != null)) ? (listener
							.asBinder()) : (null)));
					mRemote.transact(Stub.TRANSACTION_unregistenerListener,
							_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);
		static final int TRANSACTION_registerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
		static final int TRANSACTION_unregistenerListener = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
	}
	public java.util.List<com.example.aidl.Book> getBookList()
			throws android.os.RemoteException;
	public void addBook(com.example.aidl.Book book)
			throws android.os.RemoteException;
	public void registerListener(com.example.aidl.IOnNewBookListener listener)
			throws android.os.RemoteException;
	public void unregistenerListener(
			com.example.aidl.IOnNewBookListener listener)
			throws android.os.RemoteException;
}

看了上面的eclipse的outline视图和具体的代码结构之后再看下面的UML类图对AIDl文件对应的java接口类内部结构更清晰了.下面的IxxxServie就是和我们这个实例中的IBookManager对应.