Android studio 下的aidl编程实现Android的夸进程间通信

前言

Android中夸进程间通信方式有很多种方式，比如：aidl，Messenger，文件共享，广播（BroadCast），ContentProvider，Socket（网络通信）。每种方式都有自己的使用场景和优缺点，接下来几篇博客我们一一学习他们是怎么使用的。这篇博客主要是介绍Android studio下实现aidl编程。

AIDL的使用步骤

aidl远程调用传递的参数和返回值支持Java的基本类型（int long booen char byte等）和String，List，Map等。当然也支持一个自定义对象的传递，不过此时就需要做一些特别处理了，后续会介绍aidl传递对象怎么处理。
有关aidl的相关概念这里就不详细解释了，我们来看看在Android Studio下怎么来实现aidl编程的。

服务端

生成aidl文件

新建一个MyAidlDemoServer工程，然后在main目录下右键新建一个aidl目录，然后在该目录下新建一个IMyAidlInterface.aidl文件，代码如下：

// IMyAidlInterface.aidl
package com.example.xjp.aidla;

interface IMyAidlInterface {

    int add(int arg1, int arg2);

}

定义了一个IMyAidlInterface接口，接口里面定义了一个add方法用于计算两个数的和。然后Build当前工程，在app/build/generated/source/aidl/debug目录下会生成一个与IMyAidlInterface.aidl文件同样包名的一个文件，该文件下面自动生成IMyAidlInterface文件，该文件里面自动实现了一些方法用于远程调用，IMyAidlInterface代码如下：

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: D:\\WorkPlace\\MyAidlDemoServer\\app\\src\\main\\aidl\\com\\example\\xjp\\aidla
 * \\IMyAidlInterface.aidl
 */
package com.example.xjp.aidla;

public interface IMyAidlInterface extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.example.xjp.aidla
            .IMyAidlInterface {
        private static final java.lang.String DESCRIPTOR = "com.example.xjp.aidla.IMyAidlInterface";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.example.xjp.aidla.IMyAidlInterface interface,
         * generating a proxy if needed.
         */
        public static com.example.xjp.aidla.IMyAidlInterface asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.example.xjp.aidla.IMyAidlInterface))) {
                return ((com.example.xjp.aidla.IMyAidlInterface) iin);
            }
            return new com.example.xjp.aidla.IMyAidlInterface.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 {
            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;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.example.xjp.aidla.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;
            }

            @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.transact(Stub.TRANSACTION_add, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readInt();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
        }

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

    public int add(int arg1, int arg2) throws android.os.RemoteException;
}

以上代码都是AS自动生成的，如此一来，开发者更加容易来实现AIDL跨进程间通信。如有对以上代码感兴趣者，可自行学习。

编写远程服务

新建MyServer类实现远程服务代码如下：

public class MyServer extends Service {

    IMyAidlInterface.Stub mStub = new IMyAidlInterface.Stub() {

        public int add(int arg1, int arg2) {
            return arg1 + arg2;
        }
    };


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

服务代码也很简单，仅仅实现了IMyAidlInterface.Stub类中的 add方法，然后重写了Service的onBind方法。

记得在AndroidManifest.xml中配置MyServer服务，代码如下：

<manifest package="com.example.xjp.aidl"
          xmlns:android="http://schemas.android.com/apk/res/android">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">

        <service
            android:name="com.example.xjp.aidl.MyServer"
            android:process=":remote">
            <intent-filter>
                <action android:name="com.xjp.myService">action>
            intent-filter>
        service>
    application>

manifest>

以上代码给当前service设置了 android:process属性为“:remote”,这个属性有两种赋值，一是:”:remote”,一是：”remote”,区别在于字符串前面带有”:”，后面的字符串不一定是remote，开发者可以随意设置。

两者代表不同意思，带有”:”的表示该服务所在的进程是私有的，即只要有客户端去启动该服务，系统就会创建一个新的进程来运行该服务。

不带有”:”的表示该服务所在的进程是共享的，即当前系统不管有几个客户端去启动该服务，系统中只有一个进程来运行该服务。

客户端

客户端代码相对简单些，新建MyAidlDemoCustomer工程，然后直接把服务端的aidl目录直接拷贝到客户端的main目录下。这么一来客户端的aidl就无需编写了，直接和服务端的一模一样。包括路径的包名等。虽然你可以自己在客户端在写一遍aidl代码，为了不出错，请直接将服务端的aidl代码直接拷贝过来。

客户端调用代码如下

package com.example.xjp.myaidldemocustomer;

import android.app.Activity;
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.os.RemoteException;
import android.util.Log;
import android.widget.ImageView;
import android.widget.TextView;

import com.example.xjp.aidla.IMyAidlInterface;


public class MainActivity extends Activity {

    IMyAidlInterface mStub;
    TextView txt;

    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.e("xjp", "the Connected====>" + System.currentTimeMillis());
            mStub = IMyAidlInterface.Stub.asInterface(service);
            if (mStub == null) {
                Log.e("xjp", "the mStub is null");
            } else {
                try {
                    int value = mStub.add(1, 8);
                    txt.setText(value + "");
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        txt = (TextView) findViewById(R.id.text);

        Intent intent = new Intent();
        //android 5.0以后直设置action不能启动相应的服务，需要设置packageName或者Component。
        intent.setAction("com.xjp.myService");
        intent.setComponent(new ComponentName("com.example.xjp.aidl", "com.example.xjp.aidl.MyServer"));
        //绑定服务
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
        Log.e("xjp", "the bindServer start..====>" + System.currentTimeMillis());
    }

    @Override
    protected void onDestroy() {
        //解绑服务
        unbindService(serviceConnection);
        super.onDestroy();
    }
}

如此一来，客户端也写好了。先安装服务端，在安装客户端。进入客户端之后实现了远程调用Service。

AIDL跨进程传递Bitamp对象

以上是最简单的 aidl跨进程传递java基本类型数据，最近在项目中遇到这么个需求，跨进程传递bitmap图片。当时看到这个需求就懵逼了，后来仔细分析其实是可以实现Android 利用Aidl实现跨进程传递 Bitmap对象。那么该怎么实现呢？

我们都知道Aidl支持跨进程传递 Java基本数据类型中包括byte这个类型，那么思路是不是来了呢？我们可以在服务端将需要传递的图片由bitmap转换成 byte[]类型。代码如下：

 public byte[] getBitmap() {
        Bitmap bitmap = BitmapFactory.decodeResource(MyServer.this.getResources(), R.drawable.bg_top);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG, 90, baos);//压缩位图
        return baos.toByteArray();//创建分配字节数组
    }

如此一来就将Bitmap对象转换成byte[]类型了，现在aidl就可以跨进程传递byte[]类型数据。

在客户端你只需要将远程调用得到的byte[]类型转换成Bitmap对象，然后显示即可。客户端代码如下：

byte[] bytes = mStub.getBitmap();
Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
img.setImageBitmap(bitmap);

是不是很简单，其实Aidl传递图片只是将Bitamp对象转换成byte[]类型，然后由byte[]类型在转换回Bitmap对象的一个过程。

• 注意：在亲测的过程中发现，利用aidl传递Bitamp对象是有一定的限制的，当Bitmap达到一定大小时是Aidl跨进程传递会失败。所以，利用Aidl跨进程可以传递较小的图片，至于多大可以根据你需求测试以免出错。这也是由于Aidl跨进程传递数据是有限的，数据过大就不适合利用aidl夸进程传递了，应该用Socket传递。因为Aidl跨进程间通信是一个实时的，同步的的一个过程，即Aidl的远程调用方法不能被阻塞，因此不能传递大数据。

总结

这是一个在AS下最简单的一个AIDL编程：
1.服务端创建一个aidl目录，然后在该目录下新建一个.aidl为后缀的接口类，该类定义远程调用的接口方法。
2.build编译之后会在app/build/generated/source/aidl/debug目录下会生成aidl远程实现类，该类是AS自动生成的。
3.在AndroidManifest.xml下配置Service的action和process属性。
4.将服务端的aidl目录拷贝到客户端相应的目录下，然后编写客户端调用代码，AS下简单的aidl编程就ok了。

5.利用Aidl实现跨进程传递较小的Bitmap对象。