aidl ( 六) 加入序列化对象传输

最新推荐文章于 2024-01-08 09:00:00 发布
最新推荐文章于 2024-01-08 09:00:00 发布
阅读量2.2k 收藏 3
点赞数
分类专栏： android_Aidl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/litefish/article/details/50923981
版权

在之前的文章中，我们传的都是java基本类型或者string，其实aidl也可以传序列化好的对象，序列化 的对象必须实现Parcelable接口。

我们来举个例子说明aidl如何传输序列化数据的，参考module为aidlclient3和aidlserver3。aidlclient3在aidlclient1的基础上修改，aidlserver3在aidlserver2 的基础上修改。

 先看客户端，首先在com.data包下建立BaseData类，BaseData实现了Parcelable接口，然后在aidl文件夹的同名目录下建立，BaseData.aidl，代码如下，主要就是申明这个类。

 

// BaseData.aidl
package com.data;

// Declare any non-default types here with import statements
parcelable BaseData;


然后在IMyAidlInterface.aidl文件内加一行代码

 

int putRemote(in BaseData data,int t);

注意BaseData必须加方向tag，是in或者out或者inout，记住，只要不是基本类型或者string都必须加方向tag。

注意要加BaseData的import代码

import com.data.BaseData;

然后在onServiceConnected内加入

 

 BaseData baseData=new BaseData("a","b",5);
 myAIDLInterface.putRemote(baseData, 7);
 LogUtil.fish("now name is " + baseData.getName());


OK，客户端代码搞定

 

此时，客户端代码如下

 

public class MainActivity extends Activity implements View.OnClickListener {


    private Button bindService;

    private Button unbindService;


    private IMyAidlInterface myAIDLInterface;
    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            LogUtil.d("handleMessage");
            TextView tv = (TextView) findViewById(R.id.textView);
            tv.setText("" + msg.what);


        }
    };
    private ICallback callback = new ICallback.Stub() {
        @Override
        public void showTime(int x) throws RemoteException {
            LogUtil.d("callback" + x);
            LogUtil.process(getApplicationContext());
            LogUtil.thread("showTime");
            handler.sendEmptyMessage(x);
//
        }
    };

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            LogUtil.d("process name" + SystemUtil.getCurProcessName(MainActivity.this));
            myAIDLInterface = IMyAidlInterface.Stub.asInterface(service);
            LogUtil.thread("onServiceConnected");
            try {
                int cnt = myAIDLInterface.getCount();
//                double db = myAIDLInterface.complexCal("hello world", 6);
                LogUtil.d("result is " + cnt);
//                LogUtil.d("complexCal value " + db);
                BaseData baseData=new BaseData("a","b",5);
                myAIDLInterface.putRemote(baseData, 7);
                LogUtil.fish("now name is " + baseData.getName());


                myAIDLInterface.setCallback(callback);

//                myAIDLInterface.setCallback(new ICallback.Stub() {
//                    @Override
//                    public void showTime(int x) throws RemoteException {
//                        LogUtil.d("callback"+x);
                        TextView tv = (TextView) findViewById(R.id.textView);
                        tv.setText(""+x);
//                    }
//
//                    @Override
//                    public IBinder asBinder() {
//                        return null;
//                    }
//                });
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

    public String mAction="com.example.servicetest.MyAIDLService";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        LogUtil.thread("main");
        bindService = (Button) findViewById(R.id.bind_service);
        unbindService = (Button) findViewById(R.id.unbind_service);

        bindService.setOnClickListener(this);
        unbindService.setOnClickListener(this);
        Intent intent = new Intent(mAction);
        startService(intent);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.bind_service:
                Intent intent = new Intent(mAction);
                boolean b = bindService(intent, connection, Service.BIND_AUTO_CREATE);
                LogUtil.d("bind result " + b);
                break;
            case R.id.unbind_service:
                unbindService(connection);

                LogUtil.d("unbind ");
                break;
            default:
                break;
        }

    }

    @Override
    public void onBackPressed() {
        super.onBackPressed();
        Intent intent = new Intent(mAction);
        LogUtil.d("stopservice");
        stopService(intent);
    }
}


而服务端的service代码如下，

 

 

public class MyService extends Service {
    private boolean quit;

    private int count;
    public static final int TIMER = 1;
    private ICallback mCallback;
    private IMyAidlInterface.Stub mBinder = new IMyAidlInterface.Stub() {

        @Override
        public int getCount() throws RemoteException {
            return count;
        }

        @Override
        public double complexCal(String str, int t) throws RemoteException {
            int ret = str.hashCode() + t;
            return 1 * 0.3;
        }

        @Override
        public int putRemote(BaseData data, int t) throws RemoteException {
            String s=data.getName();
            data.setName("sss");
            LogUtil.fish(s);
            return t+1;
        }

        @Override
        public void setCallback(ICallback call) throws RemoteException {
            LogUtil.d("setcallback" + call);
            LogUtil.thread("set callback");
            mCallback = call;

        }
    };
    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case TIMER:
                    if(!quit)
                    {
                        count++;
                        if (mCallback != null) {
//                            LogUtil.d("callback");
//                            try {
//                                mCallback.showTime(count);
//                            } catch (RemoteException e) {
//                                e.printStackTrace();
//                            }
                        } else {
                            LogUtil.d("callback null");
                        }
                        sendEmptyMessageDelayed(TIMER,2000);
                    }

                    break;
                default:
                    super.handleMessage(msg);
            }


        }
    };

    @Override
    public void onCreate() {
        super.onCreate();

        LogUtil.thread("service main");
        LogUtil.d("onCreate process name " + SystemUtil.getCurProcessName(MyService.this));
        LogUtil.d("Service is Created");
        count=0;
        handler.sendEmptyMessageDelayed(TIMER,2000);

    }

    @Override
    public void onDestroy() {
        LogUtil.d("onDestroy process name " + SystemUtil.getCurProcessName(MyService.this));
        quit = true;
        super.onDestroy();
    }

    @Override
    public IBinder onBind(Intent intent) {
        LogUtil.d("onBind process name " + SystemUtil.getCurProcessName(MyService.this));
        return mBinder;
    }



}


此时clent可以成功把数据传给server。

 

我们注意下这行代码

myAIDLInterface.putRemote(baseData, 7);

，baseData传的是引用，那么在服务端能不能修改baseData呢，答案是可以的，但是aidl的方向tag必须 写为inout，而且BaseData类内部要加一个函数

 

    public void readFromParcel(Parcel in){
        name = in.readString();
        payType = in.readString();
        payMoney = in.readInt();
    }

具体的原理是这样的，baseData在跨进程的传输过程中是要经过序列化，修改，反序列化的过程的。如果方向tag为in，那表示这个数据需要从客户端传给服务端，那只要客户端序列化好了，传给服务端就好了。

 

过程是这样的，

1，客户端把baseData序列化为字节数组

2，字节数组传到服务端

3，服务端利用BaseData里的CREATOR把字节数组转化为BaseData实例。

但是如果tag为inout，那表示这个数据一方面需要传给服务端，另一方面还需要服务端返回给客户端。

过程除了上面3步之外，还要执行

4、服务端处理完之后把服务端的BaseData序列化成字节数组，

5、客户端使用readFromParcel，读取字节数组，生成新的BaseData，覆盖原有对象。

由此可见方向tag非常重要，会很大程度影响效率，所以如果客户端传给服务端的数据，而不需要服务端写好传回来就用in。

如果一定要服务端处理好后传给客户端，就用inout。

可以简单理解为in是传值，inout是传引用。只是理解哦，这里是跨进程的

in的效率比inout高出很多。

从代码的角度上，我们可以看加in和inout编译出来的java文件的区别，

in的服务端代码

 

case TRANSACTION_putRemote:
{
data.enforceInterface(DESCRIPTOR);
com.c.BaseData _arg0;
if ((0!=data.readInt())) {
_arg0 = com.c.BaseData.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
int _arg1;
_arg1 = data.readInt();
int _result = this.putRemote(_arg0, _arg1);
reply.writeNoException();
reply.writeInt(_result);
if ((_arg0!=null)) {
reply.writeInt(1);
_arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
}
else {
reply.writeInt(0);
}
return true;


inout生成 的服务端代码

 

 

case TRANSACTION_putRemote:
{
data.enforceInterface(DESCRIPTOR);
com.c.BaseData _arg0;
if ((0!=data.readInt())) {
_arg0 = com.c.BaseData.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
int _arg1;
_arg1 = data.readInt();
int _result = this.putRemote(_arg0, _arg1);
reply.writeNoException();
reply.writeInt(_result);
return true;
}


差别在于，inout的服务端需要把arg0以parceble形式写到reply里面去，准备回传给客户端

 

 

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

再来看in生成的客户端代码

 

 

@Override public int putRemote(com.c.BaseData data, int t) 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);
if ((data!=null)) {
_data.writeInt(1);
data.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
_data.writeInt(t);
mRemote.transact(Stub.TRANSACTION_putRemote, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}

 


再看inout生成的客户端代码

 

 

 

@Override public int putRemote(com.c.BaseData data, int t) 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);
if ((data!=null)) {
_data.writeInt(1);
data.writeToParcel(_data, 0);
}
else {
_data.writeInt(0);
}
_data.writeInt(t);
mRemote.transact(Stub.TRANSACTION_putRemote, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
if ((0!=_reply.readInt())) {
data.readFromParcel(_reply);
}
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}


比较一下，差距在于，inout的客户端需要从reply中读取BaseData数据，并且写入putRemote传进来的参数data中

 

 

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

 

 

 

 

 

 

 

litefish
关注
专栏目录
android 加入AIDL进行底层通讯 两个应用之间使用AIDL进行通信，github测试通过，
ZJQ的博客
03-25 1239
错误： Error:Execution failed for task ':server:compileDebugAidl'. > java.io.IOException: com.android.ide.common.process.ProcessException: Error while executing process C:\Users\Administrator\AppData...
使用 AIDL 实现客户端和服务的进程间通信（IPC）
哈罗德Android笔记
08-09 1125
1. 使用步骤 AIDL 的意思是 Android 接口定义语言。利用它来定义进程间通信时双方认可的编程接口。 第一步：创建 .aidl 文件 AIDL 接口方法中支持的参数类型： 8 个基本数据类型 String CharSequence List：List 中的所有元素必须是以上支持的数据类型、其他 AIDL 生成的接口或自定义的 Parcelable 类型。接收端实际接受的具体类始...
3、AIDL传递序列化数据
延龙的博客
01-15 1533
1、简单的传递数据 场景：客户端传递数据 i，j，服务端计算i+j 这个具体流程就不贴了，流程可以参考第一篇 直接贴代码和结果，这个不是今天要记录的重点。 2、传递序列化数据 场景：User类，变量 name 和 age，返回 包含 name 和 age 的字符串 服务端 ①、在AIDL包下，新建 User.java，新建User.aidl 重点：名称要一样。不一样会报错。 ...
Android 使用AIDL传递序列化数据
01-03
本次测试的是客户端和服务端使用Aidl方式实现跨进程通信。 准备工作： 1.首先定义一个客户端，这边是App0429(com.example.app0429),主要含有一个MainActivity.class 2.然后定义一个服务端，这边是App0423(com.example.app0423),主要写一个服务TestService.class 3.编写aidl文件 原创文章 12获赞 1访问量 236 关注
service通讯的序列化 AIDL
pipisky2006的专栏
12-19 1833
使用AIDL设计远程接口(Designinga Remote Interface Using AIDL)由于每个应用程序都运行在自己的进程空间，并且可以从应用程序UI运行另一个服务进程，而且经常会在不同的进程间传递对象。在Android平台，一个进程通常不能访
AIDL 学习Demo，包含定向Tag，序列化信息通讯。
12-01
AIDL的序列化信息通讯，定向tag的使用以及特性。AIDL的使用注意事项。
android关于类在序列化以及AIDL中的若干总结点
qq_24538089的博客
04-12 683
1.类在序列化的过程中，采用synchronized这种序列化方式的时候，操作比较简单，但是主要为java设计，会增大项目开销，以及大量的IO操作。 2，采用parcelable这种序列化是，需注意一下问题，wirteToParce这个方法是为了序列化对象，CREATOR这个方法是为了反序列化，descriableContent是内容描述的方法，一般值为0，在有文件描述符的时候值为1，在（Par
Android AIDL接口定义语言
11-08
然而，虽然AIDL提供了强大的跨进程通信能力，但其性能相对较低，因为每次调用都需要进行序列化和反序列化，以及进程间的切换。因此，对于频繁的通信需求，开发者可能需要考虑其他优化手段，如使用`Messenger`或`...
Android 关于AIDL你需要知道的一切
咸鱼君i
05-06 6834
好的，由于上周拖更，本次带来Android进程通信详解–AIDL，虽然网上关于这个内容的资料丰富且详细，但一千个读者就有一千个哈姆雷特不是嘛，对于任何东西都要有自己的见解。Service关于AIDL，Service就是我们不得不提的东西了，它是Android四大组件之一，太基础的东西这里我们就不再赘述，下面还是给出一些我对于Service的认识：上图为Service的生命周期从图里不难看出，Serv
AIDL学习及解析《一》
Sunrise的专栏
05-16 606
简介 AIDL：Android Interface Definition Language，android接口定义语言。可以利用它定义客户端与服务端使用进程间通信进行相互通信时都认可的编程接口；Android上，一个进程通常无法访问另一个进程的内存。进程需要将其对象分解成能够识别的原语，并将对象编组成跨越边界的对象。编写执行这一编组操作的代码是一项繁琐的工作。因此Android会使用AIDL。 ...
关于AIDL的基本要点
毛宏宇的博客
12-31 830
什么叫做AIDLAIDL (Android Interface Definition Language) AIDL IPC 多个应用程序 多线程 Binder 只有IPC 没有多线程 多个应用程序 Messenger 只有IPC 没有多线程 在Android Studio中创建AIDL1.右键单击Java点击弹出菜单，在New菜单中选择folder——
AIDL解析(一)：AIDL原理解析
热门推荐
DreamWendy
04-06 1万+
AIDL编写 AIDL运行原理 AIDL
Android开发——进程间通信之AIDL（二）
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
03-25 2690
0. 前言 不论是Android还是其他操作系统，都会有自己的IPC机制，所谓IPC（Inter-Process Communication）即进程间通信。首先线程和进程是很不同的概念，线程是CPU调用的最小单元，进程一般在PC和移动设备上指一个程序或者一个应用，一个进程可以包含多个线程。 IPC方式有很多，在Android中常用的IPC方式包括Bundle、文件、Messenger、AID......
AIDL初步理解
qq_24695201的博客
06-14 205
一 几种IPC的场合和优缺点             android 开发中Binder主要用在service中 包括AIDL和Messager，其中Messager底层是AIDL所以选用AIDl分析工作机制。二 简要流程1 进程间通信客户端通过Proxy将数据写入IBinder中 这一步主要做了先得到Parcel对象将目标标识放入data中 并通过方法IBinder方法transact写入内存中...
进程间通信（AIDL的简单使用）
weixin_42171638的博客
12-24 142
进程间通信 基本类型可以使用Intent  但是如果传递对象的话 需要先将该对象 序列化。 一般将对象序列化有两种方式，        1.是java的方式 使用Serializable，这种比较简单 直接实现Serializable接口就行啦，但是一般需要在定义一个serialVersionUID参数，通过这个参数可以更好的实现反序列化。这种方式的开销比较大，因为要使用IO操作，一般也就在存...
Android：AIDL简单介绍+传递简单数据+传递复杂数据
最新发布
shanhe_yuchuan的博客
01-08 4317
AIDL简单介绍+传递简单数据+传递复杂数据.AIDL的目的就是实现进程之间的通信，尤其是在涉及多进程并发情况下的进程间通信。可以将aidl理解为两个进程之间的桥梁，并制定规则，使其传输特定数据。
AIDL用法详解
qq_38056514的博客
11-05 6136
AIDL内容详解
AIDL（三) 数据传递--基本类型
lumingzhang的博客
04-30 2384
AIDL默认支持的数据类型 基本数据类型 String CharSequence List，Map Parcelable（序列化） 1.当编译如上类型时报以下错误： 可以看到右边红色字体说不知道参数aShort这种类型，so它并不支持short类型，去掉即可编译通过。 2.当加入如下List类型时： 报如下错误： 解释：这块的参数，你必须标识是输...
android aidl中接口是序列化对象嘛
03-29
是的，Android AIDL（Android Interface Definition Language）中的接口是序列化对象。在 Android 中，进程间通信（IPC）是通过将对象序列化为二进制数据来实现的。因此，AIDL 接口中的参数和返回值必须是可序列化的对象。这样才能确保在进程间传递数据时，对象能够被正确地序列化和反序列化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值