Android Binder进程间通信工具AIDL使用示例深入分析

目录

• 前言
• AIDL
• AIDL示例
• 客户端
• 运行日志
• AIDL通信过程分析
• bindService流程分析

前言

众所周知，Android进程间通信采用的是Binder机制。Binder是Android系统 独有的进程间通信方式，它是采用mmp函数将进程的用户空间与内核空间的一块内存区域进行映射，免去了一次数据拷贝，相比Linux上的传统IPC具有高效、安全的优点。本文结合AIDL与bindService函数，在Android体系的应用层和Framework层，对Binder通信进行深入剖析，以加深对Binder的了解。

AIDL

AIDL是Android接口描述语言，它也是一个工具，能帮助我们自动生成进程间通信的代码，省去了很多工作。既然它是一个工具，其实也不是必需的。笔者结合AIDL生成的代码进行剖析，分析它生成的代码是如何进程IPC通信的。

AIDL示例

服务端

创建PersonController.aidl文件：

在src目录包名com.devnn.libservice上右键点击创建AIDL文件并全名为PersonController，就会在aidl目录下创建同名的aidl文件。

// PersonController.aidl
package com.devnn.libservice;
import com.devnn.libservice.Person;
// Declare any non-default types here with import statements
interface PersonController {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    List getPersons();
    void addPerson(inout Person person);
}

形参上的inout修饰表示数据可以发送到服务端进程，而且服务端进程对数据的修改，也会同步到客户端进程。还有另外两个方式in和out，表示单向的传输。当使用in时，服务端对person对象的修改，客户端是无法感知的。当使用out时，客户端发送过去的字段是空的，返回的数据是服务端的。

创建Person.aidl文件:

// Person.aidl
package com.devnn.libservice;
// Declare any non-default types here with import statements
parcelable Person;

创建Person.java文件，Person类需要实现Parcelable接口：

package com.devnn.libservice
import android.os.Parcel
import android.os.Parcelable
class Person(var name: String?, var age: Int) : Parcelable {
    constructor(parcel: Parcel) : this(parcel.readString(), parcel.readInt()) {
    }
 	/**
     * 字段写入顺序和读取顺序要保持一致
     */
    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(name)
        parcel.writeInt(age)
    }
	/**
     * readFromParcel不是必需的，在aidl文件中函数参数类型是inout时需要。
     */
    fun readFromParcel(parcel: Parcel) {
        name = parcel.readString()
        age = parcel.readInt()
    }
	/**
     * 默认即可
     */
    override fun describeContents(): Int {
        return 0
    }
    companion object CREATOR : Parcelable.Creator {
        override fun createFromParcel(parcel: Parcel): Person {
            return Person(parcel)
        }
        override fun newArray(size: Int): Array {
            return arrayOfNulls(size)
        }
    }
}

创建MyService类继承Service类：

package com.devnn.libservice
import android.app.Application
import android.app.Service
import android.content.Intent
import android.os.Binder
import android.os.IBinder
import android.os.Build
import android.util.Log
import java.util.ArrayList
class MyService : Service() {
    override fun onCreate() {
        super.onCreate()
        Log.d("MyService", "onCreate")
		/**
         * 为了证明是在新进程中运行，将进程名打印出来
         * 在android 33设备上运行的。
         */
        if (Build.VERSION.SDK_INT >= 28) {
            val processName = Application.getProcessName()
            Log.d("MyService", "processName=$processName")
        }
    }
    override fun onBind(intent: Intent): IBinder? {
        Log.d("MyService", "onBind")
        return binder
    }
	private val binder: Binder = object : PersonController.Stub() {
          override fun getPersons(): List {
              Log.d("MyService", "getPersons")
              val list: MutableList = ArrayList()
              list.add(Person("张三", 20))
              list.add(Person("李四", 21))
              return list
          }
          override fun addPerson(person: Person) {
              Log.d("MyService", "addPerson")
              Log.d("MyService", "name=${person.name},age=${person.age}")
            }
        }
}

为了让MyService在独立进程运行，在Manifest声明时需要注明是新进程：

android:process=“com.devnn.libservice.MyService” 表示是独立进程，用冒号开头就示是子进程或叫私有进程，不用冒号开头表示是独立进程。注意进程名中间不能用冒号，比如这种就不行：com.devnn.xxx:MyService。

以上代码是在单独的libservice module中编写的，结构如下：

客户端

在appmodule中创建客户端代码，命名为ClientActivity，只有三个按钮，id分别btn1、btn2、btn3，功能分别对应bindService、getPersons、addPersons，代码如下：

package com.devnn.demo
import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.Bundle
import android.os.IBinder
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import com.devnn.libservice.Person
import com.devnn.libservice.PersonController
import com.devnn.demo.databinding.ActivityClientBinding
class ClientActivity : AppCompatActivity() {
    private val binding by lazy {
        ActivityClientBinding.inflate(this.layoutInflater)
    }
    private lateinit var personController: PersonController
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)
        //bindService
        binding.btn1.setOnClickListener {
            val intent = Intent().apply {
                component =
                    ComponentName([email protected], "com.devnn.libservice.MyService")
            }
            bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
        }
        //getPersons
        binding.btn2.setOnClickListener {
            personController?.let {
                val list = it.persons;
                list?.map {
                    Log.i("ClientActivity", "person:name=${it.name},age=${it.age}")
                }
            }
        }
        //addPerson
        binding.btn3.setOnClickListener {
            personController?.let {
                val person = Person("王五", 22)
                it.addPerson(person)
            }
        }
    }
    private val serviceConnection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            Log.i("ClientActivity", "onServiceConnected")
            personController = PersonController.Stub.asInterface(service)
        }
        override fun onServiceDisconnected(name: ComponentName?) {
            Log.i("ClientActivity", "onServiceDisconnected")
        }
    }
}

运行界面如下：

客户端与服务端进程的aidl文件要保持一致，可以将服务端的aidl拷贝到客户端。如果客户端在单独module，并且依赖了service所在的module，也可以不用拷贝aidl。

运行日志

运行后，点击bindService按钮输出日志如下：

在Logcat查看进程列表也出现了2个：

点击getPersons按钮，输出日志如下:

可以看到，客户端进程可以正常获取服务端进程的数据。

点击addPerson按钮，输出日志如下：

可以看到，服务端进程可以正常接收客户端进程的发来的数据。

以上是AIDL使用的一个例子，下面分析AIDI通信的过程。

AIDL通信过程分析

项目build后就会自动在build目录下生成对应的Java代码：

PersonController.java代码如下：

/*
 * This file is auto-generated.  DO NOT MODIFY.
 */
package com.devnn.libservice;
// Declare any non-default types here with import statements
public interface PersonController extends android.os.IInterface
{
  /** Default implementation for PersonController. */
  public static class Default implements com.devnn.libservice.PersonController
  {
    /**
         * Demonstrates some basic types that you can use as parameters
         * and return values in AIDL.
         */
    @Override public java.util.List getPersons() throws android.os.RemoteException
    {
      return null;
    }
    @Override public void addPerson(com.devnn.libservice.Person person) throws android.os.RemoteException
    {
    }
    @Override
    public android.os.IBinder asBinder() {
      return null;
    }
  }
  /** Local-side IPC implementation stub class. */
  public static abstract class Stub extends android.os.Binder implements com.devnn.libservice.PersonController
  {
    private static final java.lang.String DESCRIPTOR = "com.devnn.libservice.PersonController";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an com.devnn.libservice.PersonController interface,
     * generating a proxy if needed.
     */
    public static com.devnn.libservice.PersonController asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof com.devnn.libservice.PersonController))) {
        return ((com.devnn.libservice.PersonController)iin);
      }
      return new com.devnn.libservice.PersonController.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_getPersons:
        {
          data.enforceInterface(descriptor);
          java.util.List _result = this.getPersons();
          reply.writeNoException();
          reply.writeTypedList(_result);
          return true;
        }
        case TRANSACTION_addPerson:
        {
          data.enforceInterface(descriptor);
          com.devnn.libservice.Person _arg0;
          if ((0!=data.readInt())) {
            _arg0 = com.devnn.libservice.Person.CREATOR.createFromParcel(data);
          }
          else {
            _arg0 = null;
          }
          this.addPerson(_arg0);
          reply.writeNoException();
          if ((_arg0!=null)) {
            reply.writeInt(1);
            _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
          }
          else {
            reply.writeInt(0);
          }
          return true;
        }
        default:
        {
          return super.onTransact(code, data, reply, flags);
        }
      }
    }
    private static class Proxy implements com.devnn.libservice.PersonController
    {
      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;
      }
      /**
           * Demonstrates some basic types that you can use as parameters
           * and return values in AIDL.
           */
      @Override public java.util.List getPersons() throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        java.util.List _result;
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          boolean _status = mRemote.transact(Stub.TRANSACTION_getPersons, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().getPersons();
          }
          _reply.readException();
          _result = _reply.createTypedArrayList(com.devnn.libservice.Person.CREATOR);
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
        return _result;
      }
      @Override public void addPerson(com.devnn.libservice.Person person) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          if ((person!=null)) {
            _data.writeInt(1);
            person.writeToParcel(_data, 0);
          }
          else {
            _data.writeInt(0);
          }
          boolean _status = mRemote.transact(Stub.TRANSACTION_addPerson, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().addPerson(person);
            return;
          }
          _reply.readException();
          if ((0!=_reply.readInt())) {
            person.readFromParcel(_reply);
          }
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      public static com.devnn.libservice.PersonController sDefaultImpl;
    }
    static final int TRANSACTION_getPersons = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_addPerson = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    public static boolean setDefaultImpl(com.devnn.libservice.PersonController impl) {
      // Only one user of this interface can use this function
      // at a time. This is a heuristic to detect if two different
      // users in the same process use this function.
      if (Stub.Proxy.sDefaultImpl != null) {
        throw new IllegalStateException("setDefaultImpl() called twice");
      }
      if (impl != null) {
        Stub.Proxy.sDefaultImpl = impl;
        return true;
      }
      return false;
    }
    public static com.devnn.libservice.PersonController getDefaultImpl() {
      return Stub.Proxy.sDefaultImpl;
    }
  }
  /**
       * Demonstrates some basic types that you can use as parameters
       * and return values in AIDL.
       */
  public java.util.List getPersons() throws android.os.RemoteException;
  public void addPerson(com.devnn.libservice.Person person) throws android.os.RemoteException;
}

仔细观察会发现，这个接口有个Stub静态抽象内部类，里面有一个asInterface方法、onTransact方法，Proxy静态内部类是我们要关注的。

客户端进程调用 PersonController.Stub.asInterface(service)这个代码实际上就返回了Proxy这个代理对象，当调用getPersons和addPerson方法时，也相当于调用Proxy代理类里的对应的方法。

拿addPerson方法举例，这个方法实际上把JavaBean对象转成了Pacel类型的对象，然后调用IBinder的transact方法开始进程间通信。

addPerson方法进程间通信调用的方法如下：

mRemote.transact(Stub.TRANSACTION_getPersons, _data, _reply, 0);

mRemote就是通过binderService获取到的服务端进程的IBinder对象。

第一个参数Stub.TRANSACTION_getPersons表示要调用的方法ID。

第二个参数_data就是要发送给服务端的数据

第三个参数_reply就是服务端返给客户端的数据。

第四个参数0表示是同步的，需要等待服务端返回数据，1表示异步不需要等待服务端返回数据。

整体来说Proxy这个类就是给客户端使用的代码。

Stub这个类是给服务端使用的代码。

注意：谁主动发起通信谁就是客户端，接收通信是服务端。有时候一个进程同时充当客户端和服务端，比如app与ams的通信，app既充当客户端也充当服务端。

Stub类的onTransact方法就是服务端被调用时的回调函数。

boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)

第一个参数code表示调用的方法ID

第二个参数data表示调用方发来的数据

第三个参数reply表示服务端需要回传的数据

第四个参数flags表示同步还是异步。

注意这个onTransact方法是在binder服务端的binder线程池被调用的，也就是在子线程调用的。所以上面的MyService里的getPersons和addPersons方法是在子线程里运行的，如果需要与主线程通信还得使用Handler。

经过以上分析，可以发现进程间通信实际上是拿到对方的IBinder引用后，通过调用IBinder的transact方法发送和接收Parcel类型数据进行通信。AIDL实际上是简化了Binder调用的过程，帮助我们自动生成了通信代码。我们也可以根据需要，自己编写相关代码通信。

那么客户端调用bindServcie方法是如何拿到服务端进程的IBinder对象呢？这部分涉及到android framewok层，这里把它大致流程分析一下。

bindService流程分析

调用bindService方法时，实际是调用ContextWrapper的bindService方法，Activity是继承于ContextWrapper。下面基于Android 10的源码，用流程图表示这个调用链。

整体来说，客户端进程需要与服务端进程通信，先要获取服务端的binder对象，这中间需要经过AMS(Activity Manager Service)服务作为中介。先向AMS发起请求(bindService，携带ServiceConnection对象)，AMS再跟服务端进程通信，服务端进程把binder给到AMS，AMS再通过ServiceConnection的onServiceConnected回调把binder发送给客户端进程。客户端获取到binder就可以调用transact方法发送数据。

OK，关于AIDL和Binder进程间通信就介绍到这了。

到此这篇关于Android Binder进程间通信工具AIDL使用示例深入分析的文章就介绍到这了,更多相关Android Binder AIDL内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！