Service的跨进程通信实战
设想这么一个场景，我们有2个APP(或者2个进程，均可)，其中一个APP需要提供一个Person相关的服务（该服务有一个名为eat的接口），我们叫它PersonServer；另一个APP需要访问PersonServer提供的服务，我们叫它Client。也就是现在有2个APP，一个作为Server端，提供服务，另一个作为Client端，使用服务。
我们来看如何在Android中实现？
PersonServer端实现
PersonServer端是服务的提供者，我们首先需要创建一个Service来提供该服务，并且需要该服务具备跨进程通信的能力，以便Client端进行调用。
实现AIDL
跨进行，我们首先想到的是使用AIDL来实现接口的跨进程能力。
首先我们需要定义一个名为IPerson的AIDL接口，并提供eat方法：
package com.testaidl;
interface IPerson {
boolean eat(String food);
}
我们看到，IPerson的实现非常简单，我们使用IDE编译一下，编译器就会生成一个名为IPerson.java的文件，即aidl所对应的java代码。
实现Service
接下来我们定义一个Service：
public class PersionService extends Service
{
@Override
public void onCreate() {
super.onCreate();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new IPerson.Stub() {
@Override
public boolean eat(String food) throws RemoteException {
Log.d("PersionService", "this is Server");
Log.d("PersionService", "Persion eat " + food);
return true;
}
};
}
}
这里重点来看onBind方法，该方法返回一个IBinder对象，这里也就是之前我们定义的IPerson.aidl的生成类IPerson.Stub，IPerson.Stub类有一个抽象方法eat()需要在这里实现，这里也就是该服务所提供的远程服务所执行动作的具体实现。
别忘了在AndroidManifest中注册：
<service android:name=".PersionService">
<intent-filter>
<action android:name="com.example.simpledemo.PersionService"/>
</intent-filter>
</service>
Client端
Server端已经准备好了，那么Client端如何访问PersonServer所提供的服务呢？
我们来看Client端的实现：
public class MainActivity extends AppCompatActivity {
private IPerson mService = null;
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName componentName, IBinder iBinder) { //绑定Service成功后执行
mService = IPerson.Stub.asInterface(iBinder);//获取远程服务的代理对象，一个IBinder对象
try {
mService.eat("banana"); //调用远程服务的接口。
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName componentName) {
mService = null;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Button bindService = findViewById(R.id.bind_service);
bindService.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//调用bindService发送绑定远程服务的请求
Intent intent = new Intent();
intent.setAction("com.example.simpledemo.PersionService");
intent.setPackage("com.example.simpledemo");
bindService(intent, mConnection, BIND_AUTO_CREATE);
}
});
}
}
步骤分析：
- 调用bindService发送绑定远程服务的请求。
- ServiceConnection对象在绑定Service后执行回调函数onServiceConnected。
- 在onServiceConnected中，获取远程服务的代理对象，一个IBinder对象。
- 最后，通过上一步获取的远程服务代理对象，调用远程服务的接口。
注意
别忘了需要在Client端的同样位置，放置IPerson.aidl文件，包名，文件名等都保持一致。
Service/AIDL远程调用过程解析
在Serivce的远程通信过程中，最关键的点就是AIDL，它承担了远程通信访问的任务，它的低层实现当然也是通过Binder机制来实现的，但是AIDL于Binder相比，简化了我们的使用。
IPerson.aidl
我们首先来看IPerson.aidl：
package com.testaidl;
interface IPerson {
boolean eat(String food);
}
它的实现非常简单，那它是怎么实现远程通信的能力的呢？
我们知道，aidl文件经过编译器编译后，会生成一个.java文件，这个java文件才是真正存放远程通信实现逻辑代码的地方。
IPerson.java：
package com.testaidl;
// Declare any non-default types here with import statements
public interface IPerson extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.testaidl.IPerson
{
private static final java.lang.String DESCRIPTOR = "com.testaidl.IPerson";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.testaidl.IPerson interface,
* generating a proxy if needed.
*/
public static com.testaidl.IPerson asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.testaidl.IPerson))) {
return ((com.testaidl.IPerson)iin);
}
return new com.testaidl.IPerson.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
{
java.lang.String descriptor = DESCRIPTOR;
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(descriptor);
return true;
}
case TRANSACTION_eat:
{
data.enforceInterface(descriptor);
java.lang.String _arg0;
_arg0 = data.readString();
boolean _result = this.eat(_arg0);
reply.writeNoException();
reply.writeInt(((_result)?(1):(0)));
return true;
}
default:
{
return super.onTransact(code, data, reply, flags);
}
}
}
private static class Proxy implements com.testaidl.IPerson
{
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 boolean eat(java.lang.String food) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
boolean _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(food);
boolean _status = mRemote.transact(Stub.TRANSACTION_eat, _data, _reply, 0);
if (!_status && getDefaultImpl() != null) {
return getDefaultImpl().eat(food);
}
_reply.readException();
_result = (0!=_reply.readInt());
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public static com.testaidl.IPerson sDefaultImpl;
}
static final int TRANSACTION_eat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
public static boolean setDefaultImpl(com.testaidl.IPerson impl) {
if (Stub.Proxy.sDefaultImpl == null && impl != null) {
Stub.Proxy.sDefaultImpl = impl;
return true;
}
return false;
}
public static com.testaidl.IPerson getDefaultImpl() {
return Stub.Proxy.sDefaultImpl;
}
}
public boolean eat(java.lang.String food) throws android.os.RemoteException;
}
我们定义aidl时，也只用了几行代码，而这个生成的java类里面，代码还是非常多的。
我们首先来看它的类结构：
它的结构可以分为以下几个部分；
- 接口IInterface。
- 抽象方法eat。
- 内部类Stub。
- Stub的内部类Proxy。
我们分别来分析这几个组成部分。
1. 接口IInterface
接口android.os.IInterface：
public interface IInterface
{
/**
* Retrieve the Binder object associated with this interface.
* You must use this instead of a plain cast, so that proxy objects
* can return the correct result.
*/
public IBinder asBinder();
}
这里只是提供了一个必须实现的方法asBinder()，它会返回与IInterface接口关联的IBinder对象。
在IPerson.java中，asBinder方法仍然是抽象方法，不必去实现，IPerson的主要作用是提供接口的抽象类，真正的实现在它的子类Stub中。
2. 抽象方法eat
这个是一个待实现的抽象方法，最终是由Server端的调用者实现的，在该例中，实在PersionService中实现的：
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new IPerson.Stub() {
@Override
public boolean eat(String food) throws RemoteException {
Log.d("PersionService", "this is Server");
Log.d("PersionService", "Persion eat " + food);
return true;
}
};
}
3. 内部类Stub
这个内部类是实现IPC的主要逻辑，所有的外部使用，通常都是通过对它的调用来实现的。
Stub类继承了Binder类，并实现了IPerson接口。
构造方法
Stub的实例对象实在PersonServer端创建的，即它是在Server端进行实例化的。
它的构造方法：
private static final java.lang.String DESCRIPTOR = "com.testaidl.IPerson";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
直接调用了父类Binder的attachInterface方法：
public void attachInterface(@Nullable IInterface owner, @Nullable String descriptor) {
mOwner = owner;
mDescriptor = descriptor;
}
这里把当前对象和一个描述字符串赋值给相应变量，以便以后查找时使用。
asInterface方法
asInterface方法，返回一个IPerson对象，Client端获取服务对象的时候，调用的就是该方法：
mService = IPerson.Stub.asInterface(iBinder);
asInterface方法实在Client端进行调用的，它返回一个PersonServer服务在Client端的一个代理对象。
我们来看它的逻辑实现：
public static com.testaidl.IPerson asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.testaidl.IPerson))) {
return ((com.testaidl.IPerson)iin);
}
return new com.testaidl.IPerson.Stub.Proxy(obj);
}
逻辑解析：
- 如果参数obj为null则return null。obj是一个IBinder对象，obj是onServiceConnected方法的参数，代表了连接服务成功后的返回参数，如果是同进程，则该对象就是IPerson这个服务的实例，如果是跨进程，则它是IPerson在Client的远程代理对象。
- 如果参数obj不为空，则尝试通过obj.queryLocalInterface(DESCRIPTOR)获取IPerson服务对象的实例，如果成功则直接返回该实例。此处不会真正跨进程。
- 最后，创建一个IPersion服务的代理对象（在客户端的代理对象）IPerson.Stub.Proxy，然后返回它，作为跨进程通信时，IPersion的代理引用。
queryLocalInterface的实现
queryLocalInterface方法用来查询当前进程中是否存在对应的服务，如果当前进程中存在，则代表是本进程调用，不涉及跨进程，直接返回对应的服务引用即可。
public @Nullable IInterface queryLocalInterface(@NonNull String descriptor) {
if (mDescriptor != null && mDescriptor.equals(descriptor)) {
return mOwner;
}
return null;
}
mOwner是在Stub的构造方法中赋值的，如果PersonServer服务提供者和Client服务使用者都在同一个进程，则mOwner必然不为空。
接下来就剩下跨进程的情况了，我们来分析Proxy这个内部类。
4. Stub的内部类Proxy
Proxy类在Client端创建，作为远程Service端在Client端的一个代理类，协助访问远程服务。Proxy类实现了IPerson接口。
Proxy的构造方法
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
这里保存了，服务连接成功后由onServiceConnected方法传递过来的远程Server的IBinder对象。
eat方法
当Client通过Proxy对象调用IPerson的eat方法时，eat方法内部会通过Proxy创建时保存的远程IBinder对象来进行远程调用。
static final int TRANSACTION_eat = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
@Override public boolean eat(java.lang.String food) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
boolean _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(food);
boolean _status = mRemote.transact(Stub.TRANSACTION_eat, _data, _reply, 0);
if (!_status && getDefaultImpl() != null) {
return getDefaultImpl().eat(food);
}
_reply.readException();
_result = (0!=_reply.readInt());
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public static com.testaidl.IPerson sDefaultImpl;
}
TRANSACTION_eat值在跨进程调用时会使用，这里注意一下。
逻辑解析：
- 创建一个Parcel作为eat远程方法的输入参数。
- 创建一个Parcel作为eat远程方法的返回值。
- 调用远程IBinder对象（这里其实也是一个代理对象，不过我们可以看做是远程IBinder对象）的transact()方法，把远程方法eat的唯一标识、参数、返回值引用、是否同步几个对象作为参数传递给transact()方法。
- 远程调用完成后，获取调用结果，处理错误等信息，最后取出远程方法的返回值并直接返回。
远程调用过程解析
经过以上分析，我们基本明白了远程服务调用的整个过程，但是在这里，还有一点是系统内部实现的，也就是远程调用transact等相关逻辑的处理过程。我们接下来详细分析一下。
boolean _status = mRemote.transact(Stub.TRANSACTION_eat, _data, _reply, 0);
调用远程代理对象的transact方法，该方法是在Binder类中实现的，实现逻辑如下：
android.os.Binder
public final boolean transact(int code, @NonNull Parcel data, @Nullable Parcel reply,
int flags) throws RemoteException {
if (false) Log.v("Binder", "Transact: " + code + " to " + this);
if (data != null) {
data.setDataPosition(0);
}
boolean r = onTransact(code, data, reply, flags);
if (reply != null) {
reply.setDataPosition(0);
}
return r;
}
到了这里，当前的调用进程已经由Client端转到了PersonServer端了，转换过程由Binder底层帮我们实现了，这里可以简单的认为是在远程调用即可。
这里调用了onTransact方法进行处理：
com.testaidl.IPerson#Stub
@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
java.lang.String descriptor = DESCRIPTOR;
switch (code)
{
case INTERFACE_TRANSACTION:
{
reply.writeString(descriptor);
return true;
}
case TRANSACTION_eat:
{
data.enforceInterface(descriptor);
java.lang.String _arg0;
_arg0 = data.readString();
boolean _result = this.eat(_arg0);
reply.writeNoException();
reply.writeInt(((_result)?(1):(0)));
return true;
}
default:
{
return super.onTransact(code, data, reply, flags);
}
}
}
这里读取了由Client端传来的参数，并调用真正的IPerson的eat方法实现，最终将结果返回。
eat实现代码：
com.example.simpledemo.PersionService
public IBinder onBind(Intent intent) {
return new IPerson.Stub() {
@Override
public boolean eat(String food) throws RemoteException {
Log.d("PersionService", "this is Server");
Log.d("PersionService", "Persion eat " + food);
return true;
}
};
}
真正的远程接口实现就是在PersionService类中的这个IPerson.Stub对象。
小结
本文从实践的角度，详细分析了Service实现跨进程调用的具体实现，以及调用过程、原理分析。
调用过程可概括为：
- Service跨进程提供服务需要通过AIDL来实现（底层实际上使用的是Binder）。
- Client端通过PersionService绑定一个远程Service。
- 绑定成功后Client通过ServiceConnection的onServiceConnected方法获取到远程服务的本地IBinder代理对象。
- Client通过远程服务IBinder代理对象获得服务接口（IPerson）在Client端的代理对象（如果是同一个进程则直接返回IBidner服务对象）。
- Client调用远程代理对象的eat方法，底层通过Binder驱动，调用到Server端的transact方法。
- Server端的transact方法又调用了IPerson.Stub的onTransact方法。
- Server端的onTransact方法调用了eat方法的最终实现——PersionService类中的创建的IPerson.Stub对象。
