IPC是Inter-Process Communication的缩写,意思是进程间通信。Android中IPC的方式有很多种,今天先说最灵活也是最常用的一种,即AIDL(Android Interface Definition Language)方式。
创建多进程的方式有两种,一,给四大组件指定android:process属性,二,通过JNI在native层fork一个新的进程。今天Demo以第一种为例,因为第二种我不会。为了方便查看此Demo没有写两个工程,而是在同一个应用内给SecondActivity 指定
android:process="com.dyk.aidltest.SecondActivity"
这样就相当于SecondActivity是另一个应用的Activity。下面开始讲解Demo。
工程大纲:
首先新建一个实现了Parcelable的Book类,用作测试Bean。
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;
}
@Override
public int describeContents() {
return 0;
}
/**序列化*/
@Override
public void writeToParcel(Parcel out, int flags) {
out.writeInt(bookId);
out.writeString(bookName);
}
private Book(Parcel source){
bookId = source.readInt();
bookName = source.readString();
}
/**反序列化*/
public static final Creator<Book> CREATOR = new Creator<Book>() {
@Override
public Book createFromParcel(Parcel source) {
return new Book(source);
}
@Override
public Book[] newArray(int size) {
return new Book[size];
}
};
}
接着新建需要的aidl文件
package com.example.aidl;
parcelable Book;
package com.example.aidl;
import com.example.aidl.Book;
interface IBookManager{
List<Book> getBookList();
void addBook(in Book book);
}
注意:Book必须实现Parcelable接口(序列化,反序列化),参数in代表输入型参数,out代表输出型参数,inout代表输入输出型参数,否则aidl不支持。就算Book和aidl文件在同一包下,也需要导包。如果AIDL用到了自定义的parcelable对象,则必须建立一个和它同名的aidl文件,并在其中声明它为parcelable类型。AIDL接口中只支持方法,不支持静态常量,这一点区别于传统的接口。
新建上述文件夹后可以在gen/package name目录下可以查找到系统自动为我们生成的IBookManager。乍一看这个类有点乱,format后可以发现这个类并没有想象的那么复杂。在此简单分析下这个类,不感兴趣的可以略过这一阶段,直接进入下一分割线。
--------------------------------------------------------------华丽丽的分割线--------------------------------------------
首先这个IBookManager继承了IInterface接口,里面有一个抽象类Stub和两个抽象方法。
public static abstract class Stub extends android.os.Binder implements com.example.aidl.IBookManager
<span style="white-space:pre"> </span>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;
S
tub里面有几个比较重要的方法:asInterface,asBinder,onTransact和一个代理类
private static class Proxy implements com.example.aidl.IBookManager
asInterface:将服务端的Binder对象转换成客户端所需的AIDL接口类型的对象,这种对象区分进程,若在统一进程,返回服务端的Stub本身,否则返回封装后的Stub.proxy对象。
if (((iin != null) && (iin instanceof com.example.aidl.IBookManager))) {
return ((com.example.aidl.IBookManager) iin);
}
return new com.example.aidl.IBookManager.Stub.Proxy(obj);
asBinder:返回当前的Binder对象
onTransact:服务端通过参数code确定客户端请求的目标方法,接着从data中取出目标方法所需的参数,然后执行目标方法,最后向reply中写入返回值。
<span style="white-space:pre"> </span>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.IOnNewBookArrivedListener _arg0;
_arg0 = com.example.aidl.IOnNewBookArrivedListener.Stub
.asInterface(data.readStrongBinder());
this.registerListener(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_unregisterListener: {
data.enforceInterface(DESCRIPTOR);
com.example.aidl.IOnNewBookArrivedListener _arg0;
_arg0 = com.example.aidl.IOnNewBookArrivedListener.Stub
.asInterface(data.readStrongBinder());
this.unregisterListener(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
-------------------------------------------------------------------华丽丽的分割线-------------------------------------------------------------------------
接下来就可以写我们的服务端了,这里使用一个service充当服务端。先上代码
package com.example.service;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import android.app.Service;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.util.Log;
import com.example.aidl.Book;
import com.example.aidl.IBookManager.Stub;
import com.example.aidl.IOnNewBookArrivedListener;
public class MyService extends Service {
public static final String TAG = "MyService";
// CopyWriteArrayList支持并发读/写
// AIDL方法是在服务端的Binder线程池中执行的,
// 因此当多个客户端同时连接时,会存在多个线程同时访问的情形
// 类似的还有ConcurrentHashMap
/** 书籍列表 */
private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<Book>();
/** Stub继承Binder类实现了IBookManager接口 */
public class MyServiceImpl extends Stub {
@Override
public List<Book> getBookList() throws RemoteException {
for (int i = 0; i < 10; i++) {
Book mBook = new Book(i, "平凡的世界");
mBookList.add(mBook);
}
return mBookList;
}
@Override
public void addBook(Book book) throws RemoteException {
mBookList.add(book);
@Override
public IBinder onBind(Intent intent) {
return new MyServiceImpl();
}
}
在onBind中返回继承Stub的内部类MyServiceImpl。上文也提到过Stub继承Binder类实现了IBookManager接口并且本身是一个抽象类。所以非抽象子类需要重写getBookList()和addBook(Book book)方法。
服务器端暂时到此结束,接下来就到客户端了。
package com.example.aidltest;
import com.example.aidl.Book;
import com.example.aidl.IBookManager;
import com.example.aidl.IOnNewBookArrivedListener;
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.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;
public class MainActivity extends Activity implements OnClickListener {
public static final String TAG = "MainActivity";
private Button bindService;
private Button startSecondActivity;
private TextView tvShow;
private IBookManager mIBookManager;
private ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceDisconnected(ComponentName name) {
//<span style="font-family: Arial, Helvetica, sans-serif;">onServiceDisconnected</span><span style="font-family: Arial, Helvetica, sans-serif;">和onServiceConnected方法都在UI线程中运行</span>
//所以不要在它们里面直接调用服务器端的耗时方法
}
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// service就是com.example.service.MyService$MyServiceImpl
// Log.i(TAG,TAG+"******"+service.getClass().getName());
// 面向接口编程
mIBookManager = IBookManager.Stub.asInterface(service);
//为了避免ANR下面的代码最好新开线程中运行,这里为了方便就不麻烦了
try {
// 父类调用子类方法
tvShow.setText(mIBookManager.getBookList().toString());
Book newBook = new Book(888,"监听测试***书籍");
mIBookManager.addBook(newBook);
} catch (RemoteException e) {
e.printStackTrace();
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initView();
}
@Override
protected void onDestroy() {
//解除绑定
unbindService(mServiceConnection);
super.onDestroy();
}
private void initView() {
bindService = (Button) findViewById(R.id.bindService);
startSecondActivity = (Button) findViewById(R.id.startSecondActivity);
tvShow = (TextView) findViewById(R.id.tvShow);
bindService.setOnClickListener(this);
startSecondActivity.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.bindService:
Intent intent = new Intent("com.example.service.MyService");
// MyService类的onBind方法返回的是MyService的内部类MyServiceImpl
boolean isBind = bindService(intent, mServiceConnection,Context.BIND_AUTO_CREATE);
if (isBind) {
Log.i(TAG, TAG + "********绑定成功***********");
} else {
Log.i(TAG, TAG + "********绑定失败***********");
}
break;
case R.id.startSecondActivity:
Intent intent2 = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intent2);
break;
default:
break;
}
}
}
流程:A.bindService()--->S.onCreate--->S.onBind---->>A.onServiceConnected绑定成功,并获得Service对象
结束绑定按钮的监听事件-->>unbindService(conn)关闭连接对象-->>S.destory()销毁该service。
PS:SecondActivity和Maintivity代码完全一样,只是在AndroidMainfest多了一个属性,可自行创建。
android:process="com.dyk.aidltest.SecondActivity"
点击“绑定服务”后效果如图:
可以看到已经获取到Book的信息了。
get。
客户端到调用服务器端的方法到此结束。如果有这么一个需求:服务端有数据变动需要立即通知客户端,那么应该怎么做呢?没错,接口。需要说明的是这里的接口不是普通的接口。因为AIDL中无法使用普通接口,所以我们需要写一个aidl接口。
package com.example.aidl;
import com.example.aidl.Book;
interface IOnNewBookArrivedListener{
void onNewBookArrived(in Book newBook);
}
在IBookManaget里增加两个抽象方法
<span style="font-size:14px;">void registerListener(IOnNewBookArrivedListener listener);
void unregisterListener(IOnNewBookArrivedListener listener);</span>
由于IBookManager增加两个抽象方法,所以相应的MyServiceImpl需要重写这两个方法。
<span style="white-space:pre"> </span>@Override
public void registerListener(IOnNewBookArrivedListener listener)
throws RemoteException {
mListenerList.register(listener);
Log.i(TAG, "register listener:" + listener);
}
@Override
public void unregisterListener(IOnNewBookArrivedListener listener)
throws RemoteException {
// 其实就是从Map中移除相应的键值对(listener是key)
mListenerList.unregister(listener);
Log.i(TAG, "unregister listener:" + listener);
}
对象是不能跨进程直接传输的,对象跨进程传输本质都是反序列化的过程。使用普通的ArrayList后Binder会把客户端传输过来的对象重新转化并生成一个对象,虽然我们注册和反注册使用的同一个客户端对象,但是这样通过Binder传递到服务器端后会产生两个全新的对象。使用RemoteCallbackList可以解决这个问题,具体优点如下:
<span style="white-space:pre"> </span>// RemoteCallbackList是系统专门提供的用于删除跨进程listener的接口
// 当客户端进程终止后,它能自动移除客户端所注册的listener
// 内部自动实现了线程同步的功能
// 它不是list 内部采用Map接口保存AIDL的回调
/** 监听器列表 */
private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList = new RemoteCallbackList<IOnNewBookArrivedListener>();
在addBook中调用这个监听方法
// 遍历通知每个监听者
int len = mListenerList.beginBroadcast();
for (int i = 0; i < len; i++) {
IOnNewBookArrivedListener listener = mListenerList
.getBroadcastItem(i);
// 如果listener.onNewBookArrived(book)比较耗时,最好新开线程,防止ANR
listener.onNewBookArrived(book);
}
mListenerList.finishBroadcast();
接下来在MainActivity或SecondActivity中实现这个接口,并重写两个方法registerListener和unregisterListener。
IOnNewBookArrivedListener mIOnNewBookArrivedListener = new IOnNewBookArrivedListener.Stub() {
@Override
public void onNewBookArrived(Book newBook) throws RemoteException {
//书籍增加后的做法
Log.i(TAG, "newBook="+newBook.bookId+"\t"+newBook.bookName);
}
};
在MainActivity或SecondActivity的onServiceConnected中注册监听
//注册为监听者
mIBookManager.registerListener(mIOnNewBookArrivedListener);
在MainActivity或SecondActivity的onDestroy中反注册监听
if (mIBookManager!=null&&mIBookManager.asBinder().isBinderAlive()) {
try {
//解除监听
mIBookManager.unregisterListener(mIOnNewBookArrivedListener);
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
到这里基本算大功告成了,最后的最后还有一个小缺陷需要我们修复。默认情况下我们的服务器端谁都可以连接,这可不一定是我们想要的。没错,加入限权。
首先在AndroidMainfest中声明所需的限权
<!-- 自定义MyService的限权,在OnBind中验证限权 -->
<permission
android:name="com.example.service.permission.MyService"
android:protectionLevel="normal" >
</permission>
<span style="white-space:pre"> </span><service
android:name="com.example.service.MyService"
android:permission="com.example.service.permission.MyService" >
<intent-filter>
<action android:name="com.example.service.MyService" />
</intent-filter>
</service>
<span style="white-space:pre"> </span><!-- 使用限权 -->
<uses-permission android:name="com.example.service.permission.MyService" />
最后在onBinder中验证限权,没有限权返回空,无法绑定
<span style="white-space:pre"> </span>@Override
public IBinder onBind(Intent intent) {
//限权验证 ,没有限权返回空,无法绑定
int check = checkCallingOrSelfPermission("com.example.service.permission.MyService");
if (check==PackageManager.PERMISSION_DENIED) {
return null;
}
return new MyServiceImpl();
}
缕清思路加写作一共花了3个多小时,终于完成了!这一大套流程下来可真不容易,希望对你有所帮助。
Demo下载地址:http://download.csdn.net/detail/qq_17250009/9252577