前言
转载请声明，转自【https://www.cnblogs.com/andy-songwei/p/10256379.html】，谢谢！
只要是面试高级工程师岗位，Android跨进程通信就是最受面试官青睐的知识点之一。Android系统的运行由大量相互独立的进程相互协助来完成的，所以Android进程间通信问题，是做好Android开发高级工程师必须要跨过的一道坎。但是，我们是否真的清楚，Android中都有哪些方式实现跨进程通信呢？这些方式都有哪些优缺点？如何选择这些通信方式？Binder是什么？为什么要引入Binder？Binder是这么样实现跨进程通信的？AIDL是什么？AIDL和Binder又有什么关系呢？......
本文将对Android的跨进程通、进程内通信等方面做一些总结，以及比较详细地介绍AIDL的使用，主要内容如下：
其行文脉络大致如下，希望能加深读者对这方面内容的记忆：（1）Android基于Linux系统，所以先说系统进程相关知识和Linux IPC。（2）总结Android的IPC，顺带总结了Android进程内组件之间的通信方式。（3）Android为了克服Linux IPC中的缺点，引入了Binder，所以对Binder做了一些宏观上的介绍。（4）AIDL是实现Binder最常用的工具，所以详细介绍了AIDL相关内容。
一、基础知识简介
在介绍Android跨进程通信之前，笔者先简单啰嗦一下进程隔离、跨进程通信。
1、进程隔离
在操作系统中，进程与进程间的内存和数据都是不共享的。两个进程就好像大海中相互独立的两个岛屿，各自生活在互相平行的两个世界中，互不干扰，各自为政。这样做的目的，是为了避免进程间相互操作数据的现象发生，从而引起各自的安全问题。为了实现进程隔离，采用了虚拟地址空间，两个进程各自的虚拟地址不同，从逻辑上来实现彼此间的隔离。
2、跨进程通信
马克思主义哲学说，人是一切社会关系的总和。任何一个个体都不可能完全隔离于外界，都不可避免地与外界“互通有无”。进程也一样，每一个进程完成的功能有限，就像现在的生成线一样，往往就是只完成某一类功能，而不是把所有事情都给做了，就这样，每个进程就时不时需要与其他进程之间通信了。两个进程之间要进行通信，就需要采用特殊的通信机制：进程间通信（IPC:Inter-Process Communication，即进程间通信或跨进程通信，后文以IPC替代，在此声明）。
二、Linux跨进程通信
我们知道，Android系统就是基于Linux内核实现的，咱们先简单了解一下Linux系统的IPC方式。虽然不同的资料对各种方式的名称和种类说法不完全相同，但是主要来说有如下6种方式：（1）管道 Pipe；（2）信号Signal；（3）信号量Semaphore；（4）消息队列Message Queue；（5）共享内存Shared Memmory；（6）套接字Socket。读者若想深入了解这些方式，可以自行查阅，这里不展开介绍，只需要知道有这六种方式即可。
三、Android跨进程通信
Android IPC的方式在不同的资料中有不同的说法，但从大方向上看，可以归纳为如下四种（这里仅对各种方式做简单介绍和优劣对比，对具体如何使用，不做讲解）：
1、Activity方式
Activity是四大组件中使用最频繁的，咱们先从它说起。使用Activity方式实现，就是使用startActivity()来启动另外一个进程的Activity。
（1）场景
我们在使用App的使用，往往会遇到如下几种情形：（1）浏览器中看到一篇比较不错的文章，分享到微信朋友圈或者微博；（2）在某个App中点击某个网址，然后界面跳转到浏览器中进行阅读；（3）使用美团外卖app，看到店家的电话，点击联系商家时，跳转到了电话拨打界面......这样的操作再频繁不过了。这些就是通过startActivity的方式从一个App，跳转到了另外一个App的Activity，从而实现了跨进程通信。
（2）使用
我们知道，在调用startActivity(Intent intent)的时候，intent有两个类型：显式Intent和隐式Intent。
1）显式Intent的使用方式如下，用于进程内组件间通信：
Intent intent = new Intent(this,OtherActivity.class);
startActivity(intent);
这种方式显式地指定了要跳转的Activtiy的class名称，不知道是不是因为这个原因而被称为显式intent的，笔者没有查证。这种方式用于进程内Activity的跳转，是跨模块间通信，而不是跨进程间通信。
2）隐式intent的使用方式如下，用于IPC：
Intent intent = new Intent();
intent.setAction(Intent.ACTION_CALL);
startActivity(intent);//startActivityForResult()同样，这里不赘述
Intent.ACTION_CALL就是字符串常量“android.intent.action.CALL”，这种方式通过setAction的方式来启动目标app的Activity，上述代码就是启动电话app的拨号界面，有时候还可以带上电话号码等参数。
由上可知，Activity实现跨进程通信的方式，适合于不同App之间功能界面的跳转。
2、Content provider（后面简称CP）方式
（1）场景
当我们开发App需要用到联系人，多媒体信息等数据的时候，往往会通过系统提供Uri，采用CP的方式去获取。Android系统中，数据主要存储在自带的SqlLite数据库中。应用要共享SqlLite中的数据给其他App操作（增、删、改、查），就要用到CP，也就是说，CP主要用于跨进程数据库共享。Android系统提供了很多的CP来供其它App使用，如多媒体信息、联系人、日历等。如下图显示了Android系统提供的CP，包名都是以"com.android.providers“开头的：
这些用于共享的数据其实都是存储在系统数据库中的，如下显示了meida CP中的数据库：
App开发者也可以自定义CP，把自己的数据提供给其它app使用，也可以自己定义操作权限，如只允许其它app读取自己的数据，而不允许修改等。
（2）特点
1）CP的使用场景，是提供数据共享。
2）CP本质上还是在操作数据库，数据存储在sdcard中，所以建立连接和操作数据都是耗时操作，所以注意开辟子线程去操作。
3）当数据库中数据有变化时，Content Observer监听到数据库变化也是有一定的滞后。
3、Broadcase方式
Broadcast使用非常简单，注册好广播，添加上action，就可以等着接收其他进程发出的广播。发送和接收广播时，还可以借助Intent来携带数据。但是广播的使用存在很多问题，被很多程序员吐槽，甚至鄙夷，所以选择用广播进行跨进程通信，是下下策。下面盘点一下Broadcast的槽点：
（1）Broadcast是一种单向的通信方式。当一个程序发送广播后，其他应用只能被动地接收，无法向发送者反馈。
（2）Broadcast非常消耗系统资源，会导致系统性能下降。
（3）速度慢，容易造成系统ANR。且除了Parall Broadcast外，无法保证接收到的时间，甚至不一定能收得到。
（4）如果使用Ordered Broadcast，一个Receiver执行时间过长，会影响后面接收者的接收时间，甚至还有可能被中间某个Receiver拦截，导致后面Receiver无法接收到。
（5）发送者无法确定谁会接收该广播，而接收者也无发确认是谁发来的广播。
（6）如果是静态注册的广播，一个没有开启的进程，都有可能被该广播激活。
......
总而言之，言而总之，使用Broadcast来实现跨进程通信，是下下之策！
4、Service方式
启动Service的方式有多种，有的用于跨进程通信，有的用于进程内部模块之间的通信，下面仅简单介绍一下跨进程通信的方式。
（1）startService()方式
Intent startIntent = new Intent ();
ComponentName componentName = new ComponentName(string packageName，string serviceClassName);
startIntent.setComponent(componentName );
startService( startIntent);
该方式启动远程Service实现跨进程通信，耦合度比较低，功能及代码结构清晰，但是存在以下缺点：
1）没有好的机制立即返回执行结果，往往Service完成任务后，还需要其他方式向Client端反馈。
2）Service端无法识别Client端是谁，只知道有启动命令，但无法知道是谁下的命令。
3）在已经创建好Service情况下，每次调用startService，就会执行onStartCommand()生命周期方法，相比于bindService，效率低下。
4）如果Client端忘记调用stopService()了，那么该Service会一直运行下去，这也是一个隐患。
所以，针对上述缺点，往往建议startService()方式用于同一个App内，跨进程的方式用后面将要讲到的AIDL来实现。
（2）bindService、Handler、Messager结合
这种方式也可以实现跨进程通信，据说和AIDL具有相同的功效，但比AIDL使用简单，详细可以阅读博文【Android总结篇系列：Android Service】。但是从笔者工作这些年来看，从没见过谁使用过这种方式，可能是笔者太孤陋寡闻了，这里就不多介绍了。
（3）AIDL
这种方式也是bindService()启动方式的一种使用情况，也是广受程序员们推崇的方式。前面说startService()和Broadcast如何不好，就是为了衬托AIDL如何的好
！这是本文的主角，本文后面会专门详细讲解，这里不赘述。
值得注意的是，从Android L开始，系统对Service的隐式启动做了限制，需要至少包含包名或类名，具体可以查看博文【Android 5.0之后隐式声明Intent 启动Service引发的问题】，所以隐式启动Service时需要多注意这一点。
5、总结
从如上的介绍来看，其实Android中跨进程通信的实现，就是利用四大组件来实现的。对方式的选择，我们总结一下：
（1）如果跨进程需要界面上的交互操作，用隐式startActivity()方式实现。
（2）如果需要共享数据，用Content Provider方式实现。
（3）排除前两种情形，就用AIDL。
（4）仅仅为了完成功能，又确实不会用AIDL的，就用Broadcast吧！！！虽然很low，但比实现不了功能还是强多了
四、Android进程内通信
前面总结了几种跨进程通信的方式，这里顺便总结一下Android进程内部组件之间的通信方式。
（1）显示调用startActivity()。可以用Intent携带数据，而且如果用startActivityForResult()，还可以得到目标Activity完成任务后的反馈。
（2）startService/bindService。用于与service通信，其中Intent，回调方法等会携带数据或者对象，选择哪一个需要视情况而定。
（3）Boradcast。对于全局广播，前面已经diss过很多了，这里不多说了，能不用则不用。但是还有一种局部广播——LocalBroadcastManager，只能在app内部使用，也是一种进程内通信的方法，且在性能、安全等方面都要优于全局广播，对于它的使用，可以参考我的另外一篇文章【【朝花夕拾】四大组件之（一）广播篇】。
（4）Handler方式。这种方式在子线程和主线程通信中用得很普遍，跨模块使用也常见到，使用方便。需要注意的是Looper和线程问题。
（5）回调。最普遍的方式了，使用也很方便。一般会结合面向接口编程来实现，如果调用的层次比较深，同一个接口注册的地方太多，可读性会比较差，经常看得头晕。甚至有时候这些注册回调的地方会相互干扰。使用的时候要注意退出该模块的时候，把注册的回调变量置空销毁。
（6）EventBus。使用简单，耦合度低，代码可读性比较好，也受到很多开发者的喜爱。但也有一些缺点：1）需要导入第三方库。2）发送消息出去后，被注册的地方都会收到该消息，如果处理不当，开发者甚至不容易意识到哪些地方收到了消息并做了处理，带来不必要的混乱。3）当注册了EventBus的模块退出后，容易忘记反注册。
（7）SharePreference（简称SP）等数据存储方式。这个就是数据的持久化和模块间共享数据了，除了SP，还有网络存储，Sqilite数据库，文件存储等多种方式，功能可以类比跨进程通信的ContentProvider。
和跨进程通行方式选择一样，组件间的通信方式也要根据具体需要来确定了。从完成功能上讲，前面讲到的跨进程通信的方式，在进程内组件间通信也可以用，但是这样就像用牛刀杀鸡，大炮打蚊子了。出于性能方面的考虑，就不要将跨进程的方式用于进程内模块间通信了。
五、Binder概述
Binder是Android框架中非常重要的一个机制，在Framework中被广泛使用，理解Binder对阅读Framework源码有着很大的帮助。当然，在应用层等层面的跨进程通信中，也被广泛使用。有人说，理解Binder，是跨入高级Android工程师行列的第一步，先不管是不是夸大其词了，但足以说明Binder对于Android有多么重要，也说明理解Binder有一定的难度。
1、Binder是什么
Binder英文单词的意思就是“粘合剂”，把两个物体粘合在一起。说起Binder是什么，在IPC过程中，从不同的角度来看，它可以被定义为一种机制，或者实体类，或者远程代理，甚至是传输对象，咱们这里说的Binder是从宏观定义来看的，是说的Binder机制。在Android中，它是一种高效的IPC方式，是Android所特有的机制。它采用C/S架构模式，基于内存映射（mmap（）），在系统内核空间将Client端和Service端两个用户空间的进程联系在一起。
2、Binder的由来
Binder前身是某公司开发的OpenBinder项目，后来该项目的作者加入了Google，同时把该项目带进了Android。从此以后，Binder就成为了Android中主要的跨进程通信机制。
3、Android为什么要引入Binder
前面第二点提到，Linux已经具备了这么多的IPC方式，为什么Android中还要引入Binder呢？原因是从性能、稳定性和安全性三方面考虑，Linux本身的那些方式，往往只能具备一部分因素，无法兼顾。但是Binder却不然，从性能上看，只需要一次数据拷贝，性能上仅次于共享内存；从稳定性上看，基于C/S架构，职责明确、架构清晰，稳定性好；从安全性上看，它为每个APP分配UID，而进程的UID是鉴别进程身份的重要标志。对于更详细的对比，推荐阅读【Android Bander设计与实现 - 设计篇的“引言”部分】，本文重点不是探索Linux，就不赘述了，咱们只需要知道Binder比Linux其它IPC方式更给力就够了。
4、Binder机制原理
Binder机制相关知识点和源码非常庞杂，很多技术书籍往往要花很大篇幅来阐述，比如罗升阳的《Android 系统源码情景分析》就花了100多页来剖析它。俗话说，要想倒出一碗水，你得先有一桶水。很不好意思，笔者现在一碗水都不到，这里就不献丑了，推荐一篇讲得比较好的博文：【写给 Android 应用工程师的 Binder 原理剖析】，看完后收获挺大的。
六、AIDL基本使用
前面我们讲到，为了克服Linux中IPC各种方式的缺点，在Android中引入了Binder机制。但是当说起Binder在Android中的使用时，几乎所有的资料都是在说AIDL的使用。AIDL的全称是Android Interface Definition Language，即Android接口定义语言，是Binder机制实现Android IPC时使用比较广泛的工具。本节将以一个Demo演示一下AIDL的基本实现步骤。
源码地址：https://pan.baidu.com/s/1CyE_8-T9TDQLVQ1TDAEX2A 提取码：4auk 。
如下两个图展示了该Demo的结构图和AIDL关键文件：
图6.1 图6.2
1、建立两个App，分别为Client端和Server端。
这个比较 好理解，Server端就是包含了Service真正干活的那一端；Client端就是通过远程操控指挥的那一端，分别在不同的App中。如下图所示：
2、在Server端main目录下建立aidl文件夹以及.aidl文件，并copy一份到Client端，如图6.1中②处所示结构。注意，Client端和Server端②处是一模一样的。另外，AS中提供了快捷方式创建aidl文件，在main处点击右键 > New > AIDL > AIDL File文件，按照提示给aidl文件命名即可自动创建完成，可以看到文件路径也是该项目的包名。
这里给aidl命名为IDemoService.aidl，这里需要注意的是命名规范，一般都是以“I”开头，表示是一个接口，其内容如下：
//========== IDemoService.aidl========
package com.songwei.aidldemoserver;
// Declare any non-default types here with import statements
interface IDemoService {
void setName(String name);
String getName();
}
3、Server端创建Service文件 AidlService.java，如图6.1中③处所示，代码如下：
package com.songwei.aidldemoserver; import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;
import android.util.Log; public class AidlService extends Service {
private final static String TAG = "aidlDemo"; public AidlService() {
} @Override
public void onCreate() {
super.onCreate();
Log.i(TAG, "server:[onCreate]");
} @Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
Log.i(TAG, "server:[onBind]");
return new MyBinder();
} @Override
public boolean onUnbind(Intent intent) {
Log.i(TAG, "server:[onUnbind]");
return super.onUnbind(intent);
} @Override
public void onDestroy() {
super.onDestroy();
Log.i(TAG, "server:[onDestroy]");
} class MyBinder extends IDemoService.Stub {
private String mName = ""; public void setName(String name) throws RemoteException{
Log.i(TAG, "server:[setName]");
mName = name;
} @Override
public String getName() throws RemoteException {
Log.i(TAG, "server:[getName]");
return mName;
}
}
}
为了下文分析流程及生命周期，在其中各个方法中都添加了Log。
同时，在Server端的AndroidManifest.xml文件中添加该Service的注册信息。
<service
android:name=".AidlService"
android:exported="true">
<intent-filter>
<action android:name="com.songwei.aidl" />
</intent-filter>
</service>
这里有几点需要注意：
（1）exported属性值，如果有“intent-filter”，则默认值为true，否则为false。所以这里其实可以去掉，因为有“intent-filter”，其默认值就是true。
（2）由于笔者在后面启动该service的时候用的action的方式，所以这里就有了“intent-filter”里面的action。如果用其他方式启动，这个service的注册信息就需要相应的改动了，有一定开发经验的读者应该都知道，就不展开讲了，主要是怕读者容易忽略这里，所以特别提醒一下。
4、编译Sever端和Client端App，生成IDemoService.java文件。
当编译的时候，AS会自动为我们生成IDemoService.java文件，如图6.1和图6.2中④处所示。当你打开该文件的时候，是不是看到了如下场景？
惊不惊喜？意不意外？是不是一脸懵逼，大惊，卧槽，这尼玛啥玩意啊？
AIDL是Android接口定义语言，IDemoService.java是一个java中的interface（接口），现在是不是若有所思了呢？AIDL正是定义了IDemoService.java这个接口！！！ 这个接口文件就是AIDL帮助咱们生成的Binder相关代码，这些代码就是用来帮助实现Client端和Server端通信的。前面第2步中提到的IDemoService.aidl文件，其作用就是作为原料通过AIDL来生成这些你貌似看不懂的代码的，第3步中的AidlService.java和后续在Client端App连接Server端App的时候，其实这个aidl文件就从来没有出现过，也就是说，它已经没有什么价值了。所以说，AIDL的作用就是用来自动生成Binder相关接口代码的，而不需要开发者手动编写。有些教程中说，可以不使用AIDL而手动编写这份Binder代码，AIDL不是Binder实现通信所必需的，笔者也没有尝试过手动编写，如果读者您想挑战，可以尝试一下！
咱们继续！
打开IDemoService.java文件后，点击主菜单兰Code > Reformat Code （或 Ctrl + Alt +L快捷健），你会发现画面变成了下面这个样子：
/*
* This file is auto-generated. DO NOT MODIFY.
* Original file: D:\\ASWorkspace\\testDemo\\aidldemoclient\\src\\main\\aidl\\com\\songwei\\aidldemoserver\\IDemoService.aidl
*/
package com.songwei.aidldemoserver; public interface IDemoService extends android.os.IInterface {
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.songwei.aidldemoserver.IDemoService {
private static final java.lang.String DESCRIPTOR = "com.songwei.aidldemoserver.IDemoService"; /**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
} /**
* Cast an IBinder object into an com.songwei.aidldemoserver.IDemoService interface,
* generating a proxy if needed.
*/
public static com.songwei.aidldemoserver.IDemoService asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.songwei.aidldemoserver.IDemoService))) {
return ((com.songwei.aidldemoserver.IDemoService) iin);
}
return new com.songwei.aidldemoserver.IDemoService.Stub.Proxy(obj);
} @Override
public android.os.IBinder asBinder() {
return this;
} @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_setName: {
data.enforceInterface(DESCRIPTOR);
java.lang.String _arg0;
_arg0 = data.readString();
this.setName(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_getName: {
data.enforceInterface(DESCRIPTOR);
java.lang.String _result = this.getName();
reply.writeNoException();
reply.writeString(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
} private static class Proxy implements com.songwei.aidldemoserver.IDemoService {
private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) {
mRemote = remote;
} @Override
public android.os.IBinder asBinder() {
return mRemote;
} public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
} @Override
public void setName(java.lang.String name) 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.writeString(name);
mRemote.transact(Stub.TRANSACTION_setName, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
} @Override
public java.lang.String getName() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.lang.String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getName, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
} static final int TRANSACTION_setName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_getName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
} public void setName(java.lang.String name) throws android.os.RemoteException; public java.lang.String getName() throws android.os.RemoteException; }
惊不惊喜？意不意外？这下是不是有种似曾相识的赶脚？这就是一个很普通的java中的接口文件而已，结构也非常简单。
神秘的面纱揭开一层了吧！后面在讲完Client端和Server端的连接及通信后，还会继续深入剖析这个文件。
5、Client端ClientActivity连接Server端AidlService并通信
ClientActivity.java的内容如下，布局文件在此省略，比较简单，就两个按钮，一个用于绑定，一个用于解绑，看Button命名也很容易分辨。
package com.songwei.aidldemoclient; import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button; import com.songwei.aidldemoserver.IDemoService; public class ClientActivity extends AppCompatActivity { private final static String TAG = "aidlDemo";
private Button mBindBtn, mUnBindBtn;
private IDemoService mDemoService;
private boolean mIsBinded = false;
private ServiceConnection mConn = new ServiceConnection() {
//当与远程Service绑定后，会回调该方法。
@Override
public void onServiceConnected(ComponentName componentName, IBinder binder) {
Log.i(TAG, "client:[onServiceConnected]componentName=" + componentName);
mIsBinded = true;
//得到一个远程Service中的Binder代理，而不是该Binder实例
mDemoService = IDemoService.Stub.asInterface(binder);
try {
//远程控制设置name值
mDemoService.setName("Andy Song");
//远程获取设置的name值
String myName = mDemoService.getName();
Log.i(TAG, "client:[onServiceConnected]myName=" + myName);
} catch (RemoteException e) {
e.printStackTrace();
}
} //该回调方法一般不会调用，如果在解绑的时候，发现该方法没有调用，不要惊慌，因为该方法的调用时机是Service被意外销毁时，比如内存不足时。
@Override
public void onServiceDisconnected(ComponentName name) {
Log.i(TAG, "client:[onServiceDisconnected]");
mIsBinded = false;
mDemoService = null;
}
}; @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mBindBtn = (Button) findViewById(R.id.btn_bind);
mBindBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//Android5.0及以后，出于对安全的考虑，Android系统对隐式启动Service做了限制，需要带上包名或者类名，这一点需要注意。
Intent intent = new Intent();
intent.setAction("com.songwei.aidl");
intent.setPackage("com.songwei.aidldemoserver");
bindService(intent, mConn, BIND_AUTO_CREATE);
}
});
mUnBindBtn = (Button) findViewById(R.id.btn_unbind);
mUnBindBtn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//解除绑定，当调用unbindService时，一定要判断当前service是否是binded的，如果没有，就会报错。
if (mIsBinded) {
unbindService(mConn);
mDemoService = null;
mIsBinded = false;
}
}
});
}
}
代码中对一些关键和容易忽略的地方做了注释，可以结合起来进行理解。
6、运行
运行的时候，需要先启动Service端进程，才能在Client端中点击“绑定”的时候绑定成功。完成一次“绑定”和“解绑”，得到的log如下所示：
1 01-08 15:29:43.109 13532-13532/com.songwei.aidldemoserver I/aidlDemo: server:[onCreate]
2 01-08 15:29:43.110 13532-13532/com.songwei.aidldemoserver I/aidlDemo: server:[onBind]
3 01-08 15:29:43.113 13299-13299/com.songwei.aidldemoclient I/aidlDemo: client:[onServiceConnected]componentName=ComponentInfo{com.songwei.aidldemoserver/com.songwei.aidldemoserver.AidlService}
4 01-08 15:29:43.114 13532-13547/com.songwei.aidldemoserver I/aidlDemo: server:[setName]
5 01-08 15:29:43.114 13532-13546/com.songwei.aidldemoserver I/aidlDemo: server:[getName]
6 01-08 15:29:43.114 13299-13299/com.songwei.aidldemoclient I/aidlDemo: client:[onServiceConnected]myName=Andy Song
7 01-08 15:36:07.570 13299-13299/com.songwei.aidldemoclient I/aidlDemo: client:[onServiceDisconnected]
可以结合前面的ClientActivity.java和AidlService.java代码中的添加的log，来理解一下这个流程。当然，最好是能够按照上面的步骤，亲自动手实现一遍，比看10遍更有效果。
本节对介绍了AIDL最基本的知识，出于项目性质的原因，可能有些Android开发人员工作了好几年都不一定需要完整写一个AIDL实现两个App通信的功能。笔者就是这样，在前几年的工作中，虽然很早就知道AIDL这个东西，但确实是项目中就没有写过这个功能，直到最近两年。所以即便是读者您有不少开发经验了，也可能和笔者一样是个AIDL的初级开发者，这也是我花这么长的篇幅写这个基础内容的原因。
七、AIDL的深入使用和理解
前面一节讲了AIDL最进本的知识，这一节中将会结合更复杂的场景，更深入地介绍AIDL。（这一节的内容会持续补充完整）
1、Client端是如何实现调用Server端方法的
2、AIDL支持的数据类型
3、AIDL数据类序列化问题
4、AIDL回调的使用
当Server端某个操作执行完后，需要通知Client端自己完成了任务，这个时候回调就带来了很大的便利，和在同一个App中使用回调效果一样。例如在上一节的例子中，Server完成了setName()这个操作（耗时的异步操作更能体现回调的作用）后，要通知Client端自己完成了任务，可以进行下一步的操作了，就是这样一个场景。现在在前面AIDL例子基础上，对回调的使用步骤进行说明。
源码地址链接: https://pan.baidu.com/s/1eI8chrxYTGqSaIaeMZEOYg 提取码: 84cd 。
（1）在Server端IDemoService.aidl同一目录中添加一个新的.aidl接口文件，我这里命名为IDemoCallback.aidl，内容如下：
// =====IDemoCallback.aidl======
package com.songwei.aidldemoserver;
// Declare any non-default types here with import statements
interface IDemoCallback {
void testCallback(String msg);
}
（2）在IDemoService.aidl中添加注册/反注册两个方法
// =======IDemoService.aidl======
package com.songwei.aidldemoserver; // Declare any non-default types here with import statements
import com.songwei.aidldemoserver.IDemoCallback; interface IDemoService { void setName(String name); String getName(); void registerCallback(IDemoCallback cb); void unregisterCallback(IDemoCallback cb);
}
第13行和第15行为新增的方法。将这两个.aidl文件同步到Client端，使C/S两端的aidl文件完全一样，均为
最好将两个app都编译一遍，这样后面有些地方可以用代码补全，而不用手动书写。当然在AidlService.java中实现接口的时候肯定会报错的，把新增的方法补上就可以了。
（3）在AidlService.java中添加如下加粗部分的代码，
private RemoteCallbackList<IDemoCallback> mCallbacks = new RemoteCallbackList<>();
private void callback(String msg) {
int N = mCallbacks.beginBroadcast();
for (int i = 0; i < N; i++) {
try {
mCallbacks.getBroadcastItem(i).testCallback(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
mCallbacks.finishBroadcast();
}
class MyBinder extends IDemoService.Stub {
private String mName = "";
public void setName(String name) throws RemoteException {
Log.i(TAG, "server:[setName]");
mName = name;
callback("'Andy song' is setted");
}
@Override
public String getName() throws RemoteException {
Log.i(TAG, "server:[getName]");
return mName;
}
@Override
public void registerCallback(IDemoCallback cb) throws RemoteException {
Log.i(TAG,"server:[registerCallback]");
if(cb != null){
mCallbacks.register(cb);
}
}
@Override
public void unregisterCallback(IDemoCallback cb) throws RemoteException {
Log.i(TAG,"server:[unregisterCallback]");
if(cb != null){
mCallbacks.unregister(cb);
}
}
}
RemoteCallbackList是系统提供的一个用于存储回调对象的列表，其对象mCallbacks用于存储注册的IDemoCallback对象。通过第3行的callback()方法中的内容，我们可以推测它是采用一种类似于Broadcast的方式来实现回调的。
当setName（）方法执行完毕后，callback("'Andy song' is setted")；就会把回调信息反馈给Client中注册该回调的地方了。
（4）在ClientActivity.java中注册回调并处理相关逻辑
......
public void onServiceConnected(ComponentName componentName, IBinder binder) {
//Log.i(TAG, "client:[onServiceConnected]componentName=" + componentName);
mIsBinded = true;
//得到一个远程Service中的Binder代理，而不是该Binder实例
mDemoService = IDemoService.Stub.asInterface(binder);
try {
mDemoService.registerCallback(mDemoCallback);
//远程控制设置name值
mDemoService.setName("Andy Song");
//远程获取设置的name值
String myName = mDemoService.getName();
Log.i(TAG, "client:[onServiceConnected]myName=" + myName); } catch (RemoteException e) {
e.printStackTrace();
}
......
private IDemoCallback mDemoCallback = new IDemoCallback.Stub() {
@Override
public void testCallback(String msg) throws RemoteException {
Log.i(TAG, "client:[testCallback] msg=" + msg);
}
};
......
private void unRegisterCallback() {
try {
mDemoService.unregisterCallback(mDemoCallback);
} catch (RemoteException e) {
e.printStackTrace();
}
}
......
在解绑定的地方调用unRegisterCallback()反注册回调即可，这样就完成了代码整个代码的编写。这里需要注意注册回调的时机，一定要在setName()执行前注册，否则Client端收不到回调信息。
（5）运行C/S端，然后“绑定”/“解绑”，就会看到如下log信息：
1 01-11 14:11:44.714 5903-5903/com.songwei.aidldemoserver I/aidlDemo: server:[onCreate]
2 01-11 14:11:44.715 5903-5903/com.songwei.aidldemoserver I/aidlDemo: server:[onBind]
3 01-11 14:11:44.720 5903-5916/com.songwei.aidldemoserver I/aidlDemo: server:[registerCallback]
4 01-11 14:11:44.720 5903-5916/com.songwei.aidldemoserver I/aidlDemo: server:[setName]
5 01-11 14:11:44.721 6572-6572/com.songwei.aidldemoclient I/aidlDemo: client:[testCallback] msg='Andy song' is setted
6 01-11 14:11:44.722 5903-5916/com.songwei.aidldemoserver I/aidlDemo: server:[getName]
7 01-11 14:11:44.722 6572-6572/com.songwei.aidldemoclient I/aidlDemo: client:[onServiceConnected]myName=Andy Song
8 01-11 14:11:58.589 5903-5916/com.songwei.aidldemoserver I/aidlDemo: server:[unregisterCallback]
9 01-11 14:11:58.616 5903-5903/com.songwei.aidldemoserver I/aidlDemo: server:[onUnbind]
10 01-11 14:11:58.617 5903-5903/com.songwei.aidldemoserver I/aidlDemo: server:[onDestroy]
第5行就是回调信息，表示回调成功。
结语
本文主要是笔者用来整理跨进程通信的知识点，以及复习近两年才真正会用的AIDL，所以详略上是前半部分略，后半部分详，完全是按照笔者对知识点掌握程度来行文的。读者在阅读中，如果有些部分因为写得太简略而看得不过瘾，只能自己去查更详细的资料了；如果有些部分因为写得太详细而嫌啰嗦，完全可以跳着看；如果有些知识点因为笔者经验和水平问题写得有误或者阐述欠妥，请不吝赐教，万分感激！！！