android-aidl3-优快云博客

注意理解这句话：

Android SDK 工具会自动生成基于该 .aidl 文件的 IBinder 接口，具体的业务对象实现这个接口，这个具体的业务对象也是 IBinder 对象，当绑定服务的时候会根据实际情况返回具体的通信对象（本地还是代理）

也就是说任何一个类实现这个aidl的接口文件，其本身也就是Ibinder对象了，就直接可以在service中的Onbinder中返回绑定了。如实际操作：

CaSdkBinder .java

public class CaSdkBinder extends ICaSdkService.Stub {

实现接口方法，给外部调用使用。

}

CaSdkService.java
public class CaSdkService extends Service

一个服务直接在Ibinder Onbinder{

retrurn new CaSdkBinder()

因爲stub本身就继承了binder,并实现了其中的一些方法，包括asinterface这种。所以客户端在调用ICaSdkService.asinterface(binder)就能够拿到服务器的binder对象。就可以直接使用服务器的方法了。

本篇文章意在快速实现AIDL项目，更多详细内容下篇继续阐述。

在服务端创建AIDL文件，用来声明java Bean以及传输调用的接口。【声明文件】
在服务端创建Service并且实现上面的接口。【创建服务】
客户端绑定Service。【绑定服务】
客户端调用服务端接口。【跨进程调用】

服务端

创建服务端项目。首先我们在app/src/main 目录下创建AIDL文件夹。

创建载体MessageBean

首先我们在这个AIDL文件夹里创建用来传输的java Bean对象（包名并不重要），并且实现Parcelable接口（建议使用Parcelable插件），因为进程间通讯需要将该对象转化为字节序列，用于传输或者存储。（传递的载体）

public class MessageBean implements Parcelable { 
    private String content;//需求内容 
    private int level;//重要等级
 
    ......
    get set方法 
    ......
    
    @Override 
    public int describeContents() { 
        return 0; 
    } 

    @Override 
    public void writeToParcel(Parcel dest, int flags) { 
        dest.writeString(this.content); 
        dest.writeInt(this.level); 
    } 

    //如果需要支持定向tag为out,inout，就要重写该方法 
    public void readFromParcel(Parcel dest) { 
        //注意，此处的读值顺序应当是和writeToParcel()方法中一致的 
        this.content = dest.readString(); 
        this.level = dest.readInt(); 
    } 

    protected MessageBean(Parcel in) { 
        this.content = in.readString(); 
        this.level = in.readInt(); 
    } 

    public static final Creator<MessageBean> CREATOR = new Creator<MessageBean>() { 
        @Override 
        public MessageBean createFromParcel(Parcel source) { 
            return new MessageBean(source); 
        } 

        @Override 
        public MessageBean[] newArray(int size) { 
            return new MessageBean[size]; 
        } 
    }; 
}

创建AIDL文件MessageBean.AIDL

因为AIDL这个语言的规范就是aidl文件，所以我们必须将MessageBean转为aidl文件，供其它aidl的调用与交互。就这么简单，一个文件里面两行代码。(这个文件要与java Bean放置同一包下)

package qdx.aidlserver;//手动导包
parcelable MessageBean;//parcelable是小写

AIDL文件与java文件的区别，参考：

http://blog.youkuaiyun.com/luoyanglizi/article/details/51980630

文件类型：用AIDL书写的文件的后缀是 .aidl，而不是 .java。

数据类型：AIDL默认支持一些数据类型，在使用这些数据类型的时候是不需要导包的，但是除了这些类型之外的数据类型，在使用之前必须导包，就算目标文件与当前正在编写的 .aidl 文件在同一个包下——在 Java 中，这种情况是不需要导包的。比如，现在我们编写了两个文件，一个叫做 IDemandManager.java ，另一个叫做 IDemandManager.aidl，它们都在 qdx.aidlserver 包下，现在我们需要在 .aidl 文件里使用 MessageBean 对象，那么我们就必须在 .aidl 文件里面写上 import qdx.aidlserver.MessageBean; 哪怕 .java 文件和 .aidl 文件就在一个包下。

默认支持的数据类型

Java中的八种基本数据类型( byte，short(不支持short，编译不通过)，int，long，float，double，boolean，char)
String 和 CharSequence类型
List ： List中的所有元素必须是AIDL支持的类型之一，里面的每个元素都必须能够被AIDL支持
Map ： Map中的所有元素必须是AIDL支持的类型之一，包括key和value
Parcelabel : 所有实现了Parcelabel 接口的对象
AILD : 所有的AIDL接口本身也可以在AIDL文件中使用

创建AIDL文件IDemandManager.AIDL

我们创建IDemandManager接口用来实现传递方法。另外方法内如果有传输载体，就必须指明定向tag(in,out,inout)，参考：

http://blog.youkuaiyun.com/luoyanglizi/article/details/51958091

in : 客户端数据对象流向服务端，并且服务端对该数据对象的修改不会影响到客户端。

out : 数据对象由服务端流向客户端，（客户端传递的数据对象此时服务端收到的对象内容为空，服务端可以对该数据对象修改，并传给客户端）

inout : 以上两种数据流向的结合体。（但是不建议用此tag,会增加开销）

package qdx.aidlserver; 

import qdx.aidlserver.MessageBean; 
import qdx.aidlserver.IDemandListener; 

interface IDemandManager { 
     MessageBean getDemand(); 

     void setDemandIn(in MessageBean msg);//客户端->服务端 

     //out和inout都需要重写MessageBean的readFromParcel方法 
     void setDemandOut(out MessageBean msg);//服务端->客户端 

     void setDemandInOut(inout MessageBean msg);//客户端<->服务端
}

埋坑与完善

该篇文章内容不多，但是处处皆是精华，尤其是以下3条建议，以防引起惨案。

1. xxx.aidl 中不能存在同方法名不同参数的方法。

2. xxx.aidl 中实体类必须要有指定的tag。

3. 在Android Studio里写完aidl文件还需要在build.gradle文件中android{}方法内添加aidl路径。

sourceSets { 
    main { 
        java.srcDirs = ['src/main/java', 'src/main/aidl'] 
    } 
}

创建Service

最后我们还需要创建一个服务，用来处理客户端发来的请求，或者是定时推信息到客户端。

public class AIDLService extends Service { 

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

    //Stub内部继承Binder，具有跨进程传输能力 
    IDemandManager.Stub demandManager = new IDemandManager.Stub() {

        @Override 
        public MessageBean getDemand() throws RemoteException { 
            MessageBean demand = new MessageBean("首先，看到我要敬礼", 1); 
            return demand; 
        } 

        //客户端数据流向服务端 
        @Override 
        public void setDemandIn(MessageBean msg) throws RemoteException { 
            Log.i(TAG, "程序员:" + msg.toString()); 
        } 

        //服务端数据流向客户端 
        @Override 
        public void setDemandOut(MessageBean msg) throws RemoteException { 
            Log.i(TAG, "程序员:" + msg.toString());//msg内容一定为空 

            msg.setContent("我不想听解释，下班前把所有工作都搞好！"); 
            msg.setLevel(5); 
        } 

        //数据互通 
        @Override 
        public void setDemandInOut(MessageBean msg) throws RemoteException { 
            Log.i(TAG, "程序员:" + msg.toString()); 

            msg.setContent("把用户交互颜色都改成粉色"); 
            msg.setLevel(3); 
        } 
    }; 
}

最后我们在清单文件中注册服务

action 为服务名称，客户端可以通过此(com.tengxun.aidl)隐式启动该服务。

在魅族的手机上，系统禁止了隐式方法启动服务的权限，所以务必在手机管家/权限管理/ 中，开启该项目的自启权限。

<service 
    android:name=".AIDLService" 
    android:exported="true"> 
    <intent-filter> 
        <action android:name="com.tengxun.aidl" /> 
        <category android:name="android.intent.category.DEFAULT" /> 
    </intent-filter>
</service>

客户端

创建客户端项目

拷贝AIDL文件夹

将服务端创建的aidl文件夹拷贝至客户端app/src/main 目录下，并且在gradle.build中关联aidl路径。

sourceSets { 
    main { 
        java.srcDirs = ['src/main/java', 'src/main/aidl'] 
    } 
}

开启服务

Intent intent = new Intent(); 
intent.setAction("com.tengxun.aidl");//service的action
intent.setPackage("qdx.aidlserver");//aidl文件夹里面aidl文件的包名
bindService(intent, connection, Context.BIND_AUTO_CREATE);

关联对象，调用方法

服务绑定成功之后，我们将服务端的IDemandManager.Stub对象，通过asInterface转化成为我们客户端需要的AIDL接口类型对象，并且这种转化过程是区分进程的（下篇详细叙述）。

private IDemandManager demandManager; 

private ServiceConnection connection = new ServiceConnection() { 
    @Override 
    public void onServiceConnected(ComponentName name, IBinder service) { 
        //得到该对象之后，我们就可以用来进行进程间的方法调用和传输啦。 
        demandManager = IDemandManager.Stub.asInterface(service); 
    } 

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

至此我们就可以通过AIDL来进行跨进程通讯了。

附加技能(定时推送消息)

上面的步骤已经可以实现正常的跨进程通讯了，这时候如果我们想服务端项目想要定时推送消息到客户端项目，那么跨进程中如何完成呢?

使用观察者模式(多个回调方法的集合)

服务端项目(推送消息)

与通常的回调方法差不多，首先我们在AIDL文件夹里创建回调接口IDemandListener.aidl

但是这里的定向tag要稍加注意，可能有些童鞋觉得我们在服务端里给客户端发消息，照理不应该是设置out标记吗？

其实所谓的“服务端”和”客户端”在Binder通讯中是相对的，因为我们在客户端项目中拷贝了aidl文件，所以我们客户端项目其实不仅可以发送消息，充当”Client”，同时我们也可以收到服务端项目推送的消息，从而升级为”Server”，这个功能依赖于AIDL的Stub和Proxy……(更多见下篇)

所以服务端 onDemandReceiver 推送消息的过程实际上相当于”Client”

package qdx.aidlserver; 

import qdx.aidlserver.MessageBean; 

interface IDemandListener { 

    void onDemandReceiver(in MessageBean msg);//客户端->服务端
}

同时我们在IDemandManager.aidl文件中，加上绑定/解绑监听方法

void registerListener(IDemandListener listener);
void unregisterListener(IDemandListener listener);

最后Clean Project，在 IDemandManager.Stub 中多处绑定/解绑两个方法。

IDemandManager.Stub demandManager = new IDemandManager.Stub() { 
    ...... 
    setDemandIn/out等方法 
    ...... 

    @Override 
    public void registerListener(IDemandListener listener) throws RemoteException { 
    } 

    @Override 
    public void unregisterListener(IDemandListener listener) throws RemoteException { 
    } 
};

那么，关键的步骤来了，我们通常使用List<IDemandListener>来存放监听接口集合，但是：

由于跨进程传输客户端的同一对象会在服务端生成不同的对象！

上面这句话说明跨进程通讯的过程中，这个传递的对象载体并不是像寄快递一样，从客户端传给服务端。而是经过中间人狸猫换太子的一些手段传递的。

不过传递过程中间人(binder)对象都是同一个，所以 Android 通过这个特性提供 RemoteCallbackList，让我们用来存储监听接口集合。

这个 RemoteCallbackList 内部自动实现了线程同步的功能，而且它的本质是一个 ArrayMap，所以我们用它来绑定/解绑时，不需要做额外的线程同步操作。

private RemoteCallbackList<IDemandListener> demandList = new RemoteCallbackList<>();

@Override
public void registerListener(IDemandListener listener) throws RemoteException { 
    demandList.register(listener); 
} 

@Override
public void unregisterListener(IDemandListener listener) throws RemoteException { 
    demandList.unregister(listener); 
}

最后，我们通过 Handler 来进行定时发送消息。(handler 并不能精准的做定时任务，因为 handler 在发送和接收的过程中会有时间损耗)

另外我们需要通过 beginBroadcast() 来获取 RemoteCallbackList中元素的个数，同时 beginBroadcast() 和 finishBroadcast() 必须要配对使用，哪怕仅仅只是获取一下这个集合的元素个数。

private Handler mHandler = new Handler() { 
    @Override 
    public void handleMessage(Message msg) { 
        super.handleMessage(msg); 

        if (demandList != null) { 
            int nums = demandList.beginBroadcast(); 
            for (int i = 0; i < nums; i++) { 
                MessageBean messageBean = new MessageBean("我丢", count); 
                count++; 
                try { 
                    demandList.getBroadcastItem(i).onDemandReceiver(messageBean); 
                } catch (RemoteException e) { 
                    e.printStackTrace(); 
                } 
            } 
            demandList.finishBroadcast(); 
        } 

        mHandler.sendEmptyMessageDelayed(WHAT_MSG, 3000);//每3s推一次消息 
    } 
};

客户端项目(接收定时推送)

在我们创建的客户端项目就不用过多的处理了，创建 IDemandListener.Stub（此时我们这个客户端项目相对推送过程而言是”Server”），并且将它加入至 demandManager 即可。

IDemandListener.Stub listener = new IDemandListener.Stub() { 
    @Override 
    public void onDemandReceiver(final MessageBean msg) throws RemoteException { 
        //该方法运行在Binder线程池中，是非ui线程 
    } 
}; 

demandManager.registerListener(listener);

结束语

至此一个简单通用的AIDL项目创建完成。

按照我个人习惯而言，学习和领悟一个项目知识之前，如果这个项目没有RUN成功，那么学习的过程变会略枯燥乏味，所以我们先把这个流程走一遍，然后带着种种问题去学习，应该会更加深刻去理解和看待这个知识。当然也有点急功求成的感觉…