Android AIDL的简单应用

最新推荐文章于 2022-01-07 20:30:00 发布
最新推荐文章于 2022-01-07 20:30:00 发布
阅读量450 收藏 1
点赞数
分类专栏： Android基础 文章标签： android aidl 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianzhaoai/article/details/62444413
版权

概要

AIDL(Android Interface Definition Language)，从字面解释来看就是Android接口协议语言。如果是接口协议语言。那么就跟接口脱离不了关系。通过它我们可以定义进程间的通信接口。

什么情况下使用AIDL

你能看到这说明你已经知道AIDL是为了跨进成通信使用的。但是已经有了广播、ContentProvider等都可以进行跨进程通信的方式后还要有AIDL呢？官方文档中有这么一段话：

Note: Using AIDL is necessary only if you allow clients from different applications to access your
 service for IPC and want to handle multithreading in your service. If you do not need to perform 
your interface using a Messenger. Regardless, be sure that you understand Bound Services before implementing an AIDL.

也就是说“只有当你允许来自不同的客户端访问你的服务并且需要处理多线程问题时你才必须使用AIDL“其他情况下你都可以选择其他方法，如使用广播、ContentProvider等都可以。

AIDL的使用

AIDL支持的数据类型

  1. 基本数据类型(int、long、char、boolean、double等)

  2. String和CharSequence

  3. List:只支持ArrayList，里面的每个元素都必须能被AIDL支持

  4. Map:只支持HashMap，里面的每个元素都必须被AIDL支持，包括key和value

  5. Parcelable:所有实现了Parcelable接口的对象

  6. AIDL:所有的AIDL接口本身也可以在AIDL文件中使用

注：自定义的Parcelable对象和AIDL对象必须要显式import进来，尽管在同一个包下也必须显示的import进来

为Model实现序列化Parcelable

只有实现了序列化Parcelable接口的对象，才可以通过AIDL进行跨进成通信。关于序列化这块就不过多赘述了，不是很清楚的可以参考一下这篇文章android开发之Parcelable使用详解

/**
 * Created by Administrator on 2017/3/13.
 * description :
 */

public class Message implements Parcelable {
    private String name ;
    private String msg;

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "\n"+name+ "-说 : "+msg+"\n";
    }

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

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

    public Message() {
    }

    protected Message(Parcel in) {
        this.msg = in.readString();
        this.name = in.readString();
    }

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

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

定义AIDL文件

首先定义Message.aidl

这里说一下，当你新建Message.aidl的时候可能会出现这个错误Interface Name must be unique。对于这个错误，我们可以先新建一个MessageManager.aidl。然后在新建文件Message.aidl。如下

首先通过新建AIDL建立一个MessageManager.aidl

这里写图片描述

然后在通过新建文件建立一个Message.aidl就避免刚才的错误

这里写图片描述

编写AIDL文件

首先编写Message.aidl

这个文件主要就是声明那个对象可以通过AIDL去进行通信

package com.tz.server.aidl;
//注意parcelable前面的p一定要为小写p
parcelable Message;

其次编写MessageManager.aidl

这个文件主要就是进行接口的声明

package com.tz.server.aidl;
//这里一定要import进来，尽管在一个包下也必须import
import com.tz.server.aidl.Message;

interface MessageManager {
     //一下为声明的接口
     List<Message> getMessage();
     boolean addMessage(in Message message);
}

查看生成的MessageManager.java

当两个aidl文件编写完成后，将项目重新Rebuild一下就会在build->generated->source->aidl->debug目录下就可以找到系统自动生成的一个MessageManager.java文件

package com.tz.server.aidl;

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

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

        /**
         * Cast an IBinder object into an com.tz.server.aidl.MessageManager interface,
         * generating a proxy if needed.
         */
        public static com.tz.server.aidl.MessageManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.tz.server.aidl.MessageManager))) {
                return ((com.tz.server.aidl.MessageManager) iin);
            }
            return new com.tz.server.aidl.MessageManager.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_getMessage: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.tz.server.aidl.Message> _result = this.getMessage();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addMessage: {
                    data.enforceInterface(DESCRIPTOR);
                    com.tz.server.aidl.Message _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.tz.server.aidl.Message.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    boolean _result = this.addMessage(_arg0);
                    reply.writeNoException();
                    reply.writeInt(((_result) ? (1) : (0)));
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.tz.server.aidl.MessageManager {
            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.tz.server.aidl.Message> getMessage() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.tz.server.aidl.Message> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getMessage, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.tz.server.aidl.Message.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public boolean addMessage(com.tz.server.aidl.Message message) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                boolean _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((message != null)) {
                        _data.writeInt(1);
                        message.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addMessage, _data, _reply, 0);
                    _reply.readException();
                    _result = (0 != _reply.readInt());
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }
        }

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

    public java.util.List<com.tz.server.aidl.Message> getMessage() throws android.os.RemoteException;

    public boolean addMessage(com.tz.server.aidl.Message message) throws android.os.RemoteException;
}

编写MessageService文件

在这里主要实现了MessageManager中的一个抽象类Stub。主要实现了getMessage()方法和addMessage()方法

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteException;

import com.tz.server.aidl.Message;
import com.tz.server.aidl.MessageManager;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Created by Administrator on 2017/3/13.
 * description :
 */

public class MessageService extends Service {
    private CopyOnWriteArrayList<Message> msgList = new CopyOnWriteArrayList<Message>();

    public MessageService() {

    }

    Binder binder = new MessageManager.Stub() {

        @Override
        public List<Message> getMessage() throws RemoteException {
            return msgList;
        }

        @Override
        public boolean addMessage(Message message) throws RemoteException {
            return msgList.add(message);
        }
    };

    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Message msg = new Message();
        msg.setName("Service");
        msg.setMsg("我是服务端");
        msgList.add(msg);
    }
}

Service中使用的CopyOnWriteArrayList是CopyOnWrite容器即写时复制的容器，通俗的理解是当往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

在MainActivity中bindService

如果是在5.0以上的Android系统中使用BindService时，一定要给启动Service的Intent使用setPackage方法才可以成功绑定服务

public class MainActivity extends AppCompatActivity {
    //由AIDL文件生成的Java类
    private MessageManager mMessageManager = null;

    //标志当前与服务端连接状况的布尔值，false为未连接，true为连接中
    private boolean mBound = false;

    //包含Book对象的list
    private List<Message> mMessages;

    TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);
    }

    private int count = 1;
    /**
     * 按钮的点击事件，点击之后调用服务端的addBookIn方法
     *
     * @param view
     */
    public void addMessage(View view) {
        //如果与服务端的连接处于未连接状态，则尝试连接
        if (!mBound) {
            attemptToBindService();
            Toast.makeText(this, "当前与服务端处于未连接状态，正在尝试重连，请稍后再试", Toast.LENGTH_SHORT).show();
            return;
        }
        if (mMessageManager == null)
            return;

        Message book = new Message();
        book.setName("服务端 : ");
        book.setMsg("消息"+count);
        try {
            mMessageManager.addMessage(book);
            tv.setText(mMessages.toString());
            Log.e("hypertian", getLocalClassName() + " : "+ book.toString());
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    /**
     * 尝试与服务端建立连接
     */
    private void attemptToBindService() {
        Intent intent = new Intent();
        intent.setAction("com.tz.server.service.MessageService");
        intent.setPackage("com.tz.server");
        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.e("hypertian", getLocalClassName() + " : service connected");
            mMessageManager = MessageManager.Stub.asInterface(service);
            mBound = true;

            if (mMessageManager != null) {
                try {
                    mMessages = mMessageManager.getMessage();
                    tv.setText(mMessages.toString());
                    Log.e("hypertian", getLocalClassName() + " : "+ mMessages.toString());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("hypertian", getLocalClassName() + " : service disconnected");
            mBound = false;
        }
    };
}

实现效果

这里写图片描述

源码下载

xyTianZhao
关注
专栏目录
Android AIDL 教程 (一）—— 简单的示例
feifei99_8820的博客
04-21 639
针对于上面的问题，我总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料。（包括Java在Android开发中应用、APP框架知识体系、高级UI、全方位性能调优，NDK开发，音视频技术，人工智能技术，跨平台技术等技术资料），希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！（备注：Android）**
android AIDL 应用
u010897392的专栏
04-08 513
在Android中，每个应用程序都有自己的进程，当需要在不同的进程之间传递对象时，该如何实现呢？显然，Java中是不支持跨进程内存共享的，因此要传递对象，需要把对象解析成操作系统能够理解的数据格式，以达到跨界对象访问的目的。在Android中，则采用AIDL(Android Interface Definition Language ：接口定义语言)方式实现。 AIDL (Andro
Android AIDL的应用
一分耕耘,一分收获!
01-08 580
前不久项目需要用到aidl技术，所以花了一天的时间去研究了哈，所以现在记录下来，怕自己忘记，网上关于aidl的demo也没看见几个，所以写个demo供大家参考参考，一起学习学习。 分几个部分讲吧 1.什么是aidl？ aidl英文全称Android interface definition language，通过英文名可知道是Android内部通信描述语言，通过它我们可以定义进程间的通信接口
android开发步步为营之62:进程间通信之Aidl
飞在江湖的专栏
06-09 798
android进程之间通信，比如一个app和另外一个app交互，有哪几种方式，主要有1、activity的跳转 2、contentprovider 3、broadcast 4、aidl，个人认为前面3种相对简单，应用场景也不一样。本文研究一下使用aidl进行进程之间的通信。 aidl全称是Android Interface Definition Language，即接
AIDL在android系统中的作用
weixin_30758821的博客
01-16 223
AIDL，Android Interface definition language的缩写,它是一种android内部进程通信接口的描述语言,通过它我们可以定义进程间的通信接口。最近看了下AIDL在Android系统中的用法，在网上看到很多初学的朋友不太明白AIDL的实际作用，android提供了很多进程间通信的组件，像action、broadcast、contentprovide都可以...
java 自定义类 模拟实现消息队列 消费发送功能
napcleon1的博客
04-09 768
mq 消息队列对于每个开发人员并不陌生，消息队列实现了解耦 ，提高运行效率 保证系统稳定。但又存在 数据一致性等其他问题。这些问题都有了解决方案。也不是本篇讨论的问题。 我写的模拟消息队列功能 适用于以下场景 1、有些项目虽然用到了 mq 开发周期比较短 。或者公司因为成本问题 提供的服务器比较少，配置低。也行只是做个POC 不需要做那么专业。 2、有时候尽管你 各种第三方工具（kafka red...
AndroidAIDL
12-07
**Android AIDL（Android Interface Definition Language）详解** 在Android系统中，进程间的通信（IPC, Inter-Process Communication）是...掌握AIDL的使用，对于开发大型的、需要多进程协作的Android应用至关重要。
一个应用启动另一个应用，实现应用间通讯，用bundle就行了，Android aidl简单demo 实现ipc通讯。
01-20
总结来说，Android应用间通信可以通过多种方式实现，如使用`Intent`和`Bundle`传递简单数据，以及利用`AIDL`进行更复杂的进程间通信。在设计跨进程通信方案时，应根据实际需求选择合适的方法，确保数据的安全性和...
AndroidStudio使用AIDL简单完成IPC
11-05
在Android系统中，进程间通信（IPC，Inter-Process Communication）是实现不同应用程序之间数据交换的关键技术。...在实际开发中，理解并熟练掌握AIDL对于提升Android应用的性能和稳定性至关重要。
Android Aidl的简单demo
最新发布
11-17
这个简单的Aidl demo展示了如何在Android应用中使用Aidl进行跨进程通信。服务端提供了接口，客户端可以调用这些接口，实现数据传递和功能交互。在实际项目中，Aidl常用于实现复杂的服务间通信，比如音乐播放器应用中...
项目框架——消息分发系统【MessageManager】
zixue19911216的专栏
06-16 2351
首先这个消息分发系统是一个继承于Mono单例模式的，所以他也是一个单例内容，使用起来很简单，只需要知道以下几点即可。 第一，单例记得添加； 第二，添加消息监听； 第三，分发消息； 一共就这三个内容，第一点没有什么好说的，单例模式，添加在场景当中就好了，关于单例模式的内容，可以参考【项目框架——单例模式】进行详细的了解。主要是接下来的第二和第三点。 添加消息监听之前，我们来看看消息监听函数类。 ...
Android AIDL 使用教程
热门推荐
hello_1995的博客
01-07 3万+
AIDL（Android Interface Definition Language）是一种 IDL 语言，用于生成可以在 Android 设备上两个进程之间进行进程间通信（IPC）的代码。 通过 AIDL，可以在一个进程中获取另一个进程的数据和调用其暴露出来的方法，从而满足进程间通信的需求。通常，暴露方法给其他应用进行调用的应用称为服务端，调用其他应用的方法的应用称为客户端，客户端通过绑定服务端的 Service 来进行交互。...
Android AIDL使用过程
于大博
08-14 3232
服务端： 1.在Android Studio中 src目录上右键创建一个AIDL文件 并命名，完成后会再main下自动生成一个aidl目录，该目录的包名和java下的包名是一致的。 创建完成后样式如下图所示： 每次生成的.aidl文件后我们需要build一下才能让系统生成自后我们能使用文件。因为在进程间通信中真正起作用的并不是 AIDL 文件，而是系统据此而生成的文件，在Androi...
AIDL解析（一）两个应用之间使用AIDL进行通信的例子
weifeng的博客
03-02 7616
IPC(Inter-Process Communication) ：指进程间通信 ，指至少两个进程或线程间传送数据或信号的一些技术或方法 桌面应用Launcher是用Binder IPC启动应用，而进程与进程之间的交流，就是使用AIDL了。不单单是进程与进程之间可以用AIDL，Service和组件之间不但可以用Messenger来通信，也可以用AIDL来通信。使用Messenger更简单，核心是
Android中AIDL及其使用
你是我眼中最亮的星
09-20 477
1、为什么要有AIDL？ 无论学什么东西，最先得弄明白为什么要有这个东西，不要说存在即是合理，存在肯定合理，但是你还是没有明白。对于AIDL有一些人的浅显概念就是，AIDL可以跨进程访问其他应用程序，和其他应用程序通讯，那我告诉你，很多技术都可以访问，如广播（应用A在AndroidManifest.xml中注册指定Action的广播）应用B发送指定Action的广播，A就能收到信息，这样也能看成
Android中AIDL的使用(一) 之 AIDL经典示例
子云心的博客
10-15 1979
在Android开发中IPC（Inter-Process Communication的缩写）多进程通信的使用场景很多。一般地由于某些功能模块需要特殊原因运行在单独的进程中，又或者为了加大一个应用可使用的内存，因为Android对单个应用使用的最大内存是有限制的，又或者需要做一些非常耗内存而又不好回收的事情，在事情完成后直接结束掉进程，等。开启多进程模式很简单，就是给四大组件指定android:pr...
android aidl的使用及demo
u010672559的博客
08-17 2990
demo下载地址 https://download.csdn.net/download/u010672559/10610856 ---------- 概述：AIDL即跨进程通信  1.在main下面新建aidl文件 // IMyAidlInterface.aidl package com.android.aidl; // Declare any non-default types her...
Android采用AIDL实现两个应用间通信
Kai的博客
04-22 4651
Android采用AIDL实现两个应用间通信一、前言二、代码实现1、Service端2、Client端 一、前言 作为Android中实现进程间通信的一种方法，AIDL可以很方便的完成这项工作。正如AIDL的名字一样，只需定义一套客户端和服务端交互的接口即可。如需要传递数据的类型为非基本数据类型，需要先将非基本数据类型进行序列化操作。 而在很多实际情况下，客户端与服务端并不在一个应用中，他们作为两...
Android自定义键盘的简单实现
xyTianZhao
03-20 2万+
自定义键盘的简单实现概述突然发现好多软件都使用了自己定义的软键盘。自己就想着先把这块坑先踩踩把，以后掉坑的时候不至于帅的太惨。言归正传，对于自定义软键盘。需要用到系统提供的两个类：Keyboard和KeyboardView。Keyboard设计键盘的布局文件，官方上对Keyboard是这么解释的Loads an XML description of a keyboard and stores the
Android AIDL：实现实应用间高效通信
AIDL是Android系统提供的一个简单而强大的机制，它允许不同组件之间进行跨进程通信。当客户端app（如client）需要与服务端app（如orderManager）交换数据或者请求服务时，AIDL能够创建一个接口，使得双方能像操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值