Andorid中的AIDL（三）

清疚 2022-06-14 04:58 159阅读 0赞

又到周末，终于有空啦，想到AIDL还有用到的知识点没有总结下来，AIDL还可以在进程间传输序列化的对象，写了个Demo来传自定义的对象，因为没有用AndroidStudio做过，这次用了Androidstudio。

要实现通信，需要建立三个Module,

一个客户端Module（serverapp）

一个服务端Module（clientapp）

一个作为通信依赖Module（AIDLlib）：其中包含通信需要的aidl文件，通信需要的类，以及parcelable对象aidl声明文件，其实这个Module也可以舍弃，但是客户端和服务端需要的aidl文件和通信使用的类，都要写在各自的Module，这样造成代码的重复，而且修改一边另一边也要修改，因此，三个Module这种写法优点还是很多的。

下面是我的截图：

![Center][]

clientapp 和serverapp需要添加依赖项目AIDLlib，这时候可能又会很多问题，要依赖的项目gradle中不要写appId什么的，解决掉后成功依赖（不详细介绍了，IDE的使用问题，和eclipse有些不同）

在Studio如何建立AIDL通信parcelable类如下：

第一步：建立AIDL依赖Moudule，对应我这里的AIDLlib这个Moudle；

首先建立需要通信的类，MyObject，代码如下：

package com.xue.qin.demo.myparcelableclass;
    
    import android.os.Parcel;
    import android.os.Parcelable;
    
    /**
     * Created by xue.qin on 2017/6/5.
     */
    
    public class MyObject implements Parcelable {
        private int n;
        private String name;
    
        public int getN() {
            return n;
        }
    
        public void setN(int n) {
            this.n = n;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getUseless() {
            return useless;
        }
    
        public void setUseless(String useless) {
            this.useless = useless;
        }
    
        private String useless;
    
        public MyObject(){
            n=0;
            name="default";
            useless="default";
        }
    
    
    
    
        public MyObject(int n, String name, String useless) {
            this.n = n;
            this.name = name;
            this.useless = useless;
        }
    
        public MyObject(Parcel source) {
            readFromParcel(source);
        }
    
        @Override
        public int describeContents() {
            return 0;
        }
    
        @Override
        public void writeToParcel(Parcel dest, int flags) {
            dest.writeInt(n);
            dest.writeString(name);
            dest.writeString(useless);
        }
    
        public void readFromParcel(Parcel source) {
            this.n = source.readInt();
            this.name = source.readString();
            this.useless = source.readString();
        }
    
        public static final Parcelable.Creator<MyObject> CREATOR = new Creator<MyObject>() {
            @Override
            public MyObject createFromParcel(Parcel source) {
                MyObject myObject2 = new MyObject(source);
                return myObject2;
            }
    
            @Override
            public MyObject[] newArray(int size) {
                return new MyObject[size];
            }
        };
    
        @Override
        public String toString() {
            return "( n:" + n + " name:" + name + " useless:" + useless + " 地址:" + super.toString() + " )";
        }
    }

具体如何android序列化： [点击打开链接][Link 1]

建立好这个类之后需要在aidl中声明这个序列化的类，在AIDL文件夹下，建立同样Package，建立和类一样名字的声明MyObject.aidl。代码如下：

package com.xue.qin.demo.myparcelableclass;
    parcelable MyObject;

到此处，就把用于通信的parcelable类做好了，然后再写我们用于通信的AIDL写几个接口方法吧，建立IMyAidlInterface.aidl文件。代码如下；

package com.xue.qin.aidl;
    import com.xue.qin.demo.myparcelableclass.MyObject;
    interface IMyAidlInterface {
        MyObject inObject(in MyObject obj);
        MyObject outObject(out MyObject obj);
        MyObject inoutObject(inout MyObject obj);
    }

这其中引入了刚做好的MyObject类。至此第一个Moudle,就完成了，clean一下就会自动生成aidl的java文件了。

第二步，建立serverapp，和正常的serverapp一样，引入aidl文件，返回binder，代码如下：

package com.xue.qin.server;
    
    import android.app.Service;
    import android.content.Intent;
    import android.os.IBinder;
    import android.os.RemoteException;
    import android.util.Log;
    
    import com.xue.qin.aidl.IMyAidlInterface;
    import com.xue.qin.demo.myparcelableclass.MyObject;
    
    /**
     * Created by xue.qin on 2017/6/1.
     */
    
    public class ServerService extends Service {
        private static final String TAG = "ServerService";
    
        @Override
        public void onCreate() {
            super.onCreate();
            Log.i(TAG,"onCreate() Thread.currentThread() = "+Thread.currentThread());
        }
    
        @Override
        public IBinder onBind(Intent intent) {
            return new MyBinder();
        }
    
        private class MyBinder extends IMyAidlInterface.Stub {
    
            @Override
            public MyObject inObject(MyObject obj) throws RemoteException {
                Log.i(TAG,"Thread.currentThread() = "+Thread.currentThread());
                Log.i(TAG, "inObject = " + obj);
                obj.setN(100);
                obj.setName("dog");
                obj.setUseless("there");
                return new MyObject(3,"pig","home");
            }
    
            @Override
            public MyObject outObject(MyObject obj) throws RemoteException {
                Log.i(TAG, "outObject = " + obj);
                obj.setN(100);
                obj.setName("dog");
                obj.setUseless("there");
                return new MyObject(3,"pig","home");
            }
    
            @Override
            public MyObject inoutObject(MyObject obj) throws RemoteException {
                Log.i(TAG, "inoutObject = " + obj);
                obj.setN(100);
                obj.setName("dog");
                obj.setUseless("there");
                return new MyObject(3,"pig","home");
    
            }
        }
    }

至此service也建立好了，clean一下跑了起来。

![Center 1][]

第三步，建立clientapp，引入aidl文件，绑定远端service，调用方法就可以了。代码如下：

package com.xue.qin.aidldemo;
    
    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.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    
    import com.xue.qin.aidl.IMyAidlInterface;
    import com.xue.qin.demo.myparcelableclass.MyObject;
    
    /**
     * Created by xue.qin on 2017/6/1.
     */
    
    public class ClientActivity extends Activity implements View.OnClickListener {
        private static final String TAG = "ClientActivity";
        private TextView mTextView;
        private Button mButton;
        private IMyAidlInterface mService = null;
    
        private ServiceConnection mConntection = new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                Log.i(TAG, "onServiceConnected()");
                mService = IMyAidlInterface.Stub.asInterface(service);
            }
    
            @Override
            public void onServiceDisconnected(ComponentName name) {
                Log.i(TAG, "onServiceDisconnected()");
                mService = null;
            }
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main_activity_layout);
            mTextView = (TextView) findViewById(R.id.result);
            mButton = (Button) findViewById(R.id.switchmodel);
            mButton.setOnClickListener(this);
        }
    
        @Override
        protected void onResume() {
            super.onResume();
            Intent intent = new Intent("remoteService");
            intent.setPackage("com.xue.qin.server");
            boolean success = bindService(intent, mConntection, Context.BIND_AUTO_CREATE);
            Log.i(TAG, "onResume() success = " + success);
        }
    
        @Override
        protected void onPause() {
            super.onPause();
            unbindService(mConntection);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.switchmodel:
                    try {
                        MyObject obj1 = new MyObject(1, "cat", "there");
                        MyObject obj2 = new MyObject(1, "cat", "there");
                        MyObject obj3 = new MyObject(1, "cat", "there");
                        Log.i(TAG,"before fun obj1 = "+obj1);
                        MyObject result1in = mService.inObject(obj1);
                        Log.i(TAG, "after fun obj1 = " + obj1);
                        Log.i(TAG, "result1in = " + result1in);
    
    
                        Log.i(TAG,"before fun obj2 = "+obj2);
                        MyObject resultlout = mService.outObject(obj2);
                        Log.i(TAG, "after fun obj2 = " + obj2);
                        Log.i(TAG, "resultlout = " + resultlout);
    
    
                        Log.i(TAG,"before fun obj3 = "+obj3);
                        MyObject resultlinout = mService.inoutObject(obj3);
                        Log.i(TAG, "after fun obj3 = " + obj3);
                        Log.i(TAG, "resultlinout = " + resultlinout);
    
    
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
            }
        }
    
        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
        }
    }

这样客户端也建立好了，clean一下跑起来了。

![Center 2][]

看到点击一下button，log看一下。

06-10 15:22:24.643 24510-24510/com.xue.qin.aidldemo I/ClientActivity: before fun obj1 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@e1b21e8 )
    06-10 15:22:24.645 24238-24250/com.xue.qin.server I/ServerService: Thread.currentThread() = Thread[Binder_2,5,main]
    06-10 15:22:24.645 24238-24250/com.xue.qin.server I/ServerService: inObject = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@3536dcc )
    06-10 15:22:24.646 24510-24510/com.xue.qin.aidldemo I/ClientActivity: after fun obj1 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@e1b21e8 )
    06-10 15:22:24.646 24510-24510/com.xue.qin.aidldemo I/ClientActivity: result1in = ( n:3 name:pig useless:home 地址:com.xue.qin.demo.myparcelableclass.MyObject@7525001 )
    06-10 15:22:24.647 24510-24510/com.xue.qin.aidldemo I/ClientActivity: before fun obj2 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@4328ea6 )
    06-10 15:22:24.648 24238-24249/com.xue.qin.server I/ServerService: outObject = ( n:0 name:default useless:default 地址:com.xue.qin.demo.myparcelableclass.MyObject@dc21815 )
    06-10 15:22:24.650 24510-24510/com.xue.qin.aidldemo I/ClientActivity: after fun obj2 = ( n:100 name:dog useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@4328ea6 )
    06-10 15:22:24.650 24510-24510/com.xue.qin.aidldemo I/ClientActivity: resultlout = ( n:3 name:pig useless:home 地址:com.xue.qin.demo.myparcelableclass.MyObject@b6180e7 )
    06-10 15:22:24.651 24510-24510/com.xue.qin.aidldemo I/ClientActivity: before fun obj3 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@7747494 )
    06-10 15:22:24.652 24238-24252/com.xue.qin.server I/ServerService: inoutObject = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@438d72a )
    06-10 15:22:24.653 24510-24510/com.xue.qin.aidldemo I/ClientActivity: after fun obj3 = ( n:100 name:dog useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@7747494 )
    06-10 15:22:24.654 24510-24510/com.xue.qin.aidldemo I/ClientActivity: resultlinout = ( n:3 name:pig useless:home 地址:com.xue.qin.demo.myparcelableclass.MyObject@692eb3d )

看到有通信的log打印出来，到此，AIDL的parcelable传递就可以了。

其他的一些问题：

在aidl文件中有

看到这些方法参数中的tag 有in，out，和inout这三种类型，针对三种类型来一次分析一下log。

客户端测试方式，在调用每个方法之前我想打印出参数信息

Log.i(TAG,"before fun obj1 = "+obj1);

然后调用方法，最后再打印一遍这个参数对象，看看有没有被服务端修改。

Log.i(TAG, "after fun obj1 = " + obj1);

服务端测试方式，每个方法采用同样的处理方式，对每个传入的对象修改，返回一个new MyObject()；例如如下代码

@Override
            public MyObject outObject(MyObject obj) throws RemoteException {
                Log.i(TAG, "outObject = " + obj);
                obj.setN(100);
                obj.setName("dog");
                obj.setUseless("there");
                return new MyObject(3,"pig","home");
            }

对传入的参数修改，修改name为dog，修改N为100，修改Useless为there，返回一个全新的MyObject().

1）分析tag 为in的情况：

in，代表数据只能由客户端向服务端传输，服务端无法修改输入参数。

看一下Clientapp的log如下：

06-10 15:36:00.551 24510-24510/com.xue.qin.aidldemo I/ClientActivity: before fun obj1 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@e68ef32 )
    06-10 15:36:00.554 24510-24510/com.xue.qin.aidldemo I/ClientActivity: after fun obj1 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@e68ef32 )

看到前后的值完全是一致的，与猜想是一致的。

2）分析tag 为out的情况：

out，代表数据只可以由服务端向客户端传输，也就是服务端是可以修改这些参数。

先去看server端的参数传进来没有？看一下log，如下，并没有传入。

06-10 15:36:00.555 24238-24250/com.xue.qin.server I/ServerService: outObject = ( n:0 name:default useless:default 地址:com.xue.qin.demo.myparcelableclass.MyObject@d2f9ab8 )

再去看一下client端的参数变化,log如下：

06-10 15:36:00.554 24510-24510/com.xue.qin.aidldemo I/ClientActivity: before fun obj2 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@e6e4600 )
    06-10 15:36:00.556 24510-24510/com.xue.qin.aidldemo I/ClientActivity: after fun obj2 = ( n:100 name:dog useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@e6e4600 )

看到地址，这个这个对象的引用，是同一个，但是元素（n,和name）都被修改过了，实际上useless也被修改了只是原来也是there，被修改成了there，猜想的到验证。

3）分析tag 为inout的情况：

inout，代表数据是可以相互传输的。

先去看server端的参数传进来没有？看一下log，如下，传入成功。

06-10 16:03:53.519 27128-27148/com.xue.qin.server I/ServerService: inoutObject = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@29ec96c )

再去看一下client端的参数变化,log如下：

06-10 15:36:00.557 24510-24510/com.xue.qin.aidldemo I/ClientActivity: before fun obj3 = ( n:1 name:cat useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@132cc7e )
    06-10 15:36:00.559 24510-24510/com.xue.qin.aidldemo I/ClientActivity: after fun obj3 = ( n:100 name:dog useless:there 地址:com.xue.qin.demo.myparcelableclass.MyObject@132cc7e )

和out一样，对象也被修改了，

特性就是这样子了，下面分析一下源码，其实不重要了，算是打破砂锅问到底吧哈哈。

源码分析（不重要，主要是闲的。。）

1） tag为 in ，client端 proxy中inObject（）方法。

@Override
                public com.xue.qin.demo.myparcelableclass.MyObject inObject(com.xue.qin.demo.myparcelableclass.MyObject obj) throws android.os.RemoteException {
                    android.os.Parcel _data = android.os.Parcel.obtain();
                    android.os.Parcel _reply = android.os.Parcel.obtain();
                    com.xue.qin.demo.myparcelableclass.MyObject _result;
                    try {
                        _data.writeInterfaceToken(DESCRIPTOR);
                        if ((obj != null)) {
                            _data.writeInt(1);
                            obj.writeToParcel(_data, 0);
                        } else {
                            _data.writeInt(0);
                        }
                        mRemote.transact(Stub.TRANSACTION_inObject, _data, _reply, 0);
                        _reply.readException();
                        if ((0 != _reply.readInt())) {
                            _result = com.xue.qin.demo.myparcelableclass.MyObject.CREATOR.createFromParcel(_reply);
                        } else {
                            _result = null;
                        }
                    } finally {
                        _reply.recycle();
                        _data.recycle();
                    }
                    return _result;
                }

服务端代码如下stub中的转发：

case TRANSACTION_inObject: {
                        data.enforceInterface(DESCRIPTOR);
                        com.xue.qin.demo.myparcelableclass.MyObject _arg0;
                        if ((0 != data.readInt())) {
                            _arg0 = com.xue.qin.demo.myparcelableclass.MyObject.CREATOR.createFromParcel(data);
                        } else {
                            _arg0 = null;
                        }
                        com.xue.qin.demo.myparcelableclass.MyObject _result = this.inObject(_arg0);
                        reply.writeNoException();
                        if ((_result != null)) {
                            reply.writeInt(1);
                            _result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                        } else {
                            reply.writeInt(0);
                        }
                        return true;
                    }

客户端源码中，参数obj写入了\_data中的。

if ((obj != null)) {
                            _data.writeInt(1);
                            obj.writeToParcel(_data, 0);
                        } else {
                            _data.writeInt(0);
                        }

服务端读取，obj。

if ((0 != data.readInt())) {
                            _arg0 = com.xue.qin.demo.myparcelableclass.MyObject.CREATOR.createFromParcel(data);
                        } else {
                            _arg0 = null;
                        }

完成了客户端向服务端的传输。

2） tag为 out ，client端 proxy中outObject（）方法。

@Override
                public com.xue.qin.demo.myparcelableclass.MyObject outObject(com.xue.qin.demo.myparcelableclass.MyObject obj) throws android.os.RemoteException {
                    android.os.Parcel _data = android.os.Parcel.obtain();
                    android.os.Parcel _reply = android.os.Parcel.obtain();
                    com.xue.qin.demo.myparcelableclass.MyObject _result;
                    try {
                        _data.writeInterfaceToken(DESCRIPTOR);
                        mRemote.transact(Stub.TRANSACTION_outObject, _data, _reply, 0);
                        _reply.readException();
                        if ((0 != _reply.readInt())) {
                            _result = com.xue.qin.demo.myparcelableclass.MyObject.CREATOR.createFromParcel(_reply);
                        } else {
                            _result = null;
                        }
                        if ((0 != _reply.readInt())) {
                            obj.readFromParcel(_reply);
                        }
                    } finally {
                        _reply.recycle();
                        _data.recycle();
                    }
                    return _result;
                }

在客户端proxy找不到obj写入\_data的代码，根本就没有写入，服务端自然也就读不到，代码中，在读取了返回值之后，又从\_reply中读取了一个obj，这就就是服务端修改后的obj

读取代码如下，参数得到了修改。

if ((0 != _reply.readInt())) {
                            obj.readFromParcel(_reply);
                        }

服务端stub转发的代码：

case TRANSACTION_outObject: {
                        data.enforceInterface(DESCRIPTOR);
                        com.xue.qin.demo.myparcelableclass.MyObject _arg0;
                        _arg0 = new com.xue.qin.demo.myparcelableclass.MyObject();
                        com.xue.qin.demo.myparcelableclass.MyObject _result = this.outObject(_arg0);
                        reply.writeNoException();
                        if ((_result != null)) {
                            reply.writeInt(1);
                            _result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                        } else {
                            reply.writeInt(0);
                        }
                        if ((_arg0 != null)) {
                            reply.writeInt(1);
                            _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                        } else {
                            reply.writeInt(0);
                        }
                        return true;
                    }

自己new了一个无参数的对象，作为参数，这就是在log中打印的是默认的无参数构造的对象的原因。

_arg0 = new com.xue.qin.demo.myparcelableclass.MyObject();

同时在返回值写入之后，又将当前自己生成的参数写入了reply中。

if ((_arg0 != null)) {
                            reply.writeInt(1);
                            _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
                        } else {
                            reply.writeInt(0);
                        }

3）tag 为 in out的情况，将上面两种情况统一起来，全都存在就是了。

客户端有写入，服务端有读取。

服务端在写完result之后，又将参数写入了replay。客户端在读取了result之后，又读取了一个Obj从\_replay中。

demo点击[DEMO地址][DEMO]

[Center]: /images/20220614/59406ba1cc1844b7bb16cd8fd8ee5512.png
[Link 1]: http://blog.csdn.net/qinxue24/article/details/72866897
[Center 1]: /images/20220614/67b9ef2b251c4abca53ff7c1035e22ef.png
[Center 2]: /images/20220614/2fc23dc2ff4246b3bafbc5b4fdbf2eba.png
[DEMO]: https://github.com/xueqin123/AIDLparcelable