【视频文稿】车载Android应用开发与分析 - AIDL实践与封装（上）

本期视频地址 ： 车载Android应用开发与分析 - AIDL实践与封装（上）_哔哩哔哩_bilibili

开发手机APP时我们一般都是写一个独立的应用，很少会涉及到除了系统服务以外的多个进程间交互的情况，但开发车载应用则不同，随着车载系统需求复杂程度的逐渐提升，现代的车载应用或多或少都会涉及多进程间的交互。

实际的项目中，也会发现一些即使有着多年应用开发经验的同事，对于安卓跨进程通信的使用并不熟练，经常整出一些啼笑皆非的事故，所以本期视频我们将介绍车载Android应用开发最常用的跨进程通信方案-AIDL，以及它是如何使用和封装的。

「1. AIDL 简介」

AIDL 简介

AIDL 全称Android 接口定义语言（Android Interface Definition Language），是一种用于定义客户端和服务端之间的通信接口的语言，它可以让不同进程之间通过IPC（进程间通信）进行数据交互。

在 Android 系统中一个进程通常无法直接访问另一个进程的内存空间，这被称为Application Sandbox。因此，为了实现进程间通信，Android系统提供了用于实现跨进程通信的协议，但是实现通信协议往往比较复杂，需要将通信数据进行编组和解组，使用AIDL可以让上述操作变得简单。

AIDL的架构可以看作是一种CS（Client-Server）架构，即客户端-服务端架构。简单介绍如下：

1）「客户端」是指需要调用「服务端」提供的数据或功能的应用，它通过绑定「服务端」的Service来获取一个IBinder对象，然后通过该对象调用「服务端」暴露出来的接口方法 。

2）「服务端」是指提供数据或功能给「客户端」的应用，它通过创建一个Service并在onBind()方法中返回一个IBinder对象来实现通信接口，该对象需要重写.aidl文件中定义的接口方法 。

3）「客户端」和「服务端」需要共享一个.aidl文件，用来声明通信接口和方法，该文件会被Android SDK工具转换成一个Java接口，该接口包含一个Stub类和一个Proxy类 。

使用场景

Android 系统中的 IPC不只是有AIDL，Android系统还提供了以下几种常用的 IPC 的方式：

• Messenger

一种基于AIDL的IPC通信的方式，它对AIDL进行了封装，简化了使用过程，只需要创建一个Handler对象来处理消息。Messenger只支持单线程串行请求，只能传输Message对象，不能传输自定义的Parcelable对象。

• ContentProvider

一种用于提供数据访问接口的IPC通信的方式，它可以让不同进程之间通过URI和Cursor进行数据交互。ContentProvider可以处理多线程并发请求，可以传输任意类型的数据，但使用过程比较繁琐，需要实现多个方法。

• Socket

一种基于TCP/IP协议的IPC通信的方式，它可以让不同进程之间通过网络套接字进行数据交互。Socket可以处理多线程并发请求，可以传输任意类型的数据，但使用过程比较底层，需要处理网络异常和安全问题。

我们可以根据不同的场景和需求，选择合适的IPC的方式。一般来说：

• 如果需要实现跨应用的数据共享，可以使用ContentProvider。
• 如果需要实现跨应用的功能调用，可以使用AIDL。
• 如果需要实现跨应用的消息传递，可以使用Messenger。
• 如果需要实现跨网络的数据交换，可以使用Socket。

接下来，我们通过代码来实践一个 AIDL 通信的示例。

「2. AIDL实践 」

在编写示例之前，先做出需求定义。

假设我们有一个「服务端」，提供一个计算器的功能，可以进行加减乘除等多种运算。我们想让其他「客户端」应用也能调用这个「服务端」，进行计算，我们可以按照以下步骤来实现：

第 1 步，创建SDK工程，定义 AIDL 接口

在实际工作中，强烈建议将 AIDL 的接口封装到一个独立的工程（Module）中，使用时将该工程编译成一个jar包，再交给其它模块使用。这样做可以避免需要同时在APP工程以及Service工程中定义AIDL接口的情况，也方便我们后期的维护。

在SDK工程中，定义一个AIDL接口，声明我们想要提供的方法和参数。例如，我们可以创建一个ICalculator.aidl文件，内容如下：

interface ICalculator {
  int add(int a, int b);
  int subtract(int a, int b);
  int multiply(int a, int b);
  int divide(int a, int b);
}

第 2 步，创建 Service 工程，实现AIDL接口

在「服务端」应用中，创建一个Service类，实现AIDL接口，并在onBind方法中返回一个IBinder对象。例如，我们可以创建一个CalculatorService类，内容如下：

public class CalculatorService extends Service {

  private final Calculator.Stub mBinder = new Calculator.Stub() {
    @Override 
    public int add(int a, int b) throws RemoteException {
      return a + b;
    }

    @Override
    public int subtract(int a, int b) throws RemoteException {
      return a - b;
    }

    @Override
    public int multiply(int a, int b) throws RemoteException {
      return a * b;
    }

    @Override
    public int divide(int a, int b) throws RemoteException {
      if (b == 0) {
        throw new IllegalArgumentException("Divisor cannot be zero");
      }
      return a / b;
    }
  };

  @Override
  public IBinder onBind(Intent intent) {
    return mBinder;
  }
}

在「服务端」应用中，注册Service，并设置android:enabled和android:exported属性为true，以便其他应用可以访问它。

如果需要还可以添加一个intent-filter，指定一个action，让其他应用可以通过intent启动服务，同时服务端也可以通过读取intent中的action来过滤绑定请求。

例如，在AndroidManifest.xml文件中，我们可以添加以下代码：

<service
    android:name=".CalculatorService"
    android:enabled="true"
    android:exported="true">
    <intent-filter>
        <action android:name="com.example.calculator.CALCULATOR_SERVICE" />
    </intent-filter>
</service>

在Android 8.0之后的系统中，Service启动后需要添加Notification，将Service设定为前台Service，否则会抛出异常。

@Override
public void onCreate() {
    super.onCreate();
    Log.e(TAG, "onCreate: ");
    startServiceForeground();
}

private static final String CHANNEL_ID_STRING = "com.wj.service";
private static final int CHANNEL_ID = 0x11;

private void startServiceForeground() {
    NotificationManager notificationManager = (NotificationManager)
            getSystemService(Context.NOTIFICATION_SERVICE);
    NotificationChannel channel;
    channel = new NotificationChannel(CHANNEL_ID_STRING, getString(R.string.app_name),
            NotificationManager.IMPORTANCE_LOW);
    notificationManager.createNotificationChannel(channel);
    Notification notification = new Notification.Builder(getApplicationContext(),
            CHANNEL_ID_STRING).build();
    startForeground(CHANNEL_ID, notification);
}

第 3 步，创建客户端工程，调用AIDL接口

在「客户端」应用中，创建一个ServiceConnection对象，实现onServiceConnected和onServiceDisconnected方法，在onServiceConnected方法中获取IBinder对象的代理，并转换为AIDL接口类型。

private ICalculator mCalculator;

private ServiceConnection mConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        mCalculator = ICalculator.Stub.asInterface(service);

        // 计算 3*6
        calculate('*',3,6);
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        mCalculator = null;
    }
};

在使用计算器功能的应用中，绑定提供计算器功能的应用的Service，并传递一个Intent对象，指定提供计算器功能的应用的包名和Service类名。如果提供计算器功能的应用设置了intent-filter，还需要指定相应的action。

private void bindToServer() {
    Intent intent = new Intent();
    intent.setAction("com.wj.CALCULATOR_SERVICE");
    intent.setComponent(new ComponentName("com.wj.service", "com.wj.service.CalculatorService"));
    boolean connected = bindService(intent, mConnection, BIND_AUTO_CREATE);
    Log.e(TAG, "onCreate: " + connected);
}

获取到IBinder对象的代理后就可以通过该对象调用「服务端」提供的方法了。

private void calculate(final char operator, final int num1, final int num2) {
    try {
        int result = 0;
        switch (operator) {
            case '+':
                result = mCalculator.add(num1, num2);
                break;
            case '-':
                result = mCalculator.subtract(num1, num2);
                break;
            case '*':
                result = mCalculator.multiply(num1, num2);
                break;
            case '/':
                result = mCalculator.divide(num1, num2);
                break;
        }
        Log.i(TAG, "calculate result : " + result);
    } catch (RemoteException exception) {
        Log.i(TAG, "calculate: " + exception);
    }
}

注意，从Android 11 开始，系统对应用的可见性进行了保护，如果 build.gradle 中的Target API > = 30，那么还需要在 AndroidManifest.xml 配置queries标签指定「服务端」应用的包名，才可以绑定远程服务。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android">

    <queries>
        <package android:name="com.wj.service"/>
    </queries>

</manifest>

「3. AIDL 实践进阶」

在上面的示例中，我们介绍了简单的AIDL是如何创建的，但是在开发中，上述的示例远不足以支持实际的应用场景，接下来整理10个开发过程大概率会遇到的到问题，以及它的解决方案。

问题 1：AIDL 数据类型

上述示例中，我们使用AIDL传递的是最简单的int型数据，AIDL不仅支持int型数据，AIDL支持的数据类型有：

• Java编程语言中的所有原始类型（如int、long、char、boolean等）
• String和CharSequence
• List，只支持ArrayList,里面每个元素都必须能够被AIDL支持
• Map，只支持HashMap,里面的每个元素都必须被AIDL支持,包括key和value
• Parcelable，所有实现了Parcelable接口的对象
• Serializable，所有实现了Serializable接口的对象（不能独立传输）
• AIDL，所有的AIDL接口本身也可以在AIDL文件中使用

Parcelable

在安卓中非基本数据类型的对象，除了String和CharSequence都是不可以直接通过AIDL进行传输的，需要先进行序列化操作。序列化就是将对象转换为可存储或可传输的状态，序列化后的对象可以在网络上进行传输，也可以存储到本地。

Parcelable 是安卓实现的可序列化接口。它假定一种特定的结构和处理方式，这样一个实现了 Parcelable接口的对象可以相对快速地进行序列化和反序列化。

在接下来的例子中，我们定义一个Sample对象，并实现Parcelable接口将其序列化，在Android Studio上通过插件Android Parcelable Code Generator，我们可以很快速的将一个对象序列化，而不用自行编写代码。

紧接着我们只需要在需要序列化的类中，右键->generate->parcelable 选中需要序列化的成员变量，即可完成对象的序列化。

然后在aidl目录下同样的包名里创建Sample.aidl文件，这样Android SDK就能识别出Sample对象。

Sample.aidl文件内容如下：

// Sample.aidl
package com.wj.sdk.bean;

parcelable Sample;

在将需要传输的对象序列化后，我们在ICalculator.aidl中定义一个新的方法，并将Sample通过AIDL接口传递给「服务端」。

// ICalculator.aidl
package com.wj.sdk;

import com.wj.sdk.bean.Sample;

interface ICalculator {
  void optionParcel(in Sample sample);
  }

Serializable

Serializable 是 Java 提供的一个序列化接口，它是一个空接口，为对象提供标准的序列化和反序列化操作。使用 Serializable 来实现序列化相当简单，只需对象实现了Serializable 接口即可实现默认的序列化过程。Serializable 的序列化和反序列化过程由系统自动完成。

AIDL虽然支持Serializable序列化的对象，但是并不能直接在AIDL接口中传递Serializable的对象，必须放在一个Parcelable对象中传递。

Parcelable & Serializable 对比

Serializable 虽然使用简单，但是在AIDL中并不推荐使用，因为Serializable 使用了反射机制，效率较低，而且会产生大量的临时变量，增加内存开销。而Parcelable直接在内存中进行读写，效率较高，而且没有额外的开销。

一般来说，如果需要将数据通过网络传输或者持久化到本地，建议使用Serializable，如果只是在应用内部进行数据传递，则建议使用Parcelable。

问题 2：AIDL参数的数据流向

在上面的ICalculator.aidl中，addOptParcelable()方法中出现了in、out、inout这些关键字，是因为在传递序列化参数时，必须定义这些参数的数据流方向，in、out、inout关键字的影响主要体现在参数对象在传输过程中是否被复制和修改。具体来说：

• in：表示数据从客户端流向服务端，客户端会将参数对象复制一份并发送给服务端，服务端收到后可以对该对象进行修改，但不会影响客户端的原始对象 。
• out：表示数据从服务端流向客户端，客户端会将参数对象的空引用发送给服务端，服务端收到后可以创建一个新的对象并赋值给该引用，然后返回给客户端，客户端会将原始对象替换成服务端返回的对象 。
• inout：表示数据双向流动，客户端会将参数对象复制一份并发送给服务端，服务端收到后可以对该对象进行修改，并将修改后的对象返回给客户端，客户端会将原始对象替换成服务端返回的对象 。

使用这些关键字时，需要注意以下几点：

• 如果参数对象是不可变的（如String），则不需要使用out或inout关键字，因为服务端无法修改其内容 。
• 如果参数对象是可变的（如List或Map），则需要根据实际需求选择合适的关键字，以避免不必要的数据拷贝和传输 。
• 如果参数对象是自定义的Parcelable类型，则需要在其writeToParcel()和readFromParcel()方法中根据flags参数判断是否需要写入或读取数据，以适应不同的关键字 。

问题 3：使用AIDL传递复数个对象

AIDL支持传递一些基本类型和 Parcelable 类型的数据。如果需要传递一些复杂的对象或者多个对象以及数量不定的对象时，可以使用 Bundle 类来封装这些数据，然后通过 AIDL 接口传递Bundle对象。Bundle类是一个键值对的容器，它可以存储不同类型的数据，并且实现了Parcelable接口，所以可以在进程间传输。

如果AIDL接口包含接收Bundle作为参数（预计包含 Parcelable 类型）的方法，则在尝试从Bundle读取之前，请务必通过调用 Bundle.setClassLoader(ClassLoader) 设置Bundle的类加载器。否则，即使在应用中正确定义 Parcelable 类型，也会遇到 ClassNotFoundException。例如，

// ICalculator.aidl
package com.wj.sdk;

interface ICalculator {
    void optionBundle(in Bundle bundle);
}

如下方实现所示，在读取Bundle的中数据之前，ClassLoader 已在Bundle中完成显式设置。

@Override
public void optionBundle(final Bundle bundle) throws RemoteException {
    Log.i(TAG, "optionBundle: " + bundle.toString());
    bundle.setClassLoader(getClassLoader());
    Sample2 sample2 = (Sample2) bundle.getSerializable("sample2");
    Log.i(TAG, "optionBundle: " + sample2.toString());
    Sample sample = bundle.getParcelable("sample");
    Log.i(TAG, "optionBundle: " + sample.toString());
}

为什么需要设置类加载器？因为Bundle对象可能包含其他的Parcelable对象，而这些对象的类定义可能不在默认的类加载器中。设置类加载器可以让Bundle对象正确地找到和创建Parcelable对象。

例如，如果你想传递一个Android系统的NetworkInfo对象，你需要在AIDL文件中声明它是一个Parcelable对象：

package android.net;

parcelable NetworkInfo;

然后，在客户端和服务端的代码中，你需要在获取Bundle对象之前，设置类加载器为NetworkInfo的类加载器：

Bundle bundle = data.readBundle();
bundle.setClassLoader(NetworkInfo.class.getClassLoader());
NetworkInfo networkInfo = bundle.getParcelable("network_info");

这样，Bundle对象就可以正确地反序列化NetworkInfo对象了。

问题 4：使用 AIDL传递大文件

众所周知，AIDL是一种基于Binder实现的跨进程调用方案，Binder 对传输数据大小有限制，传输超过 1M 的文件就会报 android.os.TransactionTooLargeException 异常。不过我们依然有大文件传输的解决方案，其中一种解决办法是，使用AIDL传递文件描述符ParcelFileDescriptor，来实现超大型文件的跨进程传输。

该部分内容较多，可以查看我之前写的文章：Android 使用AIDL传输超大型文件 - 掘金

问题 5：AIDL 引起的 ANR

Android AIDL 通信本身是一个耗时操作，因为它涉及到进程间的数据传输和序列化/反序列化的过程。如果在「客户端」的主线程中调用 AIDL 接口，而且「服务端」的方法执行比较耗时，就会导致「客户端」主线程被阻塞，从而引发ANR。

为了避免 AIDL 引起的 ANR，可以采取以下这些措施：

• 不要在主线程中调用 AIDL 接口，而是使用子线程或者异步任务来进行 IPC。
• 不要在 onServiceConnected () 或者 onServiceDisconnected () 中直接操作服务端方法，因为这些方法是在主线程中执行的。
• 使用oneway键字来修饰 AIDL 接口，使得 IPC 调用变成非阻塞的。

oneway 简介

不要在主线程中直接调用「服务端」的方法，这个很好理解，我们主要来看oneway。oneway 是AIDL定义接口时可选的一个关键字，它可以修饰 AIDL 接口中的方法，修改远程调用的行为。

oneway主要有以下两个特性：

• 将远程调用改为「异步调用」，使得远程调用变成非阻塞式的，客户端不需要等待服务端的处理，只是发送数据并立即返回。
• oneway 修饰方法，在同一个IBinder对象调用中，会按照调用顺序依次执行。

使用场景

使用oneway的场景一般是当你不需要等待服务端的返回值或者回调时，可以提高 IPC 的效率。

oneway可以用来修饰在interface之前，这样会让interface内所有的方法都隐式地带上oneway，也可以修饰在interface里的各个方法之前。

例如：例如，你可能需要向服务端发送一些控制命令或者通知，而不关心服务端是否处理成功。

// ICalculator.aidl
package com.wj.sdk;

interface ICalculator {
    oneway void optionOneway(int i);
}

或直接将oneway添加在interface前。

// ICalculator.aidl
package com.wj.sdk;

oneway interface ICalculator {
    void optionOneway(int i);
}

注意事项

给AIDL接口添加oneway关键词有以下的事项需要注意：

• oneway 修饰本地调用没有效果，仍然是同步的，「客户端」需要等待「服务端」的处理。

本地调用是指「客户端」和「服务端」在同一个进程中，不需要进行 IPC 通信，而是直接调用 AIDL 接口的方法。这种情况下，oneway就失效了，因为没有进程间的数据传输和序列化/反序列化的过程，也就没有阻塞的问题。

• oneway 不能用于修饰有返回值的方法，或者抛出异常，因为「客户端」无法接收到这些信息。
• 同一个IBinder对象进行oneway调用，这些调用会按照原始调用的顺序依次执行。不同的IBinder对象可能导致调用顺序和执行顺序不一致。

同一个IBinder对象的oneway调用，会按照调用的顺序依次执行，这是因为内核中每个IBinder对象都有一个oneway事务的队列，只有当上一个事务完成后才会从队列中取出下一个事务。也是因为这个队列的存在，所以不同IBinder对象oneway调用的执行顺序，不一定和调用顺序一致。

• oneway 要谨慎用于修饰调用极其频繁的IPC接口

当「服务端」的处理较慢，但是「客户端」的oneway调用非常频繁时，来不及处理的调用会占满binder驱动的缓存，导致transaction failed，如果你对分析过程感兴趣，可以参考这篇文章：https://www.jianshu.com/p/4c8d346185cb。

「6. 总结」

本期视频我们介绍了车载Android开发中最常用的跨进程通信方式-AIDL，不过由于内容太多，所以会分成上下两个部分。本篇，主要聚焦在一些常见的使用场景上，下一篇，我们将介绍AIDL接口权限控制、封装、方法索引等内容。

好，以上就是本视频的全部内容了。本视频的文字内容发布在我的个人微信公众号-『车载 Android』和我的个人博客中，视频中使用的 PPT 文件和源码发布在我的Github[https://github.com/linxu-link/CarAndroidCourse]上，在本视频的简介里可以找到相应的地址。

感谢您的观看，我们下期视频再见，拜拜。