Android 浅度解析：AIDL & Binder (1)

浅介

AIDL（Android Interface Definition Language）是一种类似于其他IDL（接口定义语言）的语言，它可以让定义一个接口，这个接口中声明的方法可以在不同的进程中调用。这在Android中非常有用，例如，如果需要从另一个运行在不同进程的应用程序（例如音乐播放器或者地图应用）中获取服务，这时就可以使用AIDL。

本章将介绍以下几个方面：

• 了解IPC和AIDL
• AIDL关键字的理解
• 创建和使用AIDL文件
• 为什么要extends IInterface
• Binder机制和其在AIDL中的应用
• 使用AIDL时可能遇到的问题，以及如何处理这些问题

注意: 本文适合做Android 系统框架层开发的靓仔 , 这部分是做接口服务的基础。

了解IPC和AIDL

在多任务操作系统中，可能会有多个独立的进程同时运行。这些进程彼此之间是隔离的，它们有各自的地址空间，不能直接访问彼此的数据。然而，有时候进程之间需要进行数据交换或者协同工作，这就需要进程间通信（IPC）。

在Android中，IPC的一种实现方法就是使用AIDL。AIDL让可以定义一个接口，该接口中声明的方法可以在不同的进程中调用。这非常有用，例如，如果正在编写一个应用程序，该应用程序需要从另一个运行在不同进程的应用程序（例如音乐播放器或者地图应用）中获取服务，这时就可以使用AIDL。

举例来说，假设正在开发一个应用，需要使用到音乐播放服务。可以通过AIDL来定义一个接口，这个接口中声明了需要的各种方法，如play()、pause()、stop()等。然后音乐播放器就可以实现这个接口，应用就可以调用这些方法来控制音乐播放。

这就是为什么需要使用AIDL的原因：它提供了一种在Android系统中进行进程间通信的有效方式。在理解了AIDL的作用和它在Android系统中的使用场景之后，就可以开始学习如何使用AIDL了。

AIDL关键字的理解

在AIDL中，有几个关键字需要了解，它们会影响参数如何在进程间传递。

• oneway：这个关键字表示方法是异步的。这意味着调用这个方法的客户端不会等待方法完成就返回。这对于可能需要长时间运行的操作特别有用，因为它可以防止客户端线程阻塞。
• in，out，inout：这些关键字用来指定参数的传递方向。in表示数据只能从客户端（调用方）传递到服务端（被调用方）。out表示数据只能从服务端返回到客户端。inout表示数据可以在客户端和服务端之间双向传递。

举例来说，假设在AIDL接口中有一个名为setVolume的方法，这个方法接收一个int类型的参数volume，并且这个参数是从客户端传递到服务端的。那么，可以这样定义这个方法：

void setVolume(in int volume);

这里的in关键字表示volume参数是从客户端传递到服务端的。如果这个方法需要返回当前音量给客户端，可以添加一个out参数：

void getVolume(out int volume);

如果一个方法需要在客户端和服务端之间双向传递数据，可以使用inout关键字：

void adjustVolume(inout int volume);

理解这些关键字如何影响参数的传递是学习AIDL的关键部分，因为它们决定了接口如何交互和传递数据。在下一节中，将会学习如何在Android项目中创建AIDL文件，并定义接口和方法。

AIDL关键字的默认值

如果在AIDL文件中定义方法时没有明确指定oneway、in、out或inout等关键字，它们会有默认的行为：

• 对于oneway，如果没有指定，那么默认情况下，该方法将是同步的，也就是说，调用方（即客户端）在调用该方法时会被阻塞，直到该方法完成执行并返回。
• 对于in、out和inout，它们的默认值取决于参数的类型。对于基本类型（如int、long、boolean等）以及String和CharSequence，如果没有指定关键字，那么默认行为是in，也就是说，数据只能从客户端传递到服务端。对于其他类型的参数，例如对象或者数组，如果没有指定关键字，那么默认行为是inout，也就是数据可以在客户端和服务端之间双向传递。

虽然这些关键字有默认的行为，但在实际使用中，为了代码的清晰和易读，建议显式指定这些关键字，这样可以避免可能的误解和错误。

AIDL关键字的使用场景的疑问和解答

1.什么情况下需要使用oneway关键字？

是否需要使用oneway关键字主要取决于方法的执行时间和是否需要返回结果。如果方法可能需要很长时间才能完成，并且不希望调用这个方法的线程被阻塞，那么可能需要使用oneway关键字。同样，如果方法没有返回结果，那么它也是一个oneway方法的候选者。但请注意，oneway方法必须是void类型，它们不能返回结果。

2.如果方法不是oneway，那么调用线程会阻塞多久？

如果方法不是oneway，那么调用线程会阻塞直到方法完成。这个"阻塞多久"完全取决于方法的实现。如果方法执行很快，那么线程只会被阻塞很短的时间。如果方法执行时间长，那么线程会被阻塞更长的时间。

3.如果方法是oneway，那么调用线程会怎样？

对于oneway方法，由于它们是异步的，所以在方法还没有完成执行的时候，调用线程已经继续执行了。这意味着，如果oneway方法正在处理一些数据，而这个数据还没有处理完，那么调用线程并不会知道这个情况。如果需要知道数据处理的进度，那么可能需要使用其他的机制（例如，使用回调或者监听器）来通知调用线程数据处理的状态。

创建和使用AIDL文件

在Android项目中，创建AIDL文件的过程如下：

• 在项目的源代码目录下创建一个新的目录，通常命名为aidl。
• 在这个aidl目录下，可以创建一个或多个AIDL文件。这些文件的扩展名必须是.aidl。
• 在AIDL文件中，可以定义一个接口，然后在这个接口中声明一些方法。

例如，假设要定义一个名为IMusicService的接口，这个接口有一个方法play()，可以用来播放音乐。那么的AIDL文件可能是这样的：

// IMusicService.aidl
package com.example.music;
interface IMusicService {
    void play();
}

定义了AIDL接口之后，需要在服务端实现这个接口，然后在客户端绑定到这个服务并调用接口的方法。

在服务端，需要创建一个类，这个类需要继承自Stub类，并实现AIDL接口中定义的所有方法。Stub类是AIDL编译器自动生成的，它是定义的AIDL接口的内部抽象类，用于处理进程间的通信细节。例如，可以创建一个名为MusicServiceImpl的类，这个类实现了IMusicService接口：

// MusicServiceImpl.java
public class MusicServiceImpl extends IMusicService.Stub {
    @Override
    public void play() {
        // 实现播放音乐的逻辑...
    }
}

然后需要在一个服务（例如，一个继承自Service的类）中返回这个实现类的实例。这样，其他的应用就可以绑定到这个服务并调用方法了。

在客户端，需要绑定到这个服务，然后获取到IMusicService接口的引用。一旦有了这个引用，就可以调用play()方法了。

为什么要extends IInterface?

可能会注意到，在创建的AIDL接口中，这个接口实际上是继承自IInterface接口。IInterface是Android系统为IPC（进程间通信）定义的一个接口，它定义了一些基本的IPC交互方式，例如获取Binder、判断接口是否相同等。

下面是IInterface接口的定义：

public interface IInterface {
    public IBinder asBinder();
}

当定义一个AIDL接口，例如：

interface IMyInterface {
    void myMethod();
}

实际上，Android会自动生成一个Java接口，这个接口继承自IInterface，并且添加了定义的方法。例如：

public interface IMyInterface extends android.os.IInterface {
    public void myMethod();
}

所以，AIDL接口实际上是一个IInterface接口。这样做的目的是为了在进程间通信时，可以使用IInterface提供的基本功能。例如，可以通过调用asBinder方法获取到一个Binder对象，这个对象可以用来进行跨进程通信。

Binder机制和其在AIDL中的应用

要理解为什么需要extends IInterface以及它的工作原理，需要先了解一下Binder机制和其在AIDL中的应用。

Binder是Android系统中实现IPC（进程间通信）的一种机制，它可以让不同进程之间进行数据交换和方法调用。Binder机制涉及到以下几个概念：

• Binder对象： Binder对象是一个实现了IBinder接口的对象，它代表了一个可以被其他进程调用的服务。Binder对象可以处理来自其他进程的请求，并返回结果。
• Binder驱动： Binder驱动是一个内核模块，它负责管理不同进程之间的通信。当一个进程想要调用另一个进程的服务时，它需要通过Binder驱动来发送请求，并等待响应。
• Proxy对象： Proxy对象是一个实现了IBinder接口的对象，它代表了一个远程的服务。Proxy对象可以将请求转发给Binder驱动，并从Binder驱动接收响应。
• Stub对象： Stub对象是一个抽象类，它继承自Binder对象，并实现了某个AIDL接口。Stub对象可以将来自其他进程的请求转换为对应的方法调用，并返回结果。

在AIDL中，当定义了一个接口后，Android会为生成一个Stub类和一个Proxy类。这两个类都实现了定义的AIDL接口，并且都继承自IBinder接口。这样，就可以在不同进程之间使用这两个类来进行通信。

例如，假设有一个AIDL接口IMyInterface：

interface IMyInterface {
    void myMethod();
}

Android会为生成以下两个类：

public interface IMyInterface extends android.os.IInterface {
    public void myMethod();
    public static abstract class Stub extends android.os.Binder implements IMyInterface {
        // 这里是Stub类的实现
    }
    private static class Proxy implements IMyInterface {
        // 这里是Proxy类的实现
    }
}

在服务端，需要创建一个Stub类的子类，并实现定义的方法：

public class MyServiceImpl extends IMyInterface.Stub {
    @Override
    public void myMethod() {
        // 在这里实现方法
    }
}

然后需要在一个服务（例如，一个继承自Service的类）中返回这个Stub对象：

public class MyService extends Service {
    private final IMyInterface.Stub mBinder = new MyServiceImpl();
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
}

在客户端，需要绑定到这个服务，然后获取到一个Proxy对象：

public class MainActivity extends Activity {
    private IMyInterface mService;
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = IMyInterface.Stub.asInterface(service);
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
            mService = null;
        }
    };
    @Override
    protected void onStart() {
        super.onStart();
        Intent intent = new Intent(this, MyService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }
    @Override
    protected void onStop() {
        super.onStop();
        unbindService(mConnection);
    }
}

IMyInterface.Stub.asInterface方法是一个静态方法，它可以将一个IBinder对象转换为一个IMyInterface对象。这个IMyInterface对象实际上是一个Proxy对象，它可以将请求转发给Binder驱动，并从Binder驱动接收响应。

这样，就可以在客户端调用服务端的方法了：

mService.myMethod();

这个调用的过程大致如下：

• 客户端的Proxy对象将请求（包括方法名和参数）序列化为一个Parcel对象，然后通过Binder驱动发送给服务端。
• 服务端的Binder驱动接收到请求后，将其分发给对应的Binder对象。
• 服务端的Binder对象将请求（包括方法名和参数）反序列化为一个Parcel对象，然后根据方法名找到对应的方法，并调用该方法。
• 服务端的方法执行完毕后，将结果（如果有的话）序列化为一个Parcel对象，然后通过Binder驱动发送回客户端。
• 客户端的Binder驱动接收到结果后，将其分发给对应的Proxy对象。
• 客户端的Proxy对象将结果（如果有的话）反序列化为一个Parcel对象，然后返回给调用者。

以上就是Binder机制和其在AIDL中的应用。通过这个机制，可以在不同进程之间进行数据交换和方法调用。

使用AIDL时可能遇到的问题，以及如何处理这些问题

1.如何传递自定义的对象？

如果想要在不同进程之间传递自定义的对象，例如一个类或一个结构体，需要让这个对象实现Parcelable接口。Parcelable接口是Android系统提供的一种序列化机制，它可以让对象在进程间通信时被打包和解包。需要实现Parcelable接口中的两个方法：writeToParcel和describeContents。例如，假设有一个名为Person的类，它有两个属性：name和age。可以让这个类实现Parcelable接口，如下：

public class Person implements Parcelable {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 这个方法用于将对象的属性写入到Parcel对象中
    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
    }
    // 这个方法用于返回对象的内容描述，通常返回0即可
    @Override
    public int describeContents() {
        return 0;
    }
    // 这个静态变量用于创建Person对象的实例
    public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
        // 这个方法用于从Parcel对象中读取属性并创建Person对象
        @Override
        public Person createFromParcel(Parcel source) {
            return new Person(source.readString(), source.readInt());
        }
        // 这个方法用于创建Person对象的数组
        @Override
        public Person[] newArray(int size) {
            return new Person[size];
        }
    };
}

然后可以在AIDL文件中声明这个类，并使用关键字in, out, 或者 inout来指定参数的方向。例如：

// IMyInterface.aidl
package com.example.myapp;
import com.example.myapp.Person;
interface IMyInterface {
    void setPerson(in Person person);
    Person getPerson();
}

这样，就可以在不同进程之间传递自定义的对象了。

2.如何处理多线程并发？

如果服务可能会被多个客户端同时调用，需要考虑多线程并发的问题。因为Binder机制是基于线程池的，所以服务端可能会有多个线程同时执行定义的方法。如果方法涉及到共享资源或者状态，需要使用同步机制来保证线程安全。例如，可以使用synchronized关键字或者锁对象来同步代码块或者方法。例如：

public class MyServiceImpl extends IMyInterface.Stub {
    private int count;
    @Override
    public synchronized void increaseCount() {
        count++;
    }
    @Override
    public synchronized int getCount() {
        return count;
    }
}

或者：

public class MyServiceImpl extends IMyInterface.Stub {
    private int count;
    private Object lock = new Object();
    @Override
    public void increaseCount() {
        synchronized (lock) {
            count++;
        }
    }
    @Override
    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

3.如何处理跨进程异常？

如果服务端在执行方法时发生了异常，例如空指针异常或者数组越界异常等，这些异常是不能直接传递给客户端的。因为这些异常是Java层面的异常，而Binder机制是在底层实现的，它不能识别这些异常。所以，如果服务端发生了异常，需要自己处理这些异常，或者将这些异常转换为可以被Binder机制识别的异常。Binder机制可以识别的异常有两种：RemoteException和DeadObjectException。RemoteException是一个通用的异常，它表示远程调用发生了错误。DeadObjectException是一个特殊的异常，它表示远程对象已经死亡，无法再进行通信。可以在服务端捕获异常，并抛出这两种异常之一。例如：

public class MyServiceImpl extends IMyInterface.Stub {
    @Override
    public void myMethod() throws RemoteException {
        try {
            // 在这里实现方法
        } catch (Exception e) {
            // 在这里处理或者转换异常
            throw new RemoteException(e.getMessage());
        }
    }
}

然后可以在客户端捕获这些异常，并做相应的处理。例如：

try {
    mService.myMethod();
} catch (RemoteException e) {
    // 在这里处理远程调用发生的错误
} catch (DeadObjectException e) {
    // 在这里处理远程对象已经死亡的情况
}

以上就是一些使用AIDL时可能遇到的问题，以及如何处理这些问题。

总结

本文介绍了Android中的AIDL（Android Interface Definition Language），它是一种类似于其他IDL（接口定义语言）的语言，它可以让定义一个接口，这个接口中声明的方法可以在不同的进程中调用。