Android之IPC2————AIDL

其他 2019-01-08 03:24:03 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_38499859/article/details/83628496

Android之IPC2————AIDL

文章目录

一.AIDL概述

在上一篇博客中，我们讨论Service绑定时，所用的三种方法，即扩展的binder类，Messenger类，还有AIDL，上一章博客中当时我们只是简单的介绍了一下。在这里我们就详细的来看一看。

1.AIDL是什么

AIDL即Android接口定义语言，是IDL语言的一种。主要用来定义跨进程通信时都让双方都认可的编程接口。

IDL是Interface description language的缩写，指接口描述语言.IDL通常用于远程调用软件。在这种情况下，一般是由远程客户终端调用不同操作系统上的对象组件，并且这些对象组件可能是由不同计算机语言编写的。IDL建立起了两个不同操作系统间通信的桥梁。

2.使用场景

在Android中，一个进程通常无法访问另一个进程的内存，所以进程需要将其对象分解成操作系统可以识别的原语，并将对象编组成可以跨界.所以在Android中，它常常被用来进行跨进程通信。

3.一些语法

在使用AIDL语言时，需要创建一个.aidl文件，此时AndroidSDK工具都会生成一个.aidl文件的IBinder接口，并且其报存在gen/目录中，Service视情况实现IBinder接口。然后将客户端与Service进行绑定，此时就可以调用IBindr的方法来执行IPC。

创建AIDL时，可以通过可带参数和返回值的一个或多个方法来声明接口。参数和返回值可以时任意类型，甚至可以是其他AIDL生成的接口

默认情况下，AIDL支持下列数据类似：

  • JAVA中所有原语类型(如int,long,char,boolean等等)
  • String
  • CharSequence
  • List：List中所有元素都必须是以上列表支持的数据类型，或者其他AIDL生成的接口或者声明的可打包类型。
  • Map：同List一样，他也要求所有元素都必须是以上列表支持的数据类型，或者其他AIDL生成的接口或者声明的可打包类型。

对于不是默认数据的类型，应该使其实现Parcelable接口，并编写对应的AIDL文件。

定义接口时，注意：

  • 方法可以带零个或者多个参数，返回值或者NULl
  • 所有原语参数都需要指示数据走向方向标记，可以是in，out或者inout，原语默认是in,慎用inout参数，它会导致系统开销非常大。
  • aidl 文件中包括的所有代码注释都包含在生成的 IBinder 接口中（import 和 package 语句之前的注释除外）
  • 只客户端调用其中的方法，不支持调用其中的AIDL 中的静态字段。

二.AIDL实现跨进程通信

将一个Book类，在不同进程的客户端和服务中进行传递。

因为Book类并不默认类型，所以首先让它实现Parcelable接口(序列化)

关于序列化的问题，下一篇博客中进行分析。

1.Book实现 Parcelable 接口

创建一个Book类，建立getter和setter

public class Book {

    private String name;
    private int price;

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "书名:"+name +",价格"+price;
    }

    public Book() {
    }

}

让其继承 Parcelable 接口，并根据AS的错误提醒，自动补全。或者自己手动补全。

public class Book implements Parcelable {

    private String name;
    private int price;

    public String getName() {
        return name;
    }

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

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "书名:"+name +",价格"+price;
    }

    public Book() {
    }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(price);
    }

    protected Book(Parcel in) {
        name = in.readString();
        price = in.readInt();
    }

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

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

2.生成AIDL文件

前面我们说过，因为Book类不是默认类型，所以也要生成关于Book类的AIDL文件。

鼠标移到app上面去，点击右键，然后 new->AIDL->AIDL File，按下鼠标左键就会弹出一个框提示生成AIDL文件了。此时在java包层级下，多了一个aidl文件夹，在里面就可以新建aidl文件。

Book.aidl文件

// Book.aidl
//这个文件的作用是引入了一个序列化对象 Book 供其他的AIDL文件使用
//注意：Book.aidl与Book.java的包名应当是一样的

package com.heshucheng.servicedemo;

//注意parcelable是小写
parcelable Book;

BookManager.aidl文件

// BookManager.aidl
//作用是定义方法接口

package com.heshucheng.servicedemo;
//导入所需要使用的非默认支持数据类型的包
import com.heshucheng.servicedemo.Book;
// Declare any non-default types here with import statements

interface  BookManager{

 //所有的返回值前都不需要加任何东西，不管是什么数据类型
   List<Book> getBooks();
   //传参时除了Java基本类型以及String，CharSequence之外的类型
   //都需要在前面加上定向tag，具体加什么量需而定
   void addBook(in Book book);

}

在BookManager中，定义了两个接口，一个活的书的list，一个是添加书。

3.在Service中实现相关的接口

在AIDL的使用场景中经常在多次线程的情景下被调用，所以要考虑线程安全问题。同时完成请求的时间不止几毫秒，尽量避免在主线程中调用相关的接口。

public class AIDLService extends Service {

    private static final String TAG = "AIDLService";

    //包含Book对象的List
    private List<Book> mBooks = new ArrayList<>();

    //由AIDL文件生成的BookManager
    private final BookManager.Stub mBookManager = new BookManager.Stub() {
        @Override
        public List<Book> getBooks() throws RemoteException { //实现对应的接口
            synchronized (this) {  //确保线程安全
                Log.w(TAG, "getBooks: " + mBooks.toString());
                if (mBooks != null){
                    return mBooks;
                }
                return new ArrayList<>();
            }

        }

        @Override
        public void addBook(Book book) throws RemoteException {//实现对应的接口
            synchronized (this){ //确保线程安全
                if (mBooks == null){
                    mBooks = new ArrayList<>();
                }

                if (book == null){
                    Log.w(TAG, "addBook: " );
                    book = new Book();
                }

                //尝试修改book的参数，主要是为了观察其客户端的反馈
                book.setPrice(2333);
                if (!mBooks.contains(book)){
                    mBooks.add(book);
                }

                //打印mBooks列表，观察客户端传过来的值
                Log.w(TAG, "addBook: "+mBooks.toString());
            }
        }
    };

    public AIDLService() {

    }

    @Override
    public void onCreate() {
        super.onCreate();
        Book book = new Book();
        book.setName("Android艺术开发探索");
        book.setPrice(28);
        mBooks.add(book);
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.w(TAG, "onBind: " +intent.toString());
        return mBookManager;
    }
}

在Service中，实现相关的接口，同时确保线程安全，并在onBind类中将对于的BookManager传第过去

4.在客户端中调用相关的接口

注意，如果接口完成的时间不止几毫秒，尽量避免在主线程中调用相关的接口。

public class AIDLActivity extends AppCompatActivity {

    private static final String TAG = "AIDLActivity";
    //由AIDL文件生成的Java类
    private BookManager mBookManager = null;

    //标志当前与服务端连接状况的情况
    private boolean mBound = false;

    private List<Book> mBooks;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_aidl);
    }

    //按钮的点击事件
    public void addBook(View view){
        if(!mBound){
            attemptToBindService();
            Toast.makeText(this,"当前与服务端处于未连接状态，正在尝试重连，请稍后再试", Toast.LENGTH_SHORT).show();
            return;
        }

        if (mBookManager == null)
            return;

        Book book = new Book();
        book.setName("App研发录");
        book.setPrice(30);

        try {
            mBookManager.addBook(book); //调用对应的接口
            Log.w(TAG, "addBook: "+book.toString());
        }catch (RemoteException e){
            e.printStackTrace();
        }
    }

    /**
     * 尝试与服务端建立连接
     */
    private void attemptToBindService(){
        Intent intent = new  Intent();

        intent.setAction("com.heshucheng.aidl");
        intent.setPackage("com.heshucheng.servicedemo");
        bindService(intent,mServiceConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStart() {
        super.onStart();
        if(!mBound){
            attemptToBindService();
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        if(mBound){
            unbindService( mServiceConnection);
            mBound =false;
        }
    }

    //绑定接口
    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.w(TAG, "绑定成功" );
            mBookManager = BookManager.Stub.asInterface(service);
            mBound = true;

            if (mBookManager !=null){
                try {
                    mBooks = mBookManager.getBooks();//调用接口
                    Log.w(TAG,"获取成功"+mBooks.toString());
                }catch (RemoteException e){
                    e.printStackTrace();
                }
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e(TAG, "连接中断");
            mBound = false;
        }
    };
}

在Activity中调用对应的接口。

5.运行结果

客户端
在这里插入图片描述

服务端
在这里插入图片描述

三.AIDL生成Binder类分析

在上面的代码中，我们发现，在客户端和服务端中都没有出现aidl文件，但依然通过BookManager完成相应的工作，而它就是aidl生成的java文件，它的完整路径在app->build->generated->source->aidl->debug->com->包名->BookManager.java

在上文中，我们在Service中实现相应的接口，并将其传递给客户端，在客户端中直接调用相关的接口。好像并没有关于进程方面的操作，但两个不同进程的相互调用，肯定需要进行IPC,那这一部分在哪实现的？

答案就是在BookManager.java中。

1.asInterface

我们在获得BookManager类时，是通过这个语句

 mBookManager = BookManager.Stub.asInterface(service);

通过asIbterface获得BookManager。我们进入asInterface方法中。

         /**
         * Cast an IBinder object into an com.heshucheng.servicedemo.BookManager interface,
         * generating a proxy if needed.
         *将IBinder对象转换为BookManager接口，根据需要生成代理。
         */
        public static com.heshucheng.servicedemo.BookManager asInterface(android.os.IBinder obj) {
            //判断是否为空
            if ((obj == null)) {
                return null;
            }

            //搜索本地是否有可用对象，如果有就将其返回
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.heshucheng.servicedemo.BookManager))) {
                return ((com.heshucheng.servicedemo.BookManager) iin);
            }

            //如果没有，就新建一个
            return new com.heshucheng.servicedemo.BookManager.Stub.Proxy(obj);
        }

在上面的代码中，首先先进行了判空，然后调用了 queryLocalInterface() 方法，这个方法是 IBinder 接口里面的一个方法，它具体的源码涉及到IBinder相关内容，我们暂且不去深究。只说明它的作用，它就是去本地搜索是否有可以的对象

当本地没有BookManager对象时。会去通过Proxy来获得一个BookManager对象。让我们继续来看Proxy中的源码

2.proxy

        private static class Proxy implements com.heshucheng.servicedemo.BookManager {
            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.util.List<com.heshucheng.servicedemo.Book> getBooks() throws android.os.RemoteException {
                //_data存心客户端流向服务的数据流
                //_reply存储服务流向客户端的数据流
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.heshucheng.servicedemo.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);

                    //调用transact() 方法将方法id和两个 Parcel 容器传过去Service
                    mRemote.transact(Stub.TRANSACTION_getBooks, _data, _reply, 0);
                    _reply.readException();
                    //从_reply取出结果
                    _result = _reply.createTypedArrayList(com.heshucheng.servicedemo.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public void addBook(com.heshucheng.servicedemo.Book book) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((book != null)) {
                        //book存入
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    //调用transact() 方法将方法id和两个 Parcel 容器传给Service
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

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

说明：

  • 关于 Parcel ：简单的来说，Parcel 是一个用来存放和读取数据的容器。我们可以用它来进行客户端和服务端之间的数据传输，当然，它能传输的只能是可序列化的数据。具体 Parcel 的使用方法和相关原理可以参见这篇文章Android中Parcel的分析以及使用
  • 关于 transact() 方法：这是客户端和服务器端通信的核心方法。调用这个方法之后，客户端会挂起当前线程，等待服务端执行完先关任务后通知并接受返回的 _reply 数据流。
  • transact()第一个参数，是方法ID，这个是客户端和服务器端约定好的给方法特殊编码，彼此一一对应，在AIDL文件转化为java文件的时候，系统会自动给AIDL每一个方法自动分配一个方法ID
  • transact()第四个参数是一个int值，他的作用是设置IPC的模式，为0表示数据可以双向流动，即reply 流可以正常的携带数据回来，如果为 1 的话那么数据将只能单向流通，从服务端回来的 _reply 流将不携带任何数据。在AIDL生成的java文件里，这个参数均为0.
  • 关于transact()设计到了Binder机制比较低层的东西，博主没有太深的研究，所以就直接借用别的结论。

总结一下Proxy类方法的一般工作流程

  • 生成_data和_reply数据流，并向_data中存入客户端的数据
  • 通过transact() 方法将它们传递给服务端，并请求服务端调用指定方法。
  • 接收_reoly数据流，并从中取出服务端传回的数据

3.onTransact

在前面说了客户端通过transact() 方法将数据和请求发送过去，那么很显然，在服务端也应该有个方法来接收这些传过来的东西：在 BookManager.java 里面我们可以很轻易的找到一个叫做 onTransact() 的方法——看这名字就知道，多半和它脱不了关系，再一看它的传参 (int code, android.os.Parcel data, android.os.Parcel reply, int flags) ——和 transact() 方法的传参是一样的。所以 onTransact和transac之间肯定有很大联系，我们来看其代码

        @Override
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(DESCRIPTOR);
                    return true;
                }
                case TRANSACTION_getBooks: {
                    data.enforceInterface(DESCRIPTOR);
                    //调用 this.getBooks() 方法，在这里开始执行具体的事务逻辑
                    //此时result调用 getBooks() 方法的返回值
                    java.util.List<com.heshucheng.servicedemo.Book> _result = this.getBooks();
                    reply.writeNoException();
                    //将方法执行的结果写入 reply
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.heshucheng.servicedemo.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.heshucheng.servicedemo.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

在 onTransact先进行switch选择，之后根剧不同的方法进入不同的分支，在分支中，获得客户端的参数，并服务的实现的方法，井参数传入，最后将返回值写入reply 流。

总结服务端的流程：

  • 获取客户端传过来的数据，根剧方法ID执行相应的操作
  • 将传过来的数据取出，调用本地对应的方法
  • 将需要的数据写入reply流，传回客户端。

5.全部代码

public interface BookManager extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.heshucheng.servicedemo.BookManager {
        private static final java.lang.String DESCRIPTOR = "com.heshucheng.servicedemo.BookManager";

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

        /**
         * Cast an IBinder object into an com.heshucheng.servicedemo.BookManager interface,
         * generating a proxy if needed.
         */
        public static com.heshucheng.servicedemo.BookManager asInterface(android.os.IBinder obj) {
            //判断是否为空
            if ((obj == null)) {
                return null;
            }

            //搜索本地是否有可用对象，如果有就将其返回
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.heshucheng.servicedemo.BookManager))) {
                return ((com.heshucheng.servicedemo.BookManager) iin);
            }

            //如果没有，就新建一个
            return new com.heshucheng.servicedemo.BookManager.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 {
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(DESCRIPTOR);
                    return true;
                }
                case TRANSACTION_getBooks: {
                    data.enforceInterface(DESCRIPTOR);
                    //调用 this.getBooks() 方法，在这里开始执行具体的事务逻辑
                    //此时result调用 getBooks() 方法的返回值
                    java.util.List<com.heshucheng.servicedemo.Book> _result = this.getBooks();
                    reply.writeNoException();
                    //将方法执行的结果写入 reply
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.heshucheng.servicedemo.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.heshucheng.servicedemo.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.heshucheng.servicedemo.BookManager {
            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.util.List<com.heshucheng.servicedemo.Book> getBooks() throws android.os.RemoteException {
                //_data存心客户端流向服务的数据流
                //_reply存储服务流向客户端的数据流
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.heshucheng.servicedemo.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);

                    //调用transact() 方法将方法id和两个 Parcel 容器传过去Service
                    mRemote.transact(Stub.TRANSACTION_getBooks, _data, _reply, 0);
                    _reply.readException();
                    //从_reply取出结果
                    _result = _reply.createTypedArrayList(com.heshucheng.servicedemo.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public void addBook(com.heshucheng.servicedemo.Book book) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((book != null)) {
                        //book存入
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    //调用transact() 方法将方法id和两个 Parcel 容器传给Service
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

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


    public java.util.List<com.heshucheng.servicedemo.Book> getBooks() throws android.os.RemoteException;
    public void addBook(com.heshucheng.servicedemo.Book book) throws android.os.RemoteException;
}

6.示意图

通过上面的分析，我们大致明白的AIDL的过程，我们可以发现我们完全可以不使用AIDL文件提供的Binder文件，可以实际实现Binder。下图就是AIDL生成的Binder的工作过程

在这里插入图片描述

四.参考资料

android艺术开发探索
AIDL官方文档
Android：学习AIDL，这一篇文章就够了(上)
Android：学习AIDL，这一篇文章就够了(下)

猜你喜欢

转载自blog.csdn.net/qq_38499859/article/details/83628496
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022