Android IPC（三）AIDL实现跨进程通信

最新推荐文章于 2023-07-12 15:25:58 发布
最新推荐文章于 2023-07-12 15:25:58 发布
阅读量1k 收藏
点赞数 4
分类专栏： Android 永无止境 文章标签： android IPC通信 AIDL 王睿丶 跨进程通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27494201/article/details/120474812
版权

文章目录

上一篇：Android IPC（二）Messenger实现跨进程双向通信
下一篇：《Android IPC（四）》，望支持加快更新！

AIDL实现连接服务

在这里插入图片描述

AIDL实现消息服务（客户端→服务端）

在这里插入图片描述

AIDL实现消息服务（服务端→客户端）

在这里插入图片描述

Demo结构：

大家学习的时候注意要对应上我的Demo结构路径，否则会出现找不到文件的问题，如果你对AIDL文件很熟悉的话，路径可以随自己喜欢选择。
在这里插入图片描述

中间的 IConnectionService、IMessageService等等这块区域的代码是在Android Studio编译时自动生成的

MyBean.aidl

package com.jlink.aidldemo.entity;

//对应java 中的MyBean
parcelable MyBean;

IConnectionService.aidl

package com.jlink.aidldemo;

//连接服务
interface IConnectionService {
    //连接
    oneway void connect();
    //取消连接
    void disconnect();
    //连接状态
    boolean isConnected();
}

IMessageService.aidl

// IMessageService.aidl
package com.jlink.aidldemo;
import com.jlink.aidldemo.entity.MyBean;
import com.jlink.aidldemo.MessageReceiveListener;

//消息服务
interface IMessageService {
    //发送消息
    void sendMessage(in MyBean myBean);
    //注册消息接收监听器
    void registerMessageReceiveListener(MessageReceiveListener messageReceiveListener);
    //取消注册消息接收监听器
    void unRegisterMessageReceiveListener(MessageReceiveListener messageReceiveListener);
}

IServiceManager.aidl

package com.jlink.aidldemo;

interface IServiceManager {
    IBinder getService(String serviceName);
}

MessageReceiveListener.aidl

// MessageReceiveListener.aidl
package com.jlink.aidldemo;
import com.jlink.aidldemo.entity.MyBean;

//消息监听器
interface MessageReceiveListener {
    void onReceiveMessage(in MyBean myBean);
}

MyBean.java

public class MyBean implements android.os.Parcelable{
    private String content; //内容
    private boolean isSendSuccess;  //状态
    public MyBean(){

    }

    protected MyBean(Parcel in) {
        content = in.readString();
        isSendSuccess = in.readByte() != 0;
    }

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

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

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(content);
        dest.writeByte((byte) (isSendSuccess ? 1 : 0));
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public boolean isSendSuccess() {
        return isSendSuccess;
    }

    public void setSendSuccess(boolean sendSuccess) {
        isSendSuccess = sendSuccess;
    }
}

MyService.java

public class MyService extends Service {
    private int num = 0;
    public MyService(){

    }

    //RemoteCallbackList 存储 消息监听器
    private RemoteCallbackList<MessageReceiveListener> messageReceiveListenerRemoteCallbackList = new RemoteCallbackList<>();
    //创建计时器
    private ScheduledThreadPoolExecutor scheduledThreadPoolExecutor;
    //用来注销计时器
    private ScheduledFuture scheduledFuture;

    @Override
    public void onCreate() {
        super.onCreate();
        scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
    }

    private Handler handler = new Handler(Looper.getMainLooper());
    private boolean isConnected = false;

    private IConnectionService connectionService = new IConnectionService.Stub() {
        @Override
        public void connect() throws RemoteException {
            isConnected = true;
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(MyService.this,"连接成功",Toast.LENGTH_SHORT).show();
                }
            });

            scheduledFuture = scheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    int size = messageReceiveListenerRemoteCallbackList.beginBroadcast();
                    num++;
                    for (int i=0; i<size; i++){
                        MyBean myBean = new MyBean();
                        myBean.setContent("喷火龙怒气值：" + num);
                        try {
                            //服务端 → 客户端
                            messageReceiveListenerRemoteCallbackList.getBroadcastItem(i).onReceiveMessage(myBean);
                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
                    }
                    messageReceiveListenerRemoteCallbackList.finishBroadcast();
                }
            },2000,2000, TimeUnit.MILLISECONDS);

        }

        @Override
        public void disconnect() throws RemoteException {
            isConnected = false;
            //删除计时器
            scheduledFuture.cancel(true);
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(MyService.this,"断开连接",Toast.LENGTH_SHORT).show();
                }
            });
        }

        @Override
        public boolean isConnected() throws RemoteException {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(MyService.this,String.valueOf(isConnected),Toast.LENGTH_SHORT).show();
                }
            });
            return isConnected;
        }
    };

    private IMessageService messageService = new IMessageService.Stub() {
        @Override
        public void sendMessage(MyBean myBean) throws RemoteException {
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(MyService.this,String.valueOf(myBean.getContent()),Toast.LENGTH_SHORT).show();
                }
            });

            if (isConnected){
                myBean.setSendSuccess(true);
            }else{
                myBean.setSendSuccess(false);
            }
        }

        @Override
        public void registerMessageReceiveListener(MessageReceiveListener messageReceiveListener) throws RemoteException {
            if (messageReceiveListener != null){
                messageReceiveListenerRemoteCallbackList.register(messageReceiveListener);
            }
        }

        @Override
        public void unRegisterMessageReceiveListener(MessageReceiveListener messageReceiveListener) throws RemoteException {
            if (messageReceiveListener != null){
                messageReceiveListenerRemoteCallbackList.unregister(messageReceiveListener);
            }
        }
    };

    private IServiceManager serviceManager = new IServiceManager.Stub() {
        @Override
        public IBinder getService(String serviceName) throws RemoteException {
            if (IConnectionService.class.getSimpleName().equals(serviceName)){
                return connectionService.asBinder();
            }else if (IMessageService.class.getSimpleName().equals(serviceName)){
                return messageService.asBinder();
            }else {
                return null;
            }
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return serviceManager.asBinder();
    }
}

MainActivity.java

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private Button btnConnect,btnDisConnect,btnIsConnect;
    private Button btnSendMessage,btnRegisterListener,btnUnregisterListener;
    private IConnectionService connectionServiceProxy;
    private IMessageService messageServiceProxy;
    private IServiceManager serviceManagerProxy;

    //监听器的实现
    private MessageReceiveListener messageReceiveListener = new MessageReceiveListener.Stub() {
        @Override
        public void onReceiveMessage(MyBean myBean) throws RemoteException {
            new Handler(Looper.getMainLooper()).post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(MainActivity.this,myBean.getContent(),Toast.LENGTH_SHORT).show();
                }
            });
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
        Intent intent = new Intent(MainActivity.this,MyService.class);
        bindService(intent, new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder iBinder) {
                try {
                    serviceManagerProxy = IServiceManager.Stub.asInterface(iBinder);
                    connectionServiceProxy = IConnectionService.Stub.asInterface(serviceManagerProxy.getService(IConnectionService.class.getSimpleName()));
                    messageServiceProxy = IMessageService.Stub.asInterface(serviceManagerProxy.getService(IMessageService.class.getSimpleName()));
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        }, Context.BIND_AUTO_CREATE);

    }

    private void init() {
        btnConnect = findViewById(R.id.btn_connect);
        btnDisConnect = findViewById(R.id.btn_disconnect);
        btnIsConnect = findViewById(R.id.btn_is_connected);
        btnSendMessage = findViewById(R.id.btn_send_message);
        btnRegisterListener = findViewById(R.id.btn_register_listener);
        btnUnregisterListener = findViewById(R.id.btn_unregister_listener);
        btnIsConnect.setOnClickListener(this);
        btnConnect.setOnClickListener(this);
        btnDisConnect.setOnClickListener(this);
        btnSendMessage.setOnClickListener(this);
        btnRegisterListener.setOnClickListener(this);
        btnUnregisterListener.setOnClickListener(this);

    }

    @Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.btn_connect:
                try {
                    //连接
                    connectionServiceProxy.connect();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.btn_disconnect:
                try {
                    //断开连接
                    connectionServiceProxy.disconnect();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.btn_is_connected:
                try {
                    //获取连接状态
                    boolean isConnected = connectionServiceProxy.isConnected();
                    Toast.makeText(MainActivity.this,String.valueOf(isConnected),Toast.LENGTH_SHORT).show();
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.btn_send_message:
                try {
                    //客户端 → 服务端
                    MyBean myBean = new MyBean();
                    myBean.setContent("王睿对喷火龙使出了动感光波");
                    messageServiceProxy.sendMessage(myBean);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.btn_register_listener:
                try {
                    messageServiceProxy.registerMessageReceiveListener(messageReceiveListener);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.btn_unregister_listener:
                try {
                    messageServiceProxy.unRegisterMessageReceiveListener(messageReceiveListener);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
        }
    }
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btn_connect"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="连接"/>

    <Button
        android:id="@+id/btn_disconnect"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="取消连接"/>

    <Button
        android:id="@+id/btn_is_connected"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="连接状态"/>

    <Button
        android:id="@+id/btn_send_message"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="发送消息"/>

    <Button
        android:id="@+id/btn_register_listener"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="注册监听器"/>

    <Button
        android:id="@+id/btn_unregister_listener"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="10dp"
        android:text="取消监听器"/>


</LinearLayout>

Demo地址：
链接：https://pan.baidu.com/s/1JHmCOeRIjGaVnwuA8RB2Jw
提取码：u5xh

王睿丶
关注
  • 4
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
android使用AIDL跨进程通信（IPC）
08-28
本篇文章主要介绍了 android跨进程通信（IPC）：使用AIDL，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
跨进程访问（AIDL服务）
热门推荐
小工匠
02-16 1万+
我们都知道Service的主要的作用是后台运行和跨进程访问。 关于Service后台运行请查看鄙人的另外一篇文章Service基础本篇博文主要探讨的是跨进程访问~什么是AIDLAndroid系统中的进程之间是不能共享内存，因此，需要提供一些机制在不同的进程之间进行数据通信，Activity BroadCast 和 Content Provider都可以跨进程通信，Service同样也可以跨进程通信
AIDL通信
shuo277的博客
07-31 689
AIDL是用于定义服务端和客户端通信接口的一种描述语言，可以拿来生产IPC代码，从某种意义上说AIDL其实就是一个模板，因为在使用过程中，实际起作用的并不是AIDL文件，而是据此生产的一个Interface的实例代码，AIDL其实是为了避免我们重复写代码而出现的一个模板。...
Android：AIDL实战详解
肖云鹤的博客
04-16 6296
这篇博文从实战出发，用一个尽可能精简的Demo，实现两个App(也是两个进程：服务端mainapp、客户端otherapp)通过AIDL的跨进程通信
Android跨进程通信方式总结
ming15920的博客
08-27 970
1、AIDL定义 IPC：Inter-Process Communication，即跨进程通信 AIDL：Android Interface Definition Language，即Android接口定义语言，进程间通信的桥梁；用于让某个Service与多个App之间进行跨进程通信，从而可以实现多个App共享同一个Service的功能。 2、Android跨进程通信实现方式 Android跨进程通信实现方式采用远程Service。 3、使用场景 多个应用程序共享同一个后台服务（远...
Android AIDL 实现
MM_daqi的博客
11-16 635
android AIDL
【Android】跨进程通信——AIDL、之Service基本细节使用之：精通
虚妄狼
01-30 6083
入门及高级进阶Android组件 Service
详解Android跨进程IPC通信AIDL机制原理
01-06
AIDL:Android Interface Definition Language,即Android接口定义语言，用于生成Android不同进程间进行进程通信(IPC)的代码，一般情况下一个进程是无法访问另一个进程的内存的。如果某些情况下仍然需要跨进程访问内存...
使用aidl实现跨进程通信(ipc)
11-02
代码中包含两个应用程序，两者之间通信采用aidl方案实现 使用方法：将下载下来的图片后缀名改为.zip，再解压即可得到源代码
Android AIDL(跨进程)
zenmela2011的专栏
10-18 1903
1.AIDL AIDL是一个缩写，全称是Android Interface Definition Language，也就是Android接口定义语言。是的，首先我们知道的第一点就是：AIDL是一种语言。 设计这门语言的目的是为了实现进程间通信，尤其是在涉及多进程并发情况下的进程间通信。 每一个进程都有自己的Dalvik VM实例，都有自己的一块独立的内存，都在自己的内存上存储自己的数据，执行着自己的操作，都在自己的那片狭小的空间里过完自己的一生。每个进程之间都你不知我，我不知你，就像是隔江相望的两座小岛一样
四种跨进程通信及aidl的使用
qq_32670947的博客
06-07 826
由于android系统中应用程序之间不能共享内存。因此，在不同应用程序之间交互数据（跨进程通讯）就稍微麻烦一些。在android SDK中提供了4种用于跨进程通讯的方式。这4种方式正好对应于android系统中4种应用程序组件：Activity、Content Provider、Broadcast和Service。
Android AIDL跨进程通信
Ikulm的博客
06-12 1452
AIDL的文件编写相对来说不是很难，都是定义的一些接口方法，供外部调用。其中，我们通过自定义的远程服务ChatService作为中间组件，在两个应用间都绑定过一次，并且在DemoA中我们的远程服务与Activity的通信是通过Messenger来实现的，Messenger内部也是通过Binder机制将Message从一个进程传递到另一个进程。
Android中AIDL的简单使用（Hello world）
侠亦狐的博客
05-16 4729
AIDL：Android Interface Definition Language（Android接口定义语言） 作用：跨进程通讯。如A应用调用B应用提供的接口
如何使用AIDL进行跨进程通信
最新发布
lzq520210的博客
07-12 346
通过以上步骤，你可以使用AIDL进行跨进程通信。需要注意的是，你需要将服务端进程的包名和Service类名设置为正确的值，以便正确连接到服务端进程的Service。同时，AIDL也支持在接口中定义回调方法，以实现双向通信。详细的使用方法和示例可以在Android开发文档中找到。
Android AIDL基本使用
积小步而至千里
07-06 1079
功能实现，由客户端发送数据过来，简单保存一下aString。客户端还必须拥有接口类的访问权限，因此如果客户端和服务在不同应用内，则客户端应用的。这样server端服务已经开发好了，只需要在Activity把这个服务启动即可。因为我们给server端记上了权限，那么客户端需要把对应权限加上。文件，使用 Java 编程语言生成接口。接口，进而为客户端提供 AIDL 方法的访问权限）的副本。类并实现 AIDL 接口中的方法。--加上服务权限 -->此文件定义带有方法签名的编程接口。的内部抽象类，用于扩展。
AIDL详解，尝试自己动手实现 AIDL 机制
Guang_Mang 的博客
09-30 1992
AIDL（Android Interface definition language，安卓接口定义语言）是Android中IPC（Inter-process Communication）方式的一种，简单来说，AIDL的作用就是你可以在自己的APP绑定另一个APP的service，这样两个APP就可以进行交互。
知识点-----AIDL（一）简单的aidl实现
qq_36968707的博客
01-07 1229
AIDL是什么 AIDL（Android Interface Definition Language）是Android系统自定义的接口描述语言。可以用来实现进程间的通讯。 AIDL 支持的数据类型 共 4 种： Java 的基本数据类型 List 和 Map  元素必须是 AIDL 支持的数据类型 Server 端具体的类里则必须是 ArrayList 或者 HashMap ...
AIDL 应用间简单通信demo及基本问题
JiaoJunfeng
01-17 939
AIDL入门
两个独立 APP 通过 AIDL 进行通讯的简单例子
weixin_38096197的博客
06-06 912
在 AIDLClient 项目中，我们需要把 AIDLServer 中 aidl 生成的java文件（图7）拷贝到项目中（图8）来，注意包名也要一致。为了能够正常的创建aidl文件，我们只需要在 build.gradle 的 android 中增加以下代码即可，记得执行同步gradle操作。跟普通java接口差不多。MyService 中的代码如下，此时服务端 APPService 项目的代码就完成了。此时点击对应的按钮，我们可以把 mNumber 自增后的数据设置到服务端，然后又从服务端拿回数据。
android跨进程通信之aidl
04-26
AIDL（Android Interface Definition Language）是一种Android系统中用于实现跨进程通信（IPC）的机制。它允许一个应用程序中的组件可以调用另一个应用程序中的服务，并通过服务提供者返回结果。使用AIDL，开发人员...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

王睿丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值