**版权声明：本文为小斑马伟原创文章，转载请注明出处!
人工智能
AIDL概述：AIDL是一个缩写，全称是Android Interface Definition Language，也就是Android接口定义语言，设计这门语言的目的是为了实现进程间通信。接下来我写了两个demo（AildeService和AidleClient），他们之间通过AIDL方式实现两个进程之间互相通信。
一、 数据类序列化与反序列化
由于不同的进程有着不同的内存区域，并且它们只能访问自己的那一块内存区域，所以我们不能像平时那样，传一个句柄过去就完事了——句柄指向的是一个内存区域，现在目标进程根本不能访问源进程的内存，那把它传过去又有什么用呢？所以我们必须将要传输的数据转化为能够在内存之间流通的形式。这个转化的过程就叫做序列化与反序列化。
简单来说是这样的：比如现在我们要将一个对象的数据从客户端传到服务端去，我们就可以在客户端对这个对象进行序列化的操作，将其中包含的数据转化为序列化流，然后将这个序列化流传输到服务端的内存中去，再在服务端对这个数据流进行反序列化的操作，从而还原其中包含的数据——通过这种方式，我们就达到了在一个进程中访问另一个进程的数据的目的。
public class ConnInfoParcel implements Comparable<ConnInfoParcel>, Parcelable{
private long id;
private String name;
private String password;
private int connType;
public static final Parcelable.Creator<ConnInfoParcel> CREATOR = new Parcelable.Creator<ConnInfoParcel>() {
@Override
public ConnInfoParcel createFromParcel(Parcel arg0) {
return new ConnInfoParcel(arg0);
}
@Override
public ConnInfoParcel[] newArray(int arg0) {
return new ConnInfoParcel[arg0];
}
};
public void readFromParcel(Parcel source) {
id = source.readLong();
name = source.readString();
connType = source.readInt();
password = source.readString();
}
public ConnInfoParcel (String name, String password) {
this.name = name;
this.password = password;
}
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeLong(id);
dest.writeString(name);
dest.writeString(password);
dest.writeInt(connType);
}
@Override
public int compareTo(ConnInfoParcel arg0) {
return 0;
}
public ConnInfoParcel(Parcel source) {
readFromParcel(source);
}
public ConnInfoParcel(long id2, String name2, int connType2,
String password2) {
this.id = id2;
this.name = name2;
this.connType = connType2;
this.password = password2;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getConnType() {
return connType;
}
public void setConnType(int connType) {
this.connType = connType;
}
@Override
public String toString() {
return "ConnInfoParcel [id=" + id + ", name=" + name + ", password="
+ password + ", connType=" + connType + "]";
}
}
二、 AIDL文件生成
AIDL文件生成需要注意几点：两个项目之间AIDLE文件的包名和类名必须是一样的。传输集合的数据时,对象类需要创建一个AIDL文件，否则会导入类不成功。在AidleService工程中，创建了两个AILD文件：ICtrl.aidl文件和InfoSetupAdapter.aidl文件。
ICtrl.aidl文件：用于注册和反注册服务端回调给服务端的方法，以及客户端调用服务端的方法。
package com.android.service;
import com.android.service.InfoSetupAdapter;
/**
*for remote caller support some interface to ctrl
*@author weiwei
*
*/
interface ICtrl {
boolean registerInfoCallback(InfoSetupAdapter adapter);
boolean unregisterInfoCallback(InfoSetupAdapter adapter);
/*
*初始化
*@return
*/
boolean init();
boolean dial(String num);
boolean setSan();
boolean setMute(int mute)；
}
InfoSetupAdapter.aidl文件：服务端回调数据给客户端方法。
package com.android.service;
import com.android.service.ConnInfoParcel;
interface InfoSetupAdapter {
void connect(String deviceId,String name);
void powerState(boolean isOn);
void connList(in List<ConnInfoParcel> list);
}
两个AILD之间的嵌套需要创建一个ConnInfoParcel的AIDL文件。否者import com.android.service.InfoSetupAdapter;会找不到。
package com.android.service;
parcelable ConnInfoParcel;
三、 RemoteInterfaceService类（AidlService服务端）
RemoteInterfaceService类：该类继承Service类，在onBind方法里面实现 ICtrl.Stub接口。
public class RemoteInterfaceService extends Service {
private final RemoteCallbackList<InfoSetupAdapter> mCallbacks = new RemoteCallbackList<InfoSetupAdapter>();
private ICtrl.Stub mBinder = new ICtrl.Stub() {
@Override
public boolean registerInfoCallback(InfoSetupAdapter adapter)
throws RemoteException {
if(adapter != null) {
boolean result = mCallbacks.register(adapter);
if(result) {
updateSetupInfo();
}
} else {
Log.i("test","callback adapter is null");
}
return false;
}
@Override
public boolean unregisterInfoCallback(InfoSetupAdapter adapter)
throws RemoteException {
if(adapter != null) {
return mCallbacks.unregister(adapter);
}
return false;
}
@Override
public boolean setSan() throws RemoteException {
Log.i("test","setSan()");
return false;
}
@Override
public boolean setMute(int mute) throws RemoteException {
Log.i("test"," setMute(int mute)"+mute);
return false;
}
@Override
public boolean init() throws RemoteException {
Log.i("test","init()");
return false;
}
@Override
public boolean dial(String num) throws RemoteException {
Log.i("test","dail"+num);
return false;
}
};
private synchronized void updateSetupInfo() {
Log.i("test","callback updateSetupInfo");
String name = " weiwei";
String password = "123";
boolean isOn = true;
int connType = 2;
Vector<ConnInfo> connVector = new Vector<ConnInfo>();
List<ConnInfoParcel> list = new ArrayList<ConnInfoParcel>();
for(ConnInfo info: connVector) {
Log.i("test","callback connlists" + info.getName());
list.add(new ConnInfoParcel(info.getId(),info.getName(),info.getConnType()
,info.getPassword()));
}
int count = mCallbacks.beginBroadcast();
for(int i = 0; i < count; ++i) {
try {
mCallbacks.getBroadcastItem(i).powerState(isOn);
mCallbacks.getBroadcastItem(i).connect(name, password);
mCallbacks.getBroadcastItem(i).connList(list);
} catch (RemoteException e) {
e.printStackTrace();
}
}
Log.i("test","beginBroadcast finish !!");
mCallbacks.finishBroadcast();
}
@Override
public IBinder onBind(Intent arg0) {
Log.i("test","onbind");
return mBinder;
}
}
在AndroidMainifest.xml文件中注册该Service服务
<service android:name="com.android.service.RemoteInterfaceService">
<intent-filter >
<action android:name="com.android.servie.REMOTESERVICE"/>
<category android:name="android.intent.category.DEFAULT"/>
</intent-filter>
</service>
四、 DataManager类（AidlClient 客户端）
DataManager类：该类实现对服务端的AIDL进行绑定和取消绑定功能。并且在没有绑定成功的情况下，进行每隔100毫秒再一次绑定，直到绑定成功。
public class DataManager {
private static DataManager mDataManager;
private Context mContext;
private ICtrl mICtrl;
private List<ConnInfoParcel> list = new ArrayList<ConnInfoParcel>();
private DataManager(Context context) {
this.mContext = context;
bindService();
}
/**
* 设置值给服务端aidle
* @param name
*/
public void setName(String name) {
if(mICtrl != null) {
try {
mICtrl.dial(name);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
private void bindService() {
if(mICtrl == null) {
Intent intent = new Intent("com.zhonghong.REMOTESERVICE");
mContext.bindService(intent, conn, Context.BIND_AUTO_CREATE);
}
}
private ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName arg0, IBinder service) {
Log.i("test","bind success" + service);
mICtrl = ICtrl.Stub.asInterface(service);
if(mICtrl != null) {
new Handler().post(new Runnable(){
@Override
public void run() {
try {
mICtrl.registerInfoCallback(mInfoAdapter);
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
}
@Override
public void onServiceDisconnected(ComponentName arg0) {
mICtrl = null;
Log.i("test","bind failed");
new Handler().postDelayed(new Runnable(){
@Override
public void run() {
bindService();
}
}, 100);
}
};
/**
* 服务端AIDL回调上来的数据
*/
private InfoSetupAdapter mInfoAdapter = new InfoSetupAdapter.Stub() {
@Override
public void powerState(boolean isOn) throws RemoteException {
Log.i("test","isOn ="+isOn);
}
@Override
public void connect(String deviceId, String name) throws RemoteException {
Log.i("test"," deviceId ="+ deviceId+"name ="+name);
}
@Override
public void connList(List<ConnInfoParcel> list) throws RemoteException {
Log.i("test","client connList");
for(ConnInfoParcel conn: list) {
Log.i("test","con"+conn.toString());
}
synchronized (list) {
list.clear();
list.addAll(list);
}
}
};
/**
* 反注册
*/
public void onDestroy() {
mDataManager = null;
if(mICtrl != null) {
try {
mICtrl.unregisterInfoCallback(mInfoAdapter);
mContext.unbindService(conn);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
}
网友评论