Android进程间通信（二）：使用AIDL实现进程间通信

最新推荐文章于 2018-03-07 13:58:14 发布

快乐的kuai小马

最新推荐文章于 2018-03-07 13:58:14 发布

阅读量647

点赞数 1

分类专栏： Android 进阶文章标签： aidl 进程间通信 binder机制 IPC

本文链接：https://blog.csdn.net/happy_horse/article/details/51736744

版权

Android 进阶专栏收录该内容

21 篇文章 0 订阅

订阅专栏

AIDL简单描述

AIDL全称是：Android Interface Define Language

因此传递对象, 只能把对象拆分成操作系统能理解的简单形式, 以达到跨界对象访问的目的. 在J2EE中,采用RMI的方式, 可以通过序列化传递对象. 在Android中, 则采用AIDL的方式. 理论上AIDL可以传递Bundle,实际上做起来却比较麻烦。

AIDL(AndRoid接口描述语言)是一种借口描述语言; 编译器可以通过aidl文件生成一段代码，通过预先定义的接口达到两个进程内部通信进程的目的。

如果需要在一个Activity中, 访问另一个Service中的某个对象, 需要先将对象转化成AIDL可识别的参数(可能是多个参数), 然后使用AIDL来传递这些参数, 在消息的接收端, 使用这些参数组装成自己需要的对象.AIDL的IPC的机制和COM或CORBA类似, 是基于接口的，但它是轻量级的。它使用代理类在客户端和实现层间传递值. 如果要使用AIDL, 需要完成2件事情:

    1.  引入AIDL的相关类.; 
    2.  调用aidl产生的class.

AIDL实现进程间通信实战：

项目结构是：

这里写图片描述

在包名上点击右键新建.AIDL文件IMyAidlInterface.aidl，

package com.troy.aidldemo;

// Declare any non-default types here with import statements

interface IMyAidlInterface {//定义接口，两个方法；

      int add(int arg1,int arg2);

      int min(int arg1,int arg2);
}

然后Make Project，会自动生成对应的IMyAidlInterface.java文件，这个后续再分析。

服务端CalcService.java核心代码如下：

public class CalcService extends Service{

    private static final String TAG = "server";
    public void onCreate(){
        Log.e(TAG, "onCreate");
    }

    public IBinder onBind(Intent t){
        Log.e(TAG, "onBind");
        return mBinder;
    }

    public boolean onUnbind(Intent intent){
        Log.e(TAG, "onUnbind");
        return super.onUnbind(intent);
    }

   public void onDestroy(){
        Log.e(TAG, "onDestroy");
        super.onDestroy();
    }

    private final IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub(){//IMyAidlInterface.Stub类是Binder的子类
        @Override
        public int add(int x, int y) throws RemoteException{//实现接口中的加法
            return x + y;
        }
        @Override
        public int min(int x, int y) throws RemoteException{//实现接口中的减法
            return x - y;
        }

    };
}

并且需要在清单文件中对CalcService进行注册服务。

<service android:name=".CalcService"
            android:process=".remote">
        </service>

客户端代码MainActivity.java代码如下：

public class MainActivity extends AppCompatActivity {

    /**
     * 使用Binder实现通信（参见上一篇文章）
     */
    private IBinder mPlusBinder;
    /**
     * 使用AIDL实现通信
     */
    private IMyAidlInterface mCalcAidl;
    private EditText et1,et2;
    private int arg1,arg2;
    private ServiceConnection mServiceConnPlus = new ServiceConnection(){
        @Override
        public void onServiceConnected(ComponentName name, IBinder service){
            Log.i("server", " onServiceConnected()");
            //mPlusBinder = service;
            mCalcAidl = IMyAidlInterface.Stub.asInterface(service);//
        }

        @Override
        public void onServiceDisconnected(ComponentName name){
            Log.i("server", "onServiceDisconnected()");
            //mPlusBinder=null;
            mCalcAidl=null;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        et1=(EditText)findViewById(R.id.et1);
        et2=(EditText)findViewById(R.id.et2);
    }

    /**绑定服务*/
    public void bindService(View view){
        Intent intent = new Intent(this, CalcService.class);
        boolean plus=bindService(intent, mServiceConnPlus, Context.BIND_AUTO_CREATE);
        Toast.makeText(view.getContext(), "绑定服务"+plus, Toast.LENGTH_SHORT).show();
    }

    /**取消链接*/
    public void unbindService(View view){
        try {
            unbindService(mServiceConnPlus);
            //mPlusBinder=null;
            Toast.makeText(view.getContext(), "解绑成功", Toast.LENGTH_SHORT).show();
        } catch (Exception e) {
            e.printStackTrace();
            Toast.makeText(view.getContext(), "未绑定", Toast.LENGTH_SHORT).show();
        }
    }

    /**加法运算*/
    public void add(View view) throws Exception{
        if(!inspectData()){
            return;
        }
        if (mCalcAidl != null){
            int result = mCalcAidl.add(arg1, arg2);
            Toast.makeText(this, result + "", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(this, "服务器被异常杀死，请重新绑定服务端", Toast.LENGTH_SHORT).show();
        }

    }

    /**减法运算*/
    public void subtraction(View view) throws Exception{
        if(!inspectData()){
            return;
        }
        if (mCalcAidl != null){
            int result = mCalcAidl.min(arg1, arg2);
            Toast.makeText(this, result + "", Toast.LENGTH_SHORT).show();
        } else{
            Toast.makeText(this, "服务端未绑定或被异常杀死，请重新绑定服务端", Toast.LENGTH_SHORT).show();
        }

    }

    /**检查数据*/
    private boolean inspectData(){
        //省略代码...
}

最后运行的结果如图：

这里写图片描述

原理简单分析

在服务端，我们调用AIDL接口的代码是：

private final IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub(){
        @Override
        public int add(int x, int y) throws RemoteException{
            return x + y;
        }
        @Override
        public int min(int x, int y) throws RemoteException{
            return x - y;
        }

    };

再来系统看看我们写完AIDL文件之后，系统生成的java类是什么？我们找到generated文件夹下—>source—>aidl目录，如图所示：

这里写图片描述

找到IMyAidlInterface.java。先看看Stub静态类，Stub类IMyAidlInterface接口的静态抽象类，继承了Binder类，因此它是Binder的一个子类，同时实现了IMyAidlInterface接口。我们看看Stub类的定义：

public static abstract class Stub extends android.os.Binder implements com.troy.aidldemo.IMyAidlInterface

而IMyAidlInterface接口又是系统IInterface接口的子类：

public interface IMyAidlInterface extends android.os.IInterface

在客户端，我们实现了IMyAidlInterface接口的实例：

 private IMyAidlInterface mCalcAidl;
@Override
        public void onServiceConnected(ComponentName name, IBinder service){
            Log.i("server", " onServiceConnected()");
            //mPlusBinder = service;
            mCalcAidl = IMyAidlInterface.Stub.asInterface(service);
        }

其中调用了Stub抽象类的asInterface方法：

/**
     * Cast an IBinder object into an com.troy.aidldemo.IMyAidlInterface interface,
     * generating a proxy if needed.
     */
    public static com.troy.aidldemo.IMyAidlInterface asInterface(android.os.IBinder obj){//该方法的作用是：将一个IBinder 对象转换成我们自定义的IMyAidlInterface 接口对象；
        if ((obj==null)) {
            return null;
        }
        android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);

        if (((iin!=null)&&(iin instanceof com.troy.aidldemo.IMyAidlInterface))) {
            return ((com.troy.aidldemo.IMyAidlInterface)iin);
        }
        return new com.troy.aidldemo.IMyAidlInterface.Stub.Proxy(obj);
    }

同时在生成的java类中还会自动生成一个Proxy的静态代理类：

private static class Proxy implements com.troy.aidldemo.IMyAidlInterface{
        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;
        }

        //中间的加法运算--会调用Stub的真正加法
        @Override 
        public int add(int arg1, int arg2) throws android.os.RemoteException{
            //省略代码...
        }

        //中间的减法运算--会调用Stub的真正减法
        @Override 
        public int min(int arg1, int arg2) throws android.os.RemoteException    {
            //省略代码...
        }

        static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_min = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    }

我们来看看加法的运算流程到底是如何：

1 第一步

在客户端的EditText获取用户输入的参数，作非空判断：

 /**检查数据*/
    private EditText et1,et2;
    private int arg1,arg2;

    private boolean inspectData(){
      if(TextUtils.isEmpty(et1.getText().toString())||TextUtils.isEmpty(et2.getText().toString())){
            Toast.makeText(this, "请填全两个参数！", Toast.LENGTH_SHORT).show();
            return false;
        }
        arg1=Integer.parseInt(et1.getText().toString());
        arg2=Integer.parseInt(et2.getText().toString());
        return true;
    }

2 第二步

在客户端调用IMyAidlInterface的add方法：

  int result = mCalcAidl.add(arg1, arg2);

3 第三步

会执行代理类Proxy的add方法：

private static class Proxy implements com.troy.aidldemo.IMyAidlInterface{

        @Override 
        public int add(int arg1, int arg2) throws android.os.RemoteException{
            android.os.Parcel _data = android.os.Parcel.obtain();
            android.os.Parcel _reply = android.os.Parcel.obtain();
            int _result;
            try {
                _data.writeInterfaceToken(DESCRIPTOR);
                _data.writeInt(arg1);
                _data.writeInt(arg2);
                //mRemote就是一个IBinder对象
                mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
                _reply.readException();
                _result = _reply.readInt();
            }
            finally {
                _reply.recycle();
                _data.recycle();
            }
            return _result;
        }

4 第四步

会调用Stub的add方法，代码如下：

@Override 
    public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws 
    android.os.RemoteException{
        switch (code){
            case INTERFACE_TRANSACTION:
            {
                reply.writeString(DESCRIPTOR);
                return true;
            }
            case TRANSACTION_add:
            {
                data.enforceInterface(DESCRIPTOR);
                int _arg0;
                _arg0 = data.readInt();
                int _arg1;
                _arg1 = data.readInt();
                int _result = this.add(_arg0, _arg1);
                reply.writeNoException();
                reply.writeInt(_result);
                return true;
            }
    }

5 第五步

在服务端会回调mBinder 的add方法，这是真正实现加法运算的地方，：

 private final IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub(){
        @Override
        public int add(int x, int y) throws RemoteException{
            return x + y;
        }
  };

同理，减法运算的调用流程也是一样：

客户端参数-->Proxy代理类--->Stub类--->CalcService中的mBinder

AIDL中实现进程间通信的流程图分析为：

这里写图片描述

以上，就完成了使用AIDL来实现进程间的通信。

总结：

通过本DEMO需要掌握以下几点：
（1）如何写IMyAidlInterface.aidl文件，并能分析系统生成的IMyAidlInterface.java代码，理解其中的onTransact（）方法;
（2）在服务端要实现IMyAidlInterface.Stub实例及接口方法，并理解Stub类与Binder类的关系。
（3）客户端与服务端的连接，bindService(intent, mServiceConnPlus, Context.BIND_AUTO_CREATE);
（4）在客户端实现IMyAidlInterface接口对象，并理解IMyAidlInterface.Stub.asInterface(service)；

学习资料致谢：
1 Android aidl Binder框架浅析
http://blog.csdn.net/lmj623565791/article/details/38461079/
2 Binder牌胶水
http://www.jianshu.com/p/3d053abba04b
3 Binder学习指南
http://www.jianshu.com/p/af2993526daf
4 Android Bander设计与实现 - 设计篇
http://blog.csdn.net/universus/article/details/6211589
5 Android进程间通信（IPC）机制Binder简要介绍和学习计划
http://blog.csdn.net/luoshengyang/article/details/6618363
6 【Android】由浅到深理解AIDL
http://blog.csdn.net/realizelizijun2013/article/details/50989878
7 android跨进程通信（IPC）：使用AIDL
http://blog.csdn.net/singwhatiwanna/article/details/17041691?reload

快乐的kuai小马

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Android进程间通信（二）：使用AIDL实现进程间通信

AIDL简单描述AIDL全称是：Android Interface Define Language因此传递对象, 只能把对象拆分成操作系统能理解的简单形式, 以达到跨界对象访问的目的. 在J2EE中,采用RMI的方式, 可以通过序列化传递对象. 在Android中, 则采用AIDL的方式. 理论上AIDL可以传递Bundle,实际上做起来却比较麻烦。AIDL(AndRoid接口描述语言)是一种借口描
复制链接

扫一扫