Android 进程间通信:AIDL

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/zzw0221/article/details/92616358

1. 概述

AIDL:Android Interface Definition Language,即Android接口定义语言。在 Android 上,一个进程通常无法访问另一个进程的内存。 尽管如此,进程需要将其对象分解成操作系统能够识别的原语,并将对象编组成跨越边界的对象。 编写执行这一编组操作的代码是一项繁琐的工作,因此 Android 会使用 AIDL 来处理。(摘自Google developer网站)。

只有允许不同应用的客户端用 IPC 方式访问服务,并且想要在服务中处理多线程时,才有必要使用 AIDL。 如果您不需要执行跨越不同应用的并发 IPC,就应该通过实现一个 Binder 创建接口;或者,如果您想执行 IPC,但根本不需要处理多线程,则使用 Messenger 类来实现接口。

2. AIDL 支持的数据类型

a. Java 编程语言中的所有基本数据类型。(如 int、long、char、boolean 等等)

b. String 和 CharSequence

c. List 和Map:List /Map 中的所有元素都必须是以上列表中支持的数据类型、其他 AIDL 生成的接口或您声明的可打包类型。

d. AIDL 生成的接口。

e. 实现Parcelable接口的类

3. AIDL 实现步骤:

服务端:

1. 创建 .aidl 文件

此文件定义带有方法签名的编程接口。

2. 实现接口

Android SDK 工具会生成一个以 .aidl 文件命名的 .java 接口文件。生成的接口包括一个名为 Stub的子类,这个子类是其父接口(例如,YourInterface.Stub)的抽象实现,用于声明 .aidl 文件中的所有方法。

3. 向客户端公开接口

实现 Service 并重写onBind() 以返回 Stub 类的实现。

客户端:

1.在项目中加入 .aidl 文件

2. 实现 ServiceConnection 。

3. 调用 bindService ,以传入 ServiceConnetion。

4. 在 onServiceConnected() 实现中,将收到一个 IBinder 实例(名为 service)。调用 YourInterfaceName.Stub.asInterface((IBinder)service),以将返回的参数转换为 YourInterface 类型。

4. AIDL实例

以下为具体的代码实现:

服务端:

1. 创建要传递的实体类 Person,并实现 Parcelable 接口。

package cn.zzw.aidl;

import android.os.Parcel;
import android.os.Parcelable;

public class PersonInfo implements Parcelable{
    private String name;
    private int age;
    private String sex;
    private float height;
    public PersonInfo(String name, int age, String sex, float height) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
    }

    public PersonInfo() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public float getHeight() {
        return height;
    }

    public void setHeight(float height) {
        this.height = height;
    }

    public static Creator<PersonInfo> getCREATOR() {
        return CREATOR;
    }

    protected PersonInfo(Parcel in) {
        name = in.readString();
        age = in.readInt();
        sex = in.readString();
        height = in.readFloat();
    }

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

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

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
        dest.writeString(sex);
        dest.writeFloat(height);
    }
}

注意:此文件所在的包名要和 .aidl 文件所在的包名一样。

2. 创建 IPerson.aidl 文件

// IPerson.aidl
package cn.zzw.aidl;
import cn.zzw.aidl.PersonInfo;
// Declare any non-default types here with import statements
interface IPerson {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    String sayHello(in PersonInfo personInfo);
    int sumnNum(int num1,int num2);
}

注意: 需要import 相关的实体类,否则会报如下错误:

Process 'command 'D:\Android\sdk\build-tools\28.0.3\aidl.exe'' finished with non-zero exit value 1

3. 对于实体类 Person 也必须创建对应的 .aidl 文件

// PersonInfo.aidl
package cn.zzw.aidl;

parcelable PersonInfo;

以上三步创建后,目录如下:

4. 创建隐式意图的Service(对于此文件所在的包没有要求),并在onBind方法返回已经实现AIdl 接口的对象。

package cn.zzw.aidlserverdemo.service;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;

import cn.zzw.aidl.IPerson;
import cn.zzw.aidl.PersonInfo;

public class AidlServerService extends Service {

    private class MyBinder extends IPerson.Stub{
        @Override
        public String sayHello(PersonInfo personInfo) throws RemoteException {
            if(null!=personInfo)
            {
                String name = personInfo.getName();
                int age = personInfo.getAge();
                float height = personInfo.getHeight();
                String sex = personInfo.getSex();
                return "Hello,My Name is "+name;
            }
            return null;
        }

        @Override
        public int sumnNum(int num1, int num2) throws RemoteException {
            return num1+num2;
        }
    };
    @Override
    public IBinder onBind(Intent intent) {

        return new MyBinder();
    }
}

在 AndroidManifest.xml 中注册隐式意图的Service:

        <service android:name=".service.AidlServerService">
            <intent-filter>
                <action android:name="cn.zzw.PERSON.SERVER"></action>
            </intent-filter>
        </service>

至此Server端的实现就算完成了,接下来就是客户端如何调用了。

 

客户端:

1. 在客户端中实现服务端中的第 1,2,3 步。

注意:文件所在的包名一定要和服务端一样!!!

2. 绑定远程服务,获取服务对象。

    private void bindToClientService() {
        intent = new Intent();
        intent.setAction("cn.zzw.PERSON.SERVER");
        intent.setPackage("cn.zzw.aidlserverdemo");
        bindService(intent,conn,BIND_AUTO_CREATE);
    }


    ServiceConnection conn =new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService= IPerson.Stub.asInterface(service);
            Log.d(TAG,"Service Connect Successfully");
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.d(TAG,"Service Connect Fail");
        }
    };

3.  调用远程服务中的方法

    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.mBtn_hello:
                if(mService!=null)
                {
                    String msgInfo = null;
                    try {
                        msgInfo = mService.sayHello(mInfo);
                        Toast.makeText(this,msgInfo,Toast.LENGTH_SHORT).show();
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }else {
                    Log.d(TAG,"Service is Null");
                    bindToClientService();
                }
                break;
            case R.id.mBtn_calculate:
                if(mService!=null)
                {

                    String msgInfo = null;
                    try {
                       int sumInfo = mService.sumnNum(50,50);
                        Toast.makeText(this,""+sumInfo,Toast.LENGTH_SHORT).show();
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                }else {
                    Log.d(TAG,"Service is Null");
                    bindToClientService();
                }
                break;
        }
    }

效果:

先尝试只安装Client,会发现绑定不了Service:

log如下:

D/Client: Service is Null
D/Client: Service is Null

安装服务端后,再次运行客户端后:

附上以上实例的代码:

https://download.csdn.net/download/zzw0221/11248522

 

5. AIDL 的工作原理

当创建AIDL文件并Clean Project 代码后,会生成相应的Java文件:

 

先来一段伪代码:类整体结构

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: D:\\AndroidProject\\AIDLServerDemo\\app\\src\\main\\aidl\\cn\\zzw\\aidl\\IPerson.aidl
 */
package cn.zzw.aidl;
// Declare any non-default types here with import statements

public interface IPerson extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements cn.zzw.aidl.IPerson //1
{
      ...
 }

    public java.lang.String sayHello(cn.zzw.aidl.PersonInfo personInfo) throws android.os.RemoteException; //2

    public int sumnNum(int num1, int num2) throws android.os.RemoteException; //3
}

注释2 和注释3 就是我们在.aidl 中定义的方法。

注释1 是一个静态的抽象类,并且继承了Binder类。Binder是Android中实现IPC方式。AIDL就是利用Binder来实现的。

这里就不对于Binder进行解释,后面会对Binder的源码进行解读,再记录一篇关于Binder的原理。

 

看看Stub这个类:

    public static abstract class Stub extends android.os.Binder implements cn.zzw.aidl.IPerson {
        private static final java.lang.String DESCRIPTOR = "cn.zzw.aidl.IPerson";

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

        /**
         * Cast an IBinder object into an cn.zzw.aidl.IPerson interface,
         * generating a proxy if needed.
         */
        public static cn.zzw.aidl.IPerson asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof cn.zzw.aidl.IPerson))) {
                return ((cn.zzw.aidl.IPerson) iin);
            }
            return new cn.zzw.aidl.IPerson.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 {
            java.lang.String descriptor = DESCRIPTOR;
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(descriptor);
                    return true;
                }
                case TRANSACTION_sayHello: {
                    data.enforceInterface(descriptor);
                    cn.zzw.aidl.PersonInfo _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = cn.zzw.aidl.PersonInfo.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    java.lang.String _result = this.sayHello(_arg0);
                    reply.writeNoException();
                    reply.writeString(_result);
                    return true;
                }
                case TRANSACTION_sumnNum: {
                    data.enforceInterface(descriptor);
                    int _arg0;
                    _arg0 = data.readInt();
                    int _arg1;
                    _arg1 = data.readInt();
                    int _result = this.sumnNum(_arg0, _arg1);
                    reply.writeNoException();
                    reply.writeInt(_result);
                    return true;
                }
                default: {
                    return super.onTransact(code, data, reply, flags);
                }
            }
        }

        private static class Proxy implements cn.zzw.aidl.IPerson {
            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 java.lang.String sayHello(cn.zzw.aidl.PersonInfo personInfo) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.lang.String _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((personInfo != null)) {
                        _data.writeInt(1);
                        personInfo.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_sayHello, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readString();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public int sumnNum(int num1, int num2) 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(num1);
                    _data.writeInt(num2);
                    mRemote.transact(Stub.TRANSACTION_sumnNum, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.readInt();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
        }

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

Stub类的类结构如下:

 

下面两个int常量是用来标识我们在接口中定义的方法的:

static final int TRANSACTION_sayHello = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_sumnNum = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

DESCRIPTOR 常量是Binder的唯一标识。

private static final java.lang.String DESCRIPTOR = "cn.zzw.aidl.IPerson";

 asInterface 方法非常熟悉,上面客户端才用到的,用于将服务端的Binder对象转换为客户端所需要的接口对象。该过程区分进程,如果进程一样,就返回服务端Stub对象本身,否则就返回封装后的Stub.Proxy对象。

        public static cn.zzw.aidl.IPerson asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof cn.zzw.aidl.IPerson))) {
                return ((cn.zzw.aidl.IPerson) iin);
            }
            return new cn.zzw.aidl.IPerson.Stub.Proxy(obj);
        }

onTransact  方法是实现 Binder 类后重写的方法。这是运行在服务端的Binder线程中的,当客户端发起远程请求后,在底层的方法就会触发此方法。

5. 总结

AIDL的原理就是Binder,AIDL的最终结果就是让进程间通讯变得简单,自动的完成了参数序列化发送以及解析返回数据的一系列麻烦。

展开阅读全文

没有更多推荐了,返回首页