目录
android 加入AIDL进行底层通讯
Android接口定义语言aidl通信简单理解
Serializable和Parcelable区别:
简单客户端和服务端demo：
android 加入AIDL进行底层通讯
直接将aidl文件复制到main目录中，在sync和make project
生成的文件在 android 目录中，在java中在邮特殊符号的文件夹中能看到；
java文件将目录下的包直接复制到项目的java 目录中；进行调用；
AIDL重要的是通讯必须是报名是相同的；
Android接口定义语言aidl通信简单理解
AIDL:Android Interface Definition Language,即Android接口定义语言。
Android系统中的进程之间不能共享内存，因此，需要提供一些机制在不同进程之间进行数据通信。
为了使其他的应用程序也可以访问本应用程序提供的服务，Android系统采用了远程过程调用（Remote Procedure Call，RPC）方式来实现。与很多其他的基于RPC（Remote Procedure Call Protocol)--远程过程调用协议）的解决方案一样，Android使用一种接口定义语言（Interface Definition Language，IDL）来公开服务的接口。我们知道4个Android应用程序组件中的3个（Activity、BroadcastReceiver和ContentProvider）都可以进行跨进程访问，另外一个Android应用程序组件Service同样可以。因此，可以将这种可以跨进程访问的服务称为AIDL（Android Interface Definition Language）服务。
ipc:IPC是Inter-Process Communication的缩写，含义就是进程间通信或者跨进程通信
Serializable和Parcelable区别:Serializable(可串行化的)是Java中的序列化接口，其使用起来简单但是开销很大，在序列化和反序列化过程中需要大量的I/O操作。
而Parcelable（打包的）是Android中的序列化方式，因此更适合用在Android平台上，它的缺点就是使用起来稍微麻烦点，但是它的效率很高。
两种AIDL文件：在我的理解里，所有的AIDL文件大致可以分为两类。一类是用来定义parcelable对象，以供其他AIDL文件使用AIDL中非默认支持的数据类型的。一类是用来定义方法接口，以供系统使用来完成跨进程通信的。可以看到，两类文件都是在“定义”些什么，而不涉及具体的实现，这就是为什么它叫做“Android接口定义语言”。 注：所有的非默认支持数据类型必须通过第一类AIDL文件定义才能被使用。
AIDL 实例 下面以实例代码演示一个 AIDL 的编写。
1.创建 AIDL ①创建要操作的实体类，实现 Parcelable 接口，以便序列化/反序列化
package net.sxkeji.shixinandroiddemo2.bean;
import android.os.Parcel; import android.os.Parcelable;
public class Person implements Parcelable { private String mName;
public Person(String name) { mName = name; }
protected Person(Parcel in) { mName = in.readString(); }
public static final Creator CREATOR = new Creator() { @Override public Person createFromParcel(Parcel in) { return new Person(in); }
@Override public Person[] newArray(int size) { return new Person[size]; } };
@Override public int describeContents() { return 0; }
@Override public void writeToParcel(Parcel dest, int flags) { dest.writeString(mName); }
@Override public String toString() { return "Person{" + "mName='" + mName + '\'' + '}'; } } 实现 Parcelable 接口是为了后序跨进程通信时使用。
关于 Parcelable 可以看我的这篇文章 Android 进阶6：两种序列化方式 Serializable 和 Parcelable。
注意 实体类所在的包名。
②新建 aidl 文件夹，在其中创建接口 aidl 文件以及实体类的映射 aidl 文件
在 main 文件夹下新建 aidl 文件夹，使用的包名要和 java 文件夹的包名一致：
先创建实体类的映射 aidl 文件，Person.aidl：
// Person.aidl package net.sxkeji.shixinandroiddemo2.bean;
//还要和声明的实体类在一个包里 parcelable Person;
在其中声明映射的实体类名称与类型
注意，这个 Person.aidl 的包名要和实体类包名一致。
然后创建接口 aidl 文件，IMyAidl.aidl：
// IMyAidl.aidl package net.sxkeji.shixinandroiddemo2;
// Declare any non-default types here with import statements import net.sxkeji.shixinandroiddemo2.bean.Person;
interface IMyAidl { /** * 除了基本数据类型，其他类型的参数都需要标上方向类型：in(输入), out(输出), inout(输入输出) */ void addPerson(in Person person);
List getPersonList(); } 在接口 aidl 文件中定义将来要在跨进程进行的操作，上面的接口中定义了两个操作：
addPerson: 添加 Person getPersonList：获取 Person 列表 需要注意的是：
非基本类型的数据需要导入，比如上面的 Person，需要导入它的全路径。 这里的 Person 我理解的是 Person.aidl，然后通过 Person.aidl 又找到真正的实体 Person 类。 方法参数中，除了基本数据类型，其他类型的参数都需要标上方向类型 in(输入), out(输出), inout(输入输出)③Make Project ，生成 Binder 的 Java 文件
AIDL 真正的强大之处就在这里，通过简单的定义 aidl 接口，然后编译，就会为我们生成复杂的 Java 文件。
点击 Build -> Make Project，然后等待构建完成。
然后就会在 build/generated/source/aidl/你的 flavor/ 下生成一个 Java 文件：
现在我们有了跨进程 Client 和 Server 的通信媒介，接着就可以编写客户端和服务端代码了。
我们先跑通整个过程，这个文件的内容下篇文章介绍。
2.编写服务端代码 创建 Service，在其中创建上面生成的 Binder 对象实例，实现接口定义的方法；然后在 onBind() 中返回
创建将来要运行在另一个进程的 Service，在其中实现了 AIDL 接口中定义的方法:
public class MyAidlService extends Service { private final String TAG = this.getClass().getSimpleName();
private ArrayList mPersons;
/** * 创建生成的本地 Binder 对象，实现 AIDL 制定的方法 */ private IBinder mIBinder = new IMyAidl.Stub() {
@Override public void addPerson(Person person) throws RemoteException { mPersons.add(person); }
@Override public List getPersonList() throws RemoteException { return mPersons; } };
/** * 客户端与服务端绑定时的回调，返回 mIBinder 后客户端就可以通过它远程调用服务端的方法，即实现了通讯 * @param intent * @return */ @Nullable @Override public IBinder onBind(Intent intent) { mPersons = new ArrayList(); LogUtils.d(TAG, "MyAidlService onBind"); return mIBinder; } } 上面的代码中，创建的对象是一个 IMyAidl.Stub() ，它是一个 Binder，具体为什么是它我们下篇文章介绍。
别忘记在 Manifest 文件中声明：
服务端实现了接口，在 onBind() 中返回这个 Binder，客户端拿到就可以操作数据了。
3.编写客户端代码 这里我们以一个 Activity 为客户端。
①实现 ServiceConnection 接口，在其中拿到 AIDL 类
private IMyAidl mAidl;
private ServiceConnection mConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { //连接后拿到 Binder，转换成 AIDL，在不同进程会返回个代理 mAidl = IMyAidl.Stub.asInterface(service); }
@Override public void onServiceDisconnected(ComponentName name) { mAidl = null; } }; 在 Activity 中创建一个服务连接对象，在其中调用 IMyAidl.Stub.asInterface() 方法将 Binder 转为 AIDL 类。
②接着绑定服务
Intent intent1 = new Intent(getApplicationContext(), MyAidlService.class); bindService(intent1, mConnection, BIND_AUTO_CREATE); 要执行 IPC，必须使用 bindService() 将应用绑定到服务上。
注意：
5.0 以后要求显式调用 Service，所以我们无法通过 action 或者 filter 的形式调用 Service，具体内容可以看这篇文章 Android 进阶：Service 的一些细节。
③拿到 AIDL 类后，就可以调用 AIDL 类中定义好的操作，进行跨进程请求
@OnClick(R.id.btn_add_person) public void addPerson() { Random random = new Random(); Person person = new Person("shixin" + random.nextInt(10));
try { mAidl.addPerson(person); List personList = mAidl.getPersonList(); mTvResult.setText(personList.toString()); } catch (RemoteException e) { e.printStackTrace(); } }
总结 这篇文章介绍了 AIDL 的简单编写流程，其中也踩过一些坑，比如文件所在包的路径不统一，绑定服务收不到回调等问题。
到最后虽然跨进程通信成功，但是我们还是有很多疑问的，比如：
AIDL 生成的文件内容？ 什么是 Binder？ 为什么要这么写？ 知其然还要知其所以然，这一切都要从 Binder 讲起，且听下一回合介绍。
代码地址 Thanks 《Android 开发艺术探索》 https://developer.android.com/guide/components/aidl.html http://www.jianshu.com/p/b9b15252b3d6 http://rainbow702.iteye.com/blog/1149790
简单客户端和服务端demo：编写服务端代码 通过上面几步，我们已经完成了AIDL及其相关文件的全部内容，那么我们究竟应该如何利用这些东西来进行跨进程通信呢？其实，在我们写完AIDL文件并 clean 或者 rebuild 项目之后，编译器会根据AIDL文件为我们生成一个与AIDL文件同名的 .java 文件，这个 .java 文件才是与我们的跨进程通信密切相关的东西。事实上，基本的操作流程就是：在服务端实现AIDL中定义的方法接口的具体逻辑，然后在客户端调用这些方法接口，从而达到跨进程通信的目的。
接下来我直接贴上我写的服务端代码：
/** * 服务端的AIDLService.java *
* Created by lypeer on 2016/7/17. */ public class AIDLService extends Service {public final String TAG = this.getClass().getSimpleName();
//包含Book对象的list private List mBooks = new ArrayList();
//由AIDL文件生成的BookManager private final BookManager.Stub mBookManager = new BookManager.Stub() { @Override public List getBooks() throws RemoteException { synchronized (this) { Log.e(TAG, "invoking getBooks() method , now the list is : " + mBooks.toString()); if (mBooks != null) { return mBooks; } return new ArrayList(); } }
@Override public void addBook(Book book) throws RemoteException { synchronized (this) { if (mBooks == null) { mBooks = new ArrayList(); } if (book == null) { Log.e(TAG, "Book is null in In"); book = new Book(); } //尝试修改book的参数，主要是为了观察其到客户端的反馈 book.setPrice(2333); if (!mBooks.contains(book)) { mBooks.add(book); } //打印mBooks列表，观察客户端传过来的值 Log.e(TAG, "invoking addBooks() method , now the list is : " + mBooks.toString()); } } };
@Override public void onCreate() { super.onCreate(); Book book = new Book(); book.setName("Android开发艺术探索"); book.setPrice(28); mBooks.add(book); }
@Nullable @Override public IBinder onBind(Intent intent) { Log.e(getClass().getSimpleName(), String.format("on bind,intent = %s", intent.toString())); return mBookManager; } } 整体的代码结构很清晰，大致可以分为三块：第一块是初始化。在 onCreate() 方法里面我进行了一些数据的初始化操作。第二块是重写 BookManager.Stub 中的方法。在这里面提供AIDL里面定义的方法接口的具体实现逻辑。第三块是重写 onBind() 方法。在里面返回写好的 BookManager.Stub 。
接下来在 Manefest 文件里面注册这个我们写好的 Service ，这个不写的话我们前面做的工作都是无用功：
到这里我们的服务端代码就编写完毕了，如果你对里面的一些地方感觉有些陌生或者根本不知所云的话，说明你对 Service 相关的知识已经有些遗忘了，建议再去看看这两篇博文：Android中的Service：默默的奉献者 (1)，Android中的Service：Binder，Messenger，AIDL（2） 。
4.5，编写客户端代码 前面说过，在客户端我们要完成的工作主要是调用服务端的方法，但是在那之前，我们首先要连接上服务端，完整的客户端代码是这样的：
/** * 客户端的AIDLActivity.java * 由于测试机的无用debug信息太多，故log都是用的e *
* Created by lypeer on 2016/7/17. */ public class AIDLActivity extends AppCompatActivity {//由AIDL文件生成的Java类 private BookManager mBookManager = null;
//标志当前与服务端连接状况的布尔值，false为未连接，true为连接中 private boolean mBound = false;
//包含Book对象的list private List mBooks;
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_aidl); }
/** * 按钮的点击事件，点击之后调用服务端的addBookIn方法 * * @param view */ public void addBook(View view) { //如果与服务端的连接处于未连接状态，则尝试连接 if (!mBound) { attemptToBindService(); Toast.makeText(this, "当前与服务端处于未连接状态，正在尝试重连，请稍后再试", Toast.LENGTH_SHORT).show(); return; } if (mBookManager == null) return;
Book book = new Book(); book.setName("APP研发录In"); book.setPrice(30); try { mBookManager.addBook(book); Log.e(getLocalClassName(), book.toString()); } catch (RemoteException e) { e.printStackTrace(); } }
/** * 尝试与服务端建立连接 */ private void attemptToBindService() { Intent intent = new Intent(); intent.setAction("com.lypeer.aidl"); intent.setPackage("com.lypeer.ipcserver"); bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE); }
@Override protected void onStart() { super.onStart(); if (!mBound) { attemptToBindService(); } }
@Override protected void onStop() { super.onStop(); if (mBound) { unbindService(mServiceConnection); mBound = false; } }
private ServiceConnection mServiceConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { Log.e(getLocalClassName(), "service connected"); mBookManager = BookManager.Stub.asInterface(service); mBound = true;
if (mBookManager != null) { try { mBooks = mBookManager.getBooks(); Log.e(getLocalClassName(), mBooks.toString()); } catch (RemoteException e) { e.printStackTrace(); } } }
@Override public void onServiceDisconnected(ComponentName name) { Log.e(getLocalClassName(), "service disconnected"); mBound = false; } }; } 同样很清晰，首先建立连接，然后在 ServiceConnection 里面获取 BookManager 对象，接着通过它来调用服务端的方法。
4.6，开始通信吧！ 通过上面的步骤，我们已经完成了所有的前期工作，接下来就可以通过AIDL来进行跨进程通信了！将两个app同时运行在同一台手机上，然后调用客户端的 addBook() 方法，我们会看到服务端的 logcat 信息是这样的：
//服务端的 log 信息，我把无用的信息头去掉了，然后给它编了个号 1，on bind,intent = Intent { act=com.lypeer.aidl pkg=com.lypeer.ipcserver } 2，invoking getBooks() method , now the list is : [name : Android开发艺术探索 , price : 28] 3，invoking addBooks() method , now the list is : [name : Android开发艺术探索 , price : 28, name : APP研发录In , price : 2333] 客户端的信息是这样的：
//客户端的 log 信息 1，service connected 2，[name : Android开发艺术探索 , price : 28] 3，name : APP研发录In , price : 30
