五、AIDL（二）不同应用中使用、自定义数据类型及定向Tag

已于 2024-01-14 09:52:10 修改
阅读量992 收藏 16
点赞数 17
分类专栏： Android 合集 文章标签： android
于 2024-01-11 22:54:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31654025/article/details/135540827
版权

一、Service 开启和停止
二、Service 执行耗时工作
三、IPC常用方式
四、AIDL（一）同一应用中使用AIDL及原理
五、AIDL（二）不同应用中使用、自定义数据类型及定向Tag
六、AIDL（三）实现回调
七、AIDL（四）获取服务及绑定和Binder传递流程

文章目录

AIDL（二）不同应用中使用、自定义数据类型及定向Tag

5.1 项目介绍

5.1.1 整体介绍

本项目中，因为探究的是不同应用中使用AIDL、在AIDL中自定义数据类型以及定向Tag的使用，所以项目中有两个app（分别为：AndroidIPCServer：服务端、AndroidIPCClient：客户端）、一个自定义数据类（VectorQuantity），两个AIDL文件（IVectorQuantityInterface和VectorQuantity）。

我们知道，AIDL中在服务端和客户端之间会传递数据，但是传递的数据在双端却不是同一个对象，为确保两端对象修改的一致性，定义了定向Tag，定向Tag有三种，分别表示了在跨进程通信中数据的流向：

  • in：其中 in 表示数据只能由客户端流向服务端，表现为服务端将会接收到传递对象的完整数据，但是服务端对数据的修改不会传递到客户端；
  • out表示数据只能由服务端流向客户端，表现为服务端接收到的数据对象是空对象（由无参构造器创建），但是在服务端对数据的修改会传递到客户端；
  • inout表示数据可在服务端与客户端之间双向传递，表现为客户端传递到服务端的数据服务端可以接收到，服务端对数据的修改也可以传递到客户端；

5.1.2 定向Tag实验

为验证in、out和inout三个定向Tag功能，我们可以定义一个自定义数据类VectorQuantity，该类是一个一维向量，详细的内容参考后面的类代码。结合VectorQuantity类和定向Tag，设计出下面实验：

  1. in tag：在客户端数据为[1,2]，随后服务端将数据修改为[11,12]。根据理论结果，服务端接收到的数据为[1,2]，但是修改的数据[11,12]不能传递到客户端，所以，客户端数据仍为[1,2]；
  2. our tag：在客户端数据为[3,4]，随后将数据修改为[13,14]。根据理论结果，[3,4]不能传递到服务端，服务端的数据为[]，但是修改的数据[13,14]可以传递到客户端，所以，客户端数据改变为[13,14]；
  3. inout tag：在客户端数据为[5,6]，随后将数据修改为[15,16]。根据理论结果，[5,6]可以传递到服务端，服务端的数据为[5,6]，修改的数据[13,14]也可以传递到客户端，所以，客户端数据改变为[15,16]；

5.2 项目代码

5.2.1 自定义数据类型

代码1

com.ieening.androidipcserver.vectorquantity.VectorQuantity

package com.ieening.androidipcserver.vectorquantity;

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

import androidx.annotation.NonNull;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class VectorQuantity implements Parcelable { // 注释1
    private static final String REGEX_PATTERN = "(?<=\\()( *?\\d+? *?,?)+?(?=\\))";

    public ArrayList<Double> getComponents() {
        return components;
    }

    public int getDimension() {
        return components.size();
    }

    private final ArrayList<Double> components;

    protected VectorQuantity(Parcel in) {
        this();
        for (double component :
                Objects.requireNonNull(in.createDoubleArray())) {
            this.components.add(component);
        }
    }

    public VectorQuantity() { // 注释2
        this.components = new ArrayList<>();
    }

    public static final Creator<VectorQuantity> CREATOR = new Creator<VectorQuantity>() { // 注释3
        @Override
        public VectorQuantity createFromParcel(Parcel in) {
            return new VectorQuantity(in);
        }

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

    public VectorQuantity(ArrayList<Double> arrayList) {
        this();
        this.components.addAll(arrayList);
    }

    public static VectorQuantity getNewInstance(String componentsString) {
        ArrayList<Double> doubles = getDoublesFromString(componentsString);
        return new VectorQuantity(doubles);
    }

    @NonNull
    private static ArrayList<Double> getDoublesFromString(String componentsString) {
        String componentsStringTrim = componentsString.trim();
        Matcher matcher = Pattern.compile(REGEX_PATTERN).matcher(componentsStringTrim);
        ArrayList<Double> doubles = new ArrayList<>();
        while (matcher.find()) {
            int begin = matcher.start();
            int end = matcher.end();
            for (String component : componentsStringTrim.substring(begin, end).split(",")) {
                doubles.add(Double.parseDouble(component.trim()));
            }
        }
        return doubles;
    }

    @NonNull
    @Override
    public String toString() {
        return this.components.toString();
    }

    @Override
    public int describeContents() { // 注释4
        return 0;
    }

    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) { // 注释5
        dest.writeDoubleArray(Arrays.stream(this.components.toArray()).mapToDouble(k -> (double) k).toArray());
    }

    public void update(String componentsString) {
        ArrayList<Double> doubles = getDoublesFromString(componentsString);
        this.components.clear();
        this.components.addAll(doubles);
    }

    public void update(VectorQuantity vectorQuantity) {
        this.components.clear();
        this.components.addAll(vectorQuantity.getComponents());
    }

    public void readFromParcel(Parcel in) { // 注释6
        this.components.clear();
        for (double component :
                Objects.requireNonNull(in.createDoubleArray())) {
            this.components.add(component);
        }
    }
}

进行AIDL通信时，需要对数据进行序列化，我们通过实现Parcelable 接口来实现序列化。

  1. 注释1：实现Parcelable接口；
  2. 注释3、注释4、注释5：实现Parcelable接口中的方法；
  3. 注释6：在AIDL中，如果需要支持out和inout定向标签，还要求添加readFromParcel方法；
  4. 注释2：需要有无参构造器，否则编译时会出错；

5.2.2 服务端代码

服务端代码结构如下：

aidl different application server file structure

5.3.2.1 aidl 文件

下面VectorQuantity.aidl文件，定义VectorQuantity parcelable对象，以供其他AIDL文件使用。

代码2

com/ieening/androidipcserver/vectorquantity/VectorQuantity.aidl

// VectorQuantity.aidl
package com.ieening.androidipcserver.vectorquantity;

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

代码3

com/ieening/androidipcserver/vectorquantity/IVectorQuantityInterface.aidl

// IVectorQuantityInterface.aidl
package com.ieening.androidipcserver.vectorquantity;

// Declare any non-default types here with import statements
import com.ieening.androidipcserver.vectorquantity.VectorQuantity; // 注释1

interface IVectorQuantityInterface {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void updateVectorQuantityIn(in VectorQuantity vectorQuantity); // 注释2
    void updateVectorQuantityOut(out VectorQuantity vectorQuantity); // 注释3
    void updateVectorQuantityInOut(inout VectorQuantity vectorQuantity); // 注释4
}
  1. 注释1：导入VectorQuantity parcelable对象；
  2. 注释2：定义updateVectorQuantityIn方法，注意参数使用in修饰；
  3. 注释3：定义updateVectorQuantityOut方法，注意参数使用out修饰；
  4. 注释4：定义updateVectorQuantityInOut方法，注意参数使用inout修饰；
5.2.2.2 Service 代码

代码4

com.ieening.androidipcserver.vectorquantity.VectorQuantityService

package com.ieening.androidipcserver.vectorquantity;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

import com.ieening.androidipcserver.MainActivity;

public class VectorQuantityService extends Service {
    private final static String TAG = VectorQuantityService.class.getName();

    public static final String UPDATE_EDIT_TEXT_ACTION = "action_update_receive_from_client_edit_text";

    private final IVectorQuantityInterface.Stub iVectorQuantityBinder = new IVectorQuantityInterface.Stub() { // 注释1

        @Override
        public void updateVectorQuantityIn(VectorQuantity vectorQuantity) {
            sendBroadcastToActivity(vectorQuantity, 1);

            Log.d(TAG, "receive from client updateVectorQuantityIn firstVectorQuantity = " + vectorQuantity);
            VectorQuantity newInstance = VectorQuantity.getNewInstance(MainActivity.firstVectorQuantityString);


            if (newInstance.getDimension() > 0) {
                vectorQuantity.update(newInstance);
                Log.d(TAG, "send to client updateVectorQuantityIn firstVectorQuantity = " + vectorQuantity);
            }
        }

        @Override
        public void updateVectorQuantityOut(VectorQuantity vectorQuantity) {
            sendBroadcastToActivity(vectorQuantity, 2);

            Log.d(TAG, "receive from client updateVectorQuantityOut secondVectorQuantity = " + vectorQuantity);
            VectorQuantity newInstance = VectorQuantity.getNewInstance(MainActivity.secondVectorQuantityString);
            if (newInstance.getDimension() > 0) {
                vectorQuantity.update(newInstance);
                Log.d(TAG, "send to client updateVectorQuantityOut secondVectorQuantity = " + vectorQuantity);
            }
        }

        @Override
        public void updateVectorQuantityInOut(VectorQuantity vectorQuantity) {
            sendBroadcastToActivity(vectorQuantity, 3);

            Log.d(TAG, "receive from client updateVectorQuantityOut thirdVectorQuantity = " + vectorQuantity);
            VectorQuantity newInstance = VectorQuantity.getNewInstance(MainActivity.thirdVectorQuantityString);
            if (newInstance.getDimension() > 0) {
                vectorQuantity.update(newInstance);
                Log.d(TAG, "send to client updateVectorQuantityOut thirdVectorQuantity = " + vectorQuantity);
            }
        }
    };

    private void sendBroadcastToActivity(VectorQuantity vectorQuantity, int number) { // 注释3
        Intent activity_intent = new Intent(UPDATE_EDIT_TEXT_ACTION);
        activity_intent.putExtra("number", number);
        activity_intent.putExtra("vector_quantity", vectorQuantity);
        activity_intent.setPackage(getPackageName());
        sendBroadcast(activity_intent);
    }

    public VectorQuantityService() {
    }

    @Override
    public IBinder onBind(Intent intent) { // 注释2
        // TODO: Return the communication channel to the service.
        return iVectorQuantityBinder;
    }
}
  1. 注释1：IVectorQuantityInterface.Stub()实现Stub代码，里面的操作是将客户端传过来的数据通过broadcast传给服务端MainActivity展现，然后进行修改；
  2. 注释2：返回服务端Ibinder；
  3. 注释3：将客户端发送过来的数据通过Broadcast传递给MainActivity；
5.2.2.3 MainActivity 代码

请参考 测试代码–AndroidIPCServer

5.2.3 客户端代码

客户端代码结构如下：

5.2.3.1 aidl 文件和自定义数据类代码

aidl文件和自定义数据类代码可以完全复制服务端代码，包括包名。

5.2.3.2 客户端调用aidl接口文件中定义的方法

代码5

com.ieening.androidipcclient.MainActivity

package com.ieening.androidipcclient;

......
   
import com.ieening.androidipcserver.vectorquantity.IVectorQuantityInterface;
import com.ieening.androidipcserver.vectorquantity.VectorQuantity;

public class MainActivity extends AppCompatActivity {
   private final static String TAG = MainActivity.class.getName();
   private ActivityMainBinding binding;

   private IVectorQuantityInterface vectorQuantityRemote = null;

   private final VectorQuantity firstVectorQuantity = new VectorQuantity(); // 注释1
   private final VectorQuantity secondVectorQuantity = new VectorQuantity();
   private final VectorQuantity thirdVectorQuantity = new VectorQuantity();


   private final ServiceConnection serviceConnection = new ServiceConnection() { // 注释2
       @Override
       public void onServiceConnected(ComponentName name, IBinder service) {
           vectorQuantityRemote = IVectorQuantityInterface.Stub.asInterface(service);
           Log.d(TAG, "executing serviceConnection onServiceConnected");
           changeVectorQuantityButtonsStatus();
       }

       @Override
       public void onServiceDisconnected(ComponentName name) {
           vectorQuantityRemote = null;
           Log.d(TAG, "executing serviceConnection onServiceDisconnected");
           changeVectorQuantityButtonsStatus();
       }
   };

   ......

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       binding = ActivityMainBinding.inflate(getLayoutInflater());
       setContentView(binding.getRoot());

       ......

       setVectorQuantityNumberButtonsOnclickListener();

       ......
   }

  ......

   private void setVectorQuantityNumberButtonsOnclickListener() { // 注释3
       binding.vectorQuantityFirstNumberButton.setOnClickListener(v -> {
           try {
               Log.d(TAG, "send to server updateVectorQuantityIn firstVectorQuantity = " + firstVectorQuantity);
               vectorQuantityRemote.updateVectorQuantityIn(firstVectorQuantity);
               binding.firstNumberReceiveFromServerEditText.setText(firstVectorQuantity.toString());
               Log.d(TAG, "receive from server updateVectorQuantityIn firstVectorQuantity = " + firstVectorQuantity);
           } catch (RemoteException e) {
               e.printStackTrace();
               throw new RuntimeException(e);
           }
       });

       binding.vectorQuantitySecondNumberButton.setOnClickListener(v -> {
           try {
               Log.d(TAG, "send to server updateVectorQuantityOut secondVectorQuantity = " + secondVectorQuantity);
               vectorQuantityRemote.updateVectorQuantityOut(secondVectorQuantity);
               binding.secondNumberReceiveFromServerEditText.setText(secondVectorQuantity.toString());
               Log.d(TAG, "receive from server updateVectorQuantityOut secondVectorQuantity = " + secondVectorQuantity);
           } catch (RemoteException e) {
               e.printStackTrace();
               throw new RuntimeException(e);
           }
       });

       binding.vectorQuantityThirdNumberButton.setOnClickListener(v -> {
           try {
               Log.d(TAG, "send to server updateVectorQuantityInOut thirdVectorQuantity = " + thirdVectorQuantity);
               vectorQuantityRemote.updateVectorQuantityInOut(thirdVectorQuantity);
               binding.thirdNumberReceiveFromServerEditText.setText(thirdVectorQuantity.toString());
               Log.d(TAG, "receive from server updateVectorQuantityInOut thirdVectorQuantity = " + thirdVectorQuantity);
           } catch (RemoteException e) {
               e.printStackTrace();
               throw new RuntimeException(e);
           }
       });
   }

   ......
}
  1. 注释1：三个定向Tag在客户端对应的数据对象；
  2. 注释2：绑定服务端Service的ServiceConnection类；
  3. 注释3：调用aidl接口中的三个方法，将数据传递给服务端，并接收服务端传递过来的数据；

5.3 结果展示

5.3.1 软件界面介绍

aidl_different_application_server_client_ui

5.3.2 操作结果

从结果上看，完全符合4.1.2中预设的实验现象。

5.4 数据流实现细节

AIDL 文件最终生成.java 文件，因此需要在该文件里找答案。

代码6

com.ieening.androidipcserver.vectorquantity.IVectorQuantityInterface

/*
 * This file is auto-generated.  DO NOT MODIFY.
 */
package com.ieening.androidipcserver.vectorquantity;
public interface IVectorQuantityInterface extends android.os.IInterface
{
    ......
    private static class Proxy implements com.ieening.androidipcserver.vectorquantity.IVectorQuantityInterface
    {
        
      ......
          
      /**
       * Demonstrates some basic types that you can use as parameters
       * and return values in AIDL.
       */
      @Override public void updateVectorQuantityIn(com.ieening.androidipcserver.vectorquantity.VectorQuantity vectorQuantity) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          _Parcel.writeTypedObject(_data, vectorQuantity, 0);
          boolean _status = mRemote.transact(Stub.TRANSACTION_updateVectorQuantityIn, _data, _reply, 0);
          _reply.readException();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      @Override public void updateVectorQuantityOut(com.ieening.androidipcserver.vectorquantity.VectorQuantity vectorQuantity) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          boolean _status = mRemote.transact(Stub.TRANSACTION_updateVectorQuantityOut, _data, _reply, 0);
          _reply.readException();
          if ((0!=_reply.readInt())) {
            vectorQuantity.readFromParcel(_reply);
          }
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
      @Override public void updateVectorQuantityInOut(com.ieening.androidipcserver.vectorquantity.VectorQuantity vectorQuantity) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        try {
          _data.writeInterfaceToken(DESCRIPTOR);
          _Parcel.writeTypedObject(_data, vectorQuantity, 0);
          boolean _status = mRemote.transact(Stub.TRANSACTION_updateVectorQuantityInOut, _data, _reply, 0);
          _reply.readException();
          if ((0!=_reply.readInt())) {
            vectorQuantity.readFromParcel(_reply);
          }
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }
      }
    }
    ......
  }
  ......
  /** @hide */
  static class _Parcel {
    static private <T> T readTypedObject(
        android.os.Parcel parcel,
        android.os.Parcelable.Creator<T> c) {
      if (parcel.readInt() != 0) {
          return c.createFromParcel(parcel);
      } else {
          return null;
      }
    }
    static private <T extends android.os.Parcelable> void writeTypedObject(
        android.os.Parcel parcel, T value, int parcelableFlags) {
      if (value != null) {
        parcel.writeInt(1);
        value.writeToParcel(parcel, parcelableFlags);
      } else {
        parcel.writeInt(0);
      }
    }
  }
}

如上代码所示，在Proxy中，

  1. 用in修饰的updateVectorQuantityIn函数中，在执行mRemote.transact之前，会将数据写入（_Parcel.writeTypedObject(_data, vectorQuantity, 0)），但没有将数据读出（vectorQuantity.readFromParcel(_reply)）；
  2. 用out修饰的updateVectorQuantityOut函数中，在执行mRemote.transact之前，不会将数据写入（_Parcel.writeTypedObject(_data, vectorQuantity, 0)），但会将数据读出（vectorQuantity.readFromParcel(_reply)）；
  3. 用inout修饰的updateVectorQuantityInOut函数中，在执行mRemote.transact之前，既有将数据写入（_Parcel.writeTypedObject(_data, vectorQuantity, 0)），也有将数据读出（vectorQuantity.readFromParcel(_reply)）；

测试代码：AndroidIPCClient 和 AndroidIPCServer

那时间总是跑得很潇洒
关注
  • 17
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AIDL实践二：自定义数据类型
luyanjun07的博客
01-20 547
AIDL实践一：自定义类型传递 开发工具： Android Studio 一.编写服务端： 创建项目 在java目录同级下创建aidl文件夹 创建IPersonAidl.aidl文件，文件内容如下： // IAddAidl.aidl package com.lyj.aidldemo2;// Declare any non-default types here with import stateme
AIDL中的数据流向
freelander_j的博客
12-26 634
文章已同步github博客：AIDL中的数据流向 1、AIDL文件 1.1、文件类型 文件后缀名为.aidl； 1.2、数据类型 1.2.1、默认支持类型 默认支持的类型不需要导包； Java八种基本类型：byte、short、int、long、float、double、boolean、char； String类型； CharSequence类型； List类型：List中的所有元素必须是AID...
android aidl 自定义类型 作参数
chuzha4567的博客
08-01 249
遇到的问题是使用数组作为参数和返回值。 找了半天资料， 没有介绍。 最后看了别人的一个程序代码， 原来如此。 问题，实现玩parcelable之后， 还需要在AUDIO_TAG中添加一个类名称的定义才行。 1. 代码结构： 注意选中部分，和内容： 2. 主要的AIDL文件...
【Android】使用Binder（AIDL）实现利用自定义Bean和使用接口进行进程间通信（二）
最新发布
每天不是在写bug就是在写bug的路上
06-19 1247
使用Binder（AIDL）实现利用自定义Bean和使用接口进行进程间通信
AIDL（四）数据传递--自定义类型
lumingzhang的博客
04-30 442
一。以下服务端代码 1.IMyAidlParParcelable.aidl // IMyAidlParParcelable.aidl package com.example.zb.adiltestdemo; import com.example.zb.adiltestdemo.Person; //自定义类型 interface IMyAidlParParcelable { ...
aidl自定义类型
baobao
07-27 273
BtDevice.java [code="java"] package com.example.aidl_service; import android.os.Parcel; import android.os.Parcelable; public class BtDevice implements Parcelable{ private int id; priva...
AIDL自定义类型交互
12-19
该示例实现了AIDL简单通讯，对象通讯的方式，示例代码的博客地址：https://blog.csdn.net/lijianbiao0/article/details/85089474
AIDL 学习Demo，包含定向Tag，序列化信息通讯。
12-01
在标题中提到的“定向Tag”是指在AIDL中定义方法时，可以添加自定义的参数标签。这些标签在实际通信过程中没有直接影响，但可以在日志或者调试过程中帮助识别和跟踪特定的请求，提高开发效率。 **AIDL的序列化信息...
Android AIDL使用详解
qq_31180471的博客
11-14 456
一、概述 AIDL 意思即 Android Interface Definition Language，翻译过来就是Android接口定义语言，是用于定义服务器和客户端通信接口的一种描述语言，可以拿来生成用于IPC的代码。从某种意义上说AIDL其实是一个模板，因为在使用过程中，实际起作用的并不是AIDL文件，而是据此而生成的一个IInterface的实例代码，AIDL其实是为了避免我们重复编写代码而出现的一个模板 设计AIDL这门语言的目的就是为了实现进程间通信。在Android系统中，每个进程都运行在
Android进程间通信-AIDL的使用
weixin_39520007的博客
11-17 446
Android常用的进程通讯方式 进程：一般指一个执行单元，在PC和移动设备上指一个程序或一个应用，一个进程可以包含多个线程。Android系统底层是基于Linux的，每个进程都有自己的虚拟内存空间，因此无法直接操作其他进程的内存空间，但进程间通信（Inter-Process Communication IPC）又是不可避免的，而Android系统为我们提供了这么几种常用方式： Bundle：通过...
Android平台必备技能（一）---进程间通信AIDL的应用详解
格物致知的专栏
12-20 915
一些必备的背景知识，理解以下知识将有助于编写AIDL通信流程。 1. AIDL是什么？ AIDL:Android Interface Definition Language,即Android接口定义语言。即Android平台上使用的IDL交互式数据语言，定义了Android平台IPC的模板。 2. AIDL的语法？ 2.1) AIDL文件以 .aidl 为后缀名； ...
Android AIDL使用介绍（2）自定义数据类型的传递
01-03
1.背景 默认情况下，AIDL只支持下列数据类型： Java八种基础数据类型（如 int、long、char、boolean 等）; String字符串； CharSequence字符序列； List列表，List中的所有元素须是前面提到的数据类型，或者是Parcelable类型（这也是本文准备讲解的）； Map，Map 中的所有元素必须是以上列表中支持的数据类型，或者您所声明的由 AIDL 生成的其他接口或Parcelable 类型； 如果想在进程间传递以上数据类型之外的对象该怎么办？这就需用到Parcelable接口，Parcelable意思是“可包裹的”，是Android系统可用的序列化
Android进阶AIDL使用自定义类型
weixin_34413802的博客
07-15 259
原文首发于微信公众号：jzman-blog，欢迎关注交流！ 阅读本篇文章之前，请先阅读 Android进阶之AIDL的使用详解 这篇文章，上一篇中主要介绍从 AIDL 的使用方式以及 Android 开发中不同进程之间的通信，遗留的问题是如何在 AIDL 中使用自定义类型，具体步骤如下： 创建自定义类型 声明自定义类型 定义与自定义类...
AIDL进程间传递自定义类型参数
Listening_music的专栏
01-29 7521
Aidl默认支持的类型包话java基本类型（int、long、boolean等）和（String、List、Map、CharSequence），如果要传递自定义的类型该如何实现呢？  要传递自定义类型，首先要让自定义类型支持parcelable协议，实现步骤如下：  1>自定义类型必须实现Parcelable接口，并且实现Parcelable接口的public void writeToParc
AIDL接口自定义数据类型及Pracelable接口
hx_wang007的博客
12-12 1734
在AIDL接口中除了可以使用java自带的数据类型外，还可以使用自定义的数据类型。如果需要使用自定义数据类型或List，Map中需要封装自定义数据类型需要以下几个步骤： 1.自定义的数据类型实现Pracelable接口。 2.编写自定义数据类型的.aidl文件 3.无论自定义数据类型与aidl接口源文件是否在一个包中，在接口源文件中使用自定义数据类型时都需要显示的import语句导入。 4
aidl使用_Android进阶之AIDL如何使用自定义类型
weixin_39647787的博客
11-27 524
如何在 AIDL 中使用自定义类型，具体步骤如下：创建自定义类型声明自定义类型定义与自定义类型相关的业务重写业务实体类远程调用验证 AIDL1. 创建自定义类型自定义类型传输的就是一个实体对象，这个实体类必须实现 Parcelable 接口，具体如下：1// 自定义类型2public class Work implements Parcelable {3 private Strin...
Android Service：利用Binder通信中，传递自定义类型
Sunny的小窝
09-09 3666
Android Service：利用Binder通信中，传递自定义类型AIDL中支持的数据类型AIDL中支持的数据类型有： 支持类型 需要import 备注 Java基本类型 不需要import String, CharSequence, List, Map 不需要import List，Map内的元素必须是AIDL支持的类型；List接收方必须是ArrayLis
AIDL中的定向tag
qq_27840621的博客
05-04 640
AIDL中的定向 tag 表示了在跨进程通信中数据的流向，其中 in 表示数据只能由客户端流向服务端， out 表示数据只能由服务端流向客户端，而 inout 则表示数据可在服务端与客户端之间双向流通。其中，数据流向是针对在客户端中的那个传入方法的对象而言的。in 为定向 tag 的话表现为服务端将会接收到一个那个对象的完整数据，但是客户端的那个对象不会因为服务端对传参的修改而发生变动；out
Android AIDL传递包含枚举的自定义类型
wolf0706的专栏
06-15 1535
read和write顺序要对应上，不然会出问题。修改writeToParcel和构造方法。整理了下使用枚举注意事项。自定义类型添加枚举变量。
aidl的定向tag
08-03
回答: 在AIDL语法中，参数列表中的定向tag指的是参数的传递方向。具体含义如下：[1] - in：表示参数是输入参数，即从客户端传递给服务端的数据。 - out：表示参数是输出参数，即从服务端传递给客户端的数据。 - in...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值