Android-AIDL进程间通信

人工智能

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();
        }
    }
}
}

demo下载

Android-AIDL进程间通信

一、 数据类序列化与反序列化

二、 AIDL文件生成

三、 RemoteInterfaceService类（AidlService服务端）

四、 DataManager类（AidlClient 客户端）

一、数据类序列化与反序列化