一，aidl进程通讯介绍
Android 是进程间内存是分离的，因此需要将对象分解成操作系统可理解的元数据，并将此打包让操作系统帮忙传递对象到另一个进程。这个过程是十分复杂繁重的，因此 Google 定义了 AIDL（Android Interface Definition Language）帮助开发者简化工作。
二，aidl通讯的实现
实现步骤：
1，创建.aidl文件-该文件（YourInterface.aidl）定义了客户端可用的方法和数据的接口。
2，在服务端和客户端makefile文件中都加入.aidl文件——Eclipse中的ADT插件自动将aidl文件编译成java代码生成在gen文件夹下
3，Implement your interface methods - The AIDL compiler creates an interface in the Java programming language from your AIDL interface. This interface has an inner abstract class named Stub that inherits the interface (and implements a few additional methods necessary for the IPC call). You must create a class that extends YourInterface.Stub and implements the methods you declared in your .aidl file. 实现你定义aidl接口中的内部抽象类Stub。（这一步骤建议联系下面的代码理解会容易一些）
class Stub extends Binder implements binder.aidl.AIDLService （这里的代码在gen文件夹下）
4，服务端继承Service并且重载Service.onBind(Intent)以返回实现了接口的对象实例
具体实现
IMyService.aidl：
package com.myapp.aidl; interface IMyService { public void playMusic(int id); int getName(int id); }这里的设置意味着：客户端可以向服务器发送指令和获取数据。
其中aidl中支持的参数类型为：基本类型（int、long、char、boolean等），String，CharSequence，List，Map。若想要自定义对象传输，后面会详细讲到。
定义好aidl文件后，请在服务端和客户端粘贴一份一模一样的aidl文件。
Eclipse在编译的时候会自动在gen下面为我们生成了一个代理类Stub，这个Stub类就是一个普通的Binder，只不过它实现了我们定义的aidl接口。通过它的静态方法asInterface我们就可以在客户端中得到IMyService的实例，进而通过实例来调用其他方法。
客户端：
Intent startIntent = new Intent(); ComponentName componentName = new ComponentName( PACKAGE_REMOTE_SERVICE, NAME_REMOTE_SERVICE); startIntent.setComponent(componentName); bindService(startIntent, mConnection, Context.BIND_AUTO_CREATE);这里的PACKAGE_REMOTE_SERVICE,NAME_REMOTE_SERVICE就是指定的service。
IMyService mService; private ServiceConnection mConnection = new ServiceConnection() { public void onServiceConnected(ComponentName className, IBinder service) { Log("connect service"); mService = IMyService.Stub.asInterface(service); try { int name = mService.getName(1); } catch (RemoteException e) { } } public void onServiceDisconnected(ComponentName className) { Log("disconnect service"); mService = null; } };
服务端：
public class TestService extends Service { @Override public IBinder onBind(Intent arg0) { System.out.println("Service onBind"); return mBinder; } private final IMyService.Stub mBinder = new IMyService.Stub() { @Override String getName(int id){ String name = findBy(id);//findBy()这是伪代码 return name; } @Override public void playMusic(int id){ playMusic(int id);//playMusic()也是伪代码； } }; }Manifest.xml中记得配置service，注意：exported="true"要配置为true，不然客户端是没有权限访问服务的。
<service android:name="com.marttinli.service.MusicService" android:exported="true"> </service>如此一个基本的aidl通讯就完成了。
原理分析
那么接下来我们开始分析在gen目录下自动生成的文件到底是什么？
这里有几个重要的类和方法：asInterface(IBinder obj) , Proxy ,transact(int code, Parcel data, Parcel reply, int flags) ,onTransact(int code, Parcel data,Parcel reply, int flags)
这里涉及到Parcel序列化的一些技术，晚些会专门开一章来讲，这里你先明白Parcel对象是用来在进程间传递的数据对象，其他的基本类型和对象最终都要序列化程Parcel数据才能在进程间传递。
还记得客户端调用的IMyService.Stub.asInterface(service)吧，就在这里
public static com.marttinli.aidl.IMysService asInterface( android.os.IBinder obj) { if ((obj == null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof com.marttinli.aidl.IMysService))) { return ((com.marttinli.aidl.IMysService) iin); } return new com.marttinli.aidl.IMysService.Stub.Proxy( obj); }这里返回了一个Proxy，并把service作为输入。而Proxy正是完成了对我们在aidl接口中定义接口的实现。这里Client把参数转换成Parcel(_data)传递到了Service，而在Server端又会把返回数据保存到_reply中，这就形成了一次交互。
mRemote是远程对象，transact方法会执行onTransact方法 @Override public void playMusic(int id) 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((((id != null)) ? (id .asBinder()) : (null))); mRemote.transact(Stub.TRANSACTION_playMusic, _data, _reply, 0); _reply.readException(); } finally { _reply.recycle(); _data.recycle(); } } @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_playMusic: { data.enforceInterface(DESCRIPTOR); int _arg0; _arg0 = data.readInt(); this.playMusic(_arg0); reply.writeNoException(); return true; } } return super.onTransact(code, data, reply, flags); }而到了onTransact()中，已经是开始和service进行交互了，_data最终转化成了他原来的数据格式(这里是int)，然后调用playMusic()，service端实现了playMusic()。
三，aidl通讯传递对象数据
aidl的数据传递本来也就是把基本数据类型转化成Parelable作为跨进称数据传输的格式。
所以一个对象想要传输，也只需要把对象转成Parelable 就可以跨进称传输。
我还专门为此写了个demo，确保可行。
服务端3个文件，我假定我需要传输的对象为Music：Music.java,Music.aidl,RemoteMusic.aidl
Music.aidl
parcelable Music; RemoteMusic.aidl package com.marttinli.aidl; import com.marttinli.aidl.Music; interface RemoteMusic{ Music getMusic(); void uploadMusic(in Music music); } Music.java public class Music implements Parcelable { int id; String name; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public int describeContents() { // TODO Auto-generated method stub return 0; } @Override public void writeToParcel(Parcel dest, int flags) { // TODO Auto-generated method stub dest.writeInt(id); dest.writeString(name); } /** * 在想要进行序列号传递的实体类内部一定要声明该常量。常量名只能是CREATOR,类型也必须是 * Parcelable.Creator<T> */ public static final Parcelable.Creator<Music> CREATOR = new Creator<Music>() { /** * 创建一个要序列号的实体类的数组，数组中存储的都设置为null */ @Override public Music[] newArray(int size) { return new Music[size]; } /*** * 根据序列号的Parcel对象，反序列号为原本的实体对象 * 读出顺序要和writeToParcel的写入顺序相同 */ @Override public Music createFromParcel(Parcel source) { int id = source.readInt(); String name = source.readString(); Music music = new Music(); music.setId(id); music.setName(name); return music; } }; } MusiceService.java public class MusicService extends Service { MyBinder mBinder = new MyBinder(); @Override public IBinder onBind(Intent intent) { // TODO Auto-generated method stub return mBinder; } private class MyBinder extends RemoteMusic.Stub{ public Music getMusic() throws RemoteException { Music music = new Music(); music.setId(1) ; music.setName("沉默是金") ; return music; } @Override public void uploadMusic(Music music) throws RemoteException { // TODO Auto-generated method stub Log.d("marttinli", "uploadMusic music:"+music.getName()); }} }客户端。客户端的Music.java,Music.aidl,RemoteMusic.aidl，这三个文件请从服务器端copy过来，连外面的包也一起copy过来，确保一模一样。
客户端绑定服务和发送请求的代码就不贴了，第三点就已经说过了。
这里有几个点要注意的：
1，Music.java中注释也写了，在序列化时，想要进行序列号传递的实体类内部一定要声明CREATOR 常量。常量名只能是CREATOR,类型也必须是 Parcelable.Creator<T>
2，Music.java在序列化时，根据序列号的Parcel对象，反序列号为原本的实体对象 读出顺序要和writeToParcel的写入顺序相同
3，标识符in,out,inout，类似c语言里的用法，in表示输入参数，这个很好理解。out表示该参数做为输入，也是作为输出；比如change(int value)，输入value=1，传到service后，service重新复制value=2，那么在客户端这个value==2.
4，Music.java,Music.aidl也要名字一样，后缀不一样而已。
四，aidl实现数据监听
有个问题就是，目前我们已经实现了客户端对服务端发送指令和获取数据，但有一种情况：当你发送指令后，服务在处理数据要执行耗时操作才能返回数据。对，这个时候你应该很容易可以想到再定义一个接收数据的接口，只要服务端处理完数据调用该接口方法，在客户端实现的方法就可以获取到对应数据。
实现步骤(这里接着上面的代码写)：
1，再定义一个RemoteMusicCallback.aidl，顾名思义，这个是服务端执行完耗时操作后对客户端的callback。这里的标识符一定是in，至于原因，稍后会讲到。
interface RemoteMusicCallback{ void onChanged(in Music music); }2，既然有了Callback，那么必须要声明注册监听和反注册的方法，这里放在原来的RemoteMusic.aidl中是最合适的。那么RemoteMusic.adil变为： interface RemoteMusic{ Music getMusic(); void uploadMusic(in Music music); void registerMusic(in RemoteMusicCallback callback); void unRegisterMusic(in RemoteMusicCallback callback); }3，然后把Music.java,Music.aidl,RemoteMusic.aidl,RemoteMusicCallback.aidl，连同包一起复制到客户端和服务端。 客户端：
加入注册music变化的callback：
RemoteMusicCallback mRemoteMusicCallback = new RemoteMusicCallback.Stub() { @Override public void onChanged(Music music) throws RemoteException { // TODO Auto-generated method stub System.out.println("music:"+music.getName()); } }; @Override public void onServiceConnected(ComponentName name, IBinder service) { // TODO Auto-generated method stub Log.d("marttinli","connected successful"); mService = RemoteMusic.Stub.asInterface(service); try { mService.registerMusic(mRemoteMusicCallback); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } } 在取消ServiceConnection绑定的时候先取消注册： private void unBindService(){ if (mService!=null) { if (mRemoteMusicCallback!=null&& mRemoteMusicCallback.asBinder().isBinderAlive()) { try { mService.unRegisterMusic(mRemoteMusicCallback); } catch (RemoteException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (mConnection!=null) { unbindService(mConnection); } } }服务端：
这里有一点要注意的，我们是提供service的，谁注册监听我的数据变化，我就要给谁提供服务。那么必然存在一种可能，很多应用同时监听我的服务，那么这时我就需要把他们都按顺序存放在一个队列里，等到他们监听的服务变化时，我就给他们一一推送过去。这里我用ArrayList来存放队列，在MyBinder下实现队列的添加和删除：
private class MyBinder extends RemoteMusic.Stub{ public Music getMusic() throws RemoteException { Music music = new Music(); music.setId(1) ; music.setName("沉默是金") ; return music; } @Override public void uploadMusic(Music music) throws RemoteException { // TODO Auto-generated method stub Log.d("marttinli", "uploadMusic music:"+music.getName()); } @Override public void registerMusic(RemoteMusicCallback callback) throws RemoteException { // TODO Auto-generated method stub mCallbacks.add(callback); notifyListeners();//这是一个段伪代码 } @Override public void unRegisterMusic(RemoteMusicCallback callback) throws RemoteException { // TODO Auto-generated method stub mCallbacks.remove(callback); }}notifyListeners模拟数据发送：
private void notifyListeners() throws RemoteException{ new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub int i = 0; for (int j = 0; j < 10; j++) { for (RemoteMusicCallback callback : mCallbacks) { Music music = new Music(); music.setId(i); music.setName("沉默是金 "+i); try { callback.onChanged(music); } catch (RemoteException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } try { Thread.sleep(3000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } i++; } } }).start(); } 有没有发现，这样就实现了对服务端数据的监听。在实际开发中实现对service的数据监听经常有这个需求，service通常用来处理一类数据，你通过service获取你想要的数据，也可以监听service数据，一旦某条你监听的数据发生变化，service就会根据注册监听的队列对象一一推送该数据过去。而你只要在监听实现中获取数据。
不知道你有没有发现，aidl里面定义的都是interface，顾名思义，aidl就是定义的接口，一个供不同进程连接的接口。他们会在gen目录下生成对应的.java文件，也是接口，是继承IInterface的接口；因为需要通过Binder跨进程传输的接口都是需要继承IInterface的。
五，aidl与Messager在实现进程通讯上的区别
一般，你只有在客户端需要访问另一进程的 Service ，且需要 Service 多纯种处理客户端请求时才有必要使用 AIDL；如果只需要在进程内和 Service 通信，只需要实现 Binder 通过 onBind() 返回对象；如果需要进程间通信但不需要并发处理请求，可考虑使用 Messenger，Messenger 底层实现和 AIDL 类似，上层采用 handler-message 方式通信，更为简单易用(具体请参考上文)。
