Android AIDL 简单使用和部分解释

作者: NapleC | 来源:发表于2018-04-19 17:19 被阅读82次

    AIDL 是跨进程通信的一种实现方式,那么这里最少也要两个进程的角色才能够使用跨进程通信吧。那么接下将分成两个角色来说明使用步骤:

    服务端进程:

    ①:创建一个 aidl 文件夹(可选),在该文件夹下创建一个 AIDL 文件:IOperationServer.aidl

    ②:在这个 aidl 文件中声明提供给客户端调用的接口,点击保存,即会在 gen 目录下自动生成该接口的 IOperationServer.java 文件

    interface IOperationServer{
        double getSum(double first,double second);
    }
    

    ③:创建 Service,创建 AIDL 接口的子类作为内部类(class Mabinder extends AIDLbigname.Stub{重写方法}), 然后再 onBind() 方法中返回该内部类的对象。

    // 实现该接口,这里是实现该方法的地方
    private IOperationServer.Stub mBinder = new IOperationServer.Stub() {
        @Override
        public double getSum(double first, double second)
                throws RemoteException {
            return first + second;
        }
    };
    
    // 在onbind()方法中返回该实例
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
    

    ④:最后在清单文件中,注册服务:其中注意加上action:android:name="myservice"(这里可自定义,主要是为了让客户端通过action绑定服务)

    <service android:name=".IOperationServer" >  
        <intent-filter>  
            <action android:name="com.hl.myservice" />  
            <category android:name="android.intent.category.DEFAULT" />  
        </intent-filter>  
    </service>  
    

    客户端进程:

    ① 将服务端的 AIDL 文件拷贝到 main 文件夹下。(包名要求与服务端的一致,会自动在 gen 目录下生成 IOperationServer.java 文件)

    ② 绑定服务:在需要需要调用该接口提供的方法的地方(一般就在 Activity)绑定服务端的 Service。
    获取 aidl 接口实例。bindService 的第二个参数为 ServiceConnection 接口,当绑定的状态发生变化时,会回调该接口。该接口有两个函数:onServiceConnected 和 onServiceDisconnected。可以在 onServiceConnected 中获取服务端返回的 Binder 对象

    private IOperationServer iOperationServer;  
    private MyServiceConnection connection = new MyServiceConnection();  
    
    Intent intent = new Intent("com.hl.myservice");  
    private class MyServiceConnection implements ServiceConnection {  
         @Override  
          public void onServiceConnected(ComponentName name, IBinder service) {  
               iOperationServer= IOperationServer .Stub.asInterface(service);  
               Log.d("aidl", "onServiceConnected:" + iOperationServer);  
            }  
         @Override  
          public void onServiceDisconnected(ComponentName name) {  
            }  
    };  
    bindService(intent, connection , BIND_AUTO_CREATE);  
    

    ③ 可以通过这个接口 iOperationServer 去调用服务端的远程方法了

    double sum = iOperationServer.getSum(first, second);
    

    ④ 记得在 onDestroy 中进行解绑。

    unbindService(connection);  
    

    自动生成的Java文件比较长,以前没有仔细关注过,现在对其中的内容进行一些分析:

    整个文件是一个继承了 IIterface 的接口类,其中它的内容主要分为两个部分,
    一个是在aidl 文件中声明的方法,另一个是一个抽象类 stub
    关于第一部分,两个方法只需要在这里声明一下就可以了,不需要具体的实现过程,主要关注点还是在第二部分。
    这个抽象类 Stub 继承 Binder 类,并实现你写的 aidl 文件类,它其中又分为以下几个部分:

    1. 同 aidl 文件中所声明几个方法所相对应的几个静态整型常量,用于标识在 transact 过程中客户端中请求的到底是哪个方法
    2. 一个静态常量:DESCRIPTOR
    3. 一个无参的构造方法
    4. asInterface() 方法
    5. asBinder() 方法
    6. onTransact() 方法
    7. 实现你所写的 aidl 文件类的 Proxy 类

    贴出所有代码 :

    1 定义一个 IOperation 接口,并在内部声明一个供客户端跨进程调用的方法,并使该接口继承 IInterface 接口。

    public interface IOperation extends IInterface {
    
        /* Binder描述符 */
        static final String DESCRIPTOR = "com.example.aidlmanualtest.IOperation";
    
        /**
         * 方法标识符 :规定了最小和最大范围
         * The action to perform. This should be a number between
         * {@link #FIRST_CALL_TRANSACTION}
         * {@link #LAST_CALL_TRANSACTION}.
         * 
         * 这段说明是在IBiner的transact()方法中
         */
        static final int TRANSACTION_getSum = IBinder.FIRST_CALL_TRANSACTION + 0;
        // 定义了一个供跨进程调用的方法
        public double getSum(double first, double second) throws RemoteException;
    }
    

    2 跨进程方法调用的处理逻辑,主要集中在接口实现类 Stub 和 Stub 的代理 Proxy 类中

    public class IOperationStub extends Binder implements IOperation {
    
        public IOperationStub() {
            /**
             * Convenience method for associating a specific interface with the
             * Binder. After calling, queryLocalInterface() will be implemented for
             * you to return the given owner IInterface when the corresponding
             * descriptor is requested.
             * 
             * 将一个IInterface类型的接口实例与Binder关联起来,DESCRIPTOR相当于一个标识。当该方法被调用后,
             * 可通过queryLocalInterface(DESCRIPTOR)获取与这个标识相应的接口实例
             */
            this.attachInterface(this, DESCRIPTOR);
        }
    
        /**
         * 用于将服务端的Binder对象转换成客户端需要的AIDL接口类型的对象区分进程:
         * <p/>
         * 客户端和服务端处于同一进程:直接返回服务端的Stub对象
         * <p/>
         * 客户端和服务端处于不同进程:返回封装好的Stub.proxy对象
         * 
         * @param obj
         * @return
         */
        public static IOperation asInterface(IBinder obj) {
            if (obj == null) {
                return null;
            }
            /**
             * Attempt to retrieve a local implementation of an interface for this
             * Binder object. If null is returned, you will need to instantiate a
             * proxy class to marshall calls through the transact() method.
             * 
             * 尝试在本地检索实现了该接口的Binder对象实例
             */
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (iin != null && (iin instanceof IOperation)) {
                return ((IOperation) iin);
            }
            /**
             * 假如本地检索返回为null,需要手动生成一个proxy代理类,并在其中通过transact() 方法去处理请求
             */
            return new IOperationStub.Proxy(obj);
        }
    
        @Override
        public IBinder asBinder() {
            return this;
        }
    
        /**
         * 该方法运行在服务端,当客户端发起请求,会进入到该方法进行处理
         * <p/>
         * code:用于标识客户端请求调用的目标方法(即在IOperation中定义的方法标识符)
         * <p/>
         * data:当请求的目标方法含有参数时,该参数封装了请求的参数
         * <p/>
         * reply:当请求需要返回结果时,该参数封装了处理结果
         */
        @Override
        protected boolean onTransact(int code, Parcel data, Parcel reply, int flags)
                throws RemoteException {
            // 通过code区分不同的方法调用
            switch (code) {
            case INTERFACE_TRANSACTION:
                reply.writeString(DESCRIPTOR);
                return true;
            case TRANSACTION_getSum:
            /**
                 * Read an IBinder interface token in the parcel at the current
                 * {@link #dataPosition}. This is used to validate that the
                 * marshalled transaction is intended for the target interface.
                 */
                data.enforceInterface(DESCRIPTOR);
                // 通过data获取请求的参数
                double first = data.readDouble();
                double second = data.readDouble();
                double result = this.getSum(first, second);
                reply.writeNoException();
                // 将结果写入到reply中
                reply.writeDouble(result);
                return true;
            default:
                break;
            }
            return super.onTransact(code, data, reply, flags);
        }
    
        @Override
        public double getSum(double fisrt, double second) throws RemoteException {
            return 0;
        }
    
        private static class Proxy implements IOperation {
    
            private IBinder mRemote;
    
            Proxy(IBinder mRemote) {
                this.mRemote = mRemote;
            }
    
            @Override
            public IBinder asBinder() {
                return mRemote;
            }
    
            public java.lang.String getInterfaceDescriptor() {
                return DESCRIPTOR;
            }
    
            @Override
            public double getSum(double fisrt, double second)
                    throws RemoteException {
                Parcel data = Parcel.obtain();
                Parcel reply = Parcel.obtain();
                double result = 0;
                try {
                    /**
                     * Store an IBinder interface token in the parcel at the current
                     * {@link #dataPosition}. This is used to validate that the
                     * marshalled transaction is intended for the target interface.
                     */
                    data.writeInterfaceToken(DESCRIPTOR);
                    // 将请求的参数写入到data中
                    data.writeDouble(fisrt);
                    data.writeDouble(second);
                    // 调用transact()方法,发起跨进程请求,当前进程挂起
                    mRemote.transact(TRANSACTION_getSum, data, reply, 0);
                    // 从reply中获取返回的结果
                    reply.readException();
                    result = reply.readDouble();
                } catch (Exception e) {
                } finally {
                    data.recycle();
                    reply.recycle();
                }
                return result;
            }
        }
    
    }
    

    其中重要属性和方法说明如下:
    1.DESCRIPTOR:
    Binder 中唯一的标识,自动生成时用当前 Binder 类名表示。
    static final int TRANSACTION_getSum = IBinder.FIRST_CALL_TRANSACTION + 0;
    声明的整型的 id 用于标识在 transact 过程中客户端中请求的到底是哪个方法。

    2.asInterface(android.os.IBinder object)
    将服务端的 Binder 对象转换成客户端所需 AIDL 接口类型的对象,转换是区分进程的,客户端和服务器在同一进程中,返回的是服务端 Stub 本身,否则就返回系统封装后的 Stub.proxy 对象。

    3.asBinder
    返回当前的 Binder 对象

    4.onTransact
    本方法运行在服务器端中 Binder 线程池中,客户端发起跨进程请求时,远程请求会通过系统底层封装后交给此方法来处理:

    public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException

    通过 code 确定客户端方法的方法,然后从 data 中取得参数 (如果存在参数的话),然后执行在服务端的目标方法,执行完成之后,向 reply 中写入返回值 (如果客户端中需要返回值的话)。当然 onTransact 方法是有返回值的,如果返回 false,那么客户端就会请求失败。

    5.Proxy#getSum(double fisrt, double second)
    在客户端中运行,当客户端远程调用此方法时,内部实现方法如下:先创建所需的输入型 Parcel 对象_data, 输出型 Parcel 对象 _replay 和返回值对象 List。先将需求参数写入_data 中,接着调用 transact 方法发起远程调用 (RPC) 请求,同时当前线程会挂起,然后服务端的 onTransact 方法会被调用,当 RPC 方法结束返回后,当前线程从挂起状态变成重新运行状态,并从_reply 中取出 RPC 过程的返回结果,最后返回 _reply 中的数据。其中的内容就是大致就是调用 Binder 对象的 transact() 方法,因为调用该方法是在线程中进行,所以注意需要加个 try。 基本图解如下:

    Proxy图解

    总体逻辑:
    1 客户端调用 getSum() 方法
    2 将该方法需要的传递的参数写入到 data 中
    3 调用 transact() 方法发起跨进程请求
    4 服务端的 onTransact() 的方法被调用,客户端的进程被挂起
    5 服务端返回结果,从 reply 中取出结果,并返回

    linkToDeath & unlinkToDeath

    Binder 运行在服务端进程,如果服务进程由于某种原因异常终止,此时服务端的 Binder 链接断裂 (Binder 死亡),会导致我们的远程调用失败。更为关键的是,不知道 Binder 链接断裂,那么客户端的功能就会受影响。为了解决这个问题,Binder 中提供了两个配对的方法 lineToDeath 和 unlinkToDeath,通过 linktoDeath 可以 Binder 设置死亡代理,Binder 死亡时会受到死亡通知,此时可以重新发起连接请求从而恢复链接。

    private IOperationServer iOperationServer;  
    
    private IBinder.DeathRecipient mBinderPoolDeathRecipient = new IBinder.DeathRecipient() {
            @Override
            public void binderDied() {
                Log.d(TAG,"binder died...");
                if (iOperationServer== null)  
                    return;  
                iOperationServer.asBinder().unlinkToDeath(mDeathRecipient, 0);  
                iOperationServer= null;  
                // restart server or rebinding ServiceConnection
                bindService(intent, connection , BIND_AUTO_CREATE);  
            }
        } ;
    

    在客户端绑定远程服务成功后,给 binder 设置死亡代理:

    private IOperationServer iOperationServer;  
    private MyServiceConnection connection = new MyServiceConnection();  
    
    Intent intent = new Intent("com.hl.myservice");  
    private class MyServiceConnection implements ServiceConnection {  
         @Override  
          public void onServiceConnected(ComponentName name, IBinder service) {  
               iOperationServer= IOperationServer .Stub.asInterface(service);  
               Log.d("aidl", "onServiceConnected:" + iOperationServer);  
                 
                try {
                        Log.d("aidl", "onServiceConnected "+name.toShortString()+"  "+service.getInterfaceDescriptor());
                        service.linkToDeath(deathHandle, 0);
                    } catch (RemoteException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
            }  
         @Override  
          public void onServiceDisconnected(ComponentName name) {}  
    };  
    bindService(intent, connection , BIND_AUTO_CREATE);  
    

    基本上通过以上两个步骤,就会给 Binder 设置死亡代理,当 Binder 死亡的时候就会受到相应的通知了。

    相关文章

      网友评论

        本文标题:Android AIDL 简单使用和部分解释

        本文链接:https://www.haomeiwen.com/subject/tgowkftx.html