使用aidl实现进程间通信

最新推荐文章于 2024-01-07 20:24:36 发布
最新推荐文章于 2024-01-07 20:24:36 发布
阅读量246 收藏
点赞数

该工具可以把一个aidl文件转换为一个Java类文件，在该Java类文件中，同时重载了transact()和onTransact()方法，统一了存入包裹和读取包裹参数，从而使设计者可以把注意力放到服务代码本身上。

因为我现在使用android studio开发工具开发android应用程序，所以在编写aidl文件时，还是和用eclipse有一些差别。

首先在服务端新建一个aidl文件：




如上图建了一个名为IPayService的aidl文件。就定义一个函数，注意文件的包名要跟应用程序的包名一致，就是清单配置文件里包名，不然执行下一步没效果

然后：


点击make Project之后，就会生一个java文件了


/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: /home/chenjun/work/asproject/Binder/myserver/src/main/aidl/com/cj/myserver/IPayService.aidl
 */
package com.cj.myserver;
// Declare any non-default types here with import statements

public interface IPayService extends android.os.IInterface
{
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.cj.myserver.IPayService
{
private static final java.lang.String DESCRIPTOR = "com.cj.myserver.IPayService";
/** Construct the stub at attach it to the interface. */
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
 * Cast an IBinder object into an com.cj.myserver.IPayService interface,
 * generating a proxy if needed.
 */
public static com.cj.myserver.IPayService asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.cj.myserver.IPayService))) {
return ((com.cj.myserver.IPayService)iin);
}
return new com.cj.myserver.IPayService.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_pay:
{
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
this.pay(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.cj.myserver.IPayService
{
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;
}
/**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
@Override public void pay(int money) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(money);
mRemote.transact(Stub.TRANSACTION_pay, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_pay = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
}
/**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
public void pay(int money) throws android.os.RemoteException;
}


上面就是自动生产的java文件

现在再来看一下重新构造的服务端：


看一下主要代码：

package com.cj.myserver;

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

public class MyService extends Service {
    private static final String TAG = "test";

    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "onBind: ");
        MyBinder binder = new MyBinder();
        Log.d(TAG, "onBind: "+binder.toString());
        return binder;
    }
//    class MyBinder extends Binder{
//        @Override
//        protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
//            switch (code){
//                case 1:
//                    data.enforceInterface("MyService");
//                    int cost = data.readInt();
//                    pay(cost);
//                    break;
//            }
//            return super.onTransact(code, data, reply, flags);
//        }
//    }
    class MyBinder extends IPayService.Stub{
        @Override
        public void pay(int money) throws RemoteException {
            Log.d(TAG, "pay: "+money);
        }
    }

    /**
     * 服务端提供的支付服务
     * @param money
     */
//    public void pay(int money){
//        Log.d(TAG, "pay: "+money);
//    }

}


构造之前的都注释掉了，现在自定义MyBinder直接继承IPayService.Stub，这个类是自动生成的java文件中一个类，是一个抽象类，基于Binder，并实现了IpayService接口，主要由服务端来使用。该类之所以要定义为一个abstract类，是因为具体的服务函数pay()必须由程序员实现，因此，IpayService接口中定义的函数在stub类中可以没有具体实现。同时，在stub类中重载onTransact()方法，由于transact（）方法内部给包裹内写入的参数的顺序是由aidl工具定义的，因此在onTransact()方法中，aidl工具自然知道应该按照何种顺序从包裹中取出相应参数。

在stub类中还定义了一些int常量，比如TRANSACTION_pay，这些常量与服务函数对应，transact()和onTransact()方法的第一个参数code的值即来源于此。

接下来看客户端怎么用aidl文件


直接将服务端的aidl文件拷贝过来，注意连同包一起拷贝，放在源目录下，然后make project也会自动生成相应的java文件

看一下客户端的重构

package com.cj.binder;

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

import com.cj.myserver.IPayService;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "test";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent("com.cj.myserver.myservice");
        intent.setPackage("com.cj.myserver");
        bindService(intent,serviceConnection,BIND_AUTO_CREATE);
    }
    public void pay(View v){
//        int code = 1;
//        Parcel data = Parcel.obtain();
//        Parcel reply = Parcel.obtain();
//        data.writeInterfaceToken("MyService");
//        data.writeInt(10);
//
//        try {
//            binder.transact(code,data,reply,0);
//        } catch (RemoteException e) {
//            e.printStackTrace();
//        }
//        reply.recycle();
//        data.recycle();
        try {
            payService.pay(20);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
   // private IBinder binder;
   private IPayService payService;
    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            Log.d(TAG, "onServiceConnected: ");
            Log.d(TAG, "onServiceConnected: "+iBinder.toString());
           // binder=iBinder;
            payService = IPayService.Stub.asInterface(iBinder);
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };
}

注释掉的是重构前的代码。

现在客户端这边将返回的Binder对象转换成了IPayService接口，这里其实IPayService.Stub.Proxy对象。该类将作为客户端程序访问服务端的代理，也实现IPayService接口。

public static com.cj.myserver.IPayService asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.cj.myserver.IPayService))) {
return ((com.cj.myserver.IPayService)iin);
}
return new com.cj.myserver.IPayService.Stub.Proxy(obj);
}

这个函数的作用就是将Binder对象转换成了IPayService接口，这函数其实还做了一些判断，如果不是跨进程通信的话，也就是说在服务端程序中，其他类访问使用该服务，那么onServiceConnected（）返回的Binder对象其实就是服务端的Binder对象（想象是BBinder），而如果是其他进程访问服务，则返回的Binder对象是远程引用（想象是BpBinder），然后将BpBinder封装成IPayService.Stub.Proxy这个代理，来看一下代理实现的pay()方法

@Override public void pay(int money) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(money);
mRemote.transact(Stub.TRANSACTION_pay, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
}


看一下它是不是其实还是利用Binder对象的transact()方法，和上一篇文章写法一样。

再看一下log





启动service，点击支付按钮，这里我传入的参数是20，结果服务端输出了20

现在看看aidl工具是不是很方便，aidl帮我们封装了一下Binder对象，使客户端和服务端很方便书写代码。





    

  • 本文已收录于以下专栏：
 

 

 

 

 

 

 

qq_34211554
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AIDL详细解析以及调用流程
bqy_510的博客
04-20 792
一、AIDL代码详细解析 /* * This file is auto-generated. DO NOT MODIFY. * Original file: E:\\android_projects\\Android-PickerView-master\\AidlDemo\\app\\src\\main\\aidl\\com\\suning\\aidldemo\\IAddInterfac...
Android进阶笔记：AIDL内部实现详解 （二）
jelly_fang的博客
01-17 627
接着上一篇分析的aidl的流程解析。知道了aidl主要就是利用Ibinder来实现跨进程通信的。既然是通过对Binder各种方法的封装，那也可以不使用aidl自己通过Binder来实现跨进程通讯。那么这篇博客就主要就写一下通过上篇（Android进阶笔记：AIDL详解(一)）总结的知识来自己实现跨进程通讯从而更加透彻的了解aidl的核心逻辑。首先上一篇博客（Android进阶笔记：AIDL详解(一)
使用AIDL实现进程间通讯简单案例
08-13
该文件中包含2个module，一个是客户端 aidl_C，另一个是服务端 aidl_S，客户端可以将用户编辑的信息发送给服务端，也可以接受来自服务端的数据。没有复杂的业务逻辑，非常简单。
AIDL基本用法
qq_27856623的博客
09-05 733
前言Aidl是android进程通信的一个办法，通过aidl我们可以跨进程调用方法。如果你仔细看完这篇文章，你将会有以下收获：1、aidl的基本使用 2、aidl传递自定义对象 3、client实现对Server的监听 使用Aidl步骤1、在Server端创建一个aidl文件，把服务端想对外提供的服务在这个文件中声明。声明之后对AS进行rebuild，然后系统会为我们自动生成一个java文件2、在S
理解AIDL原理以及系统生成的源码
amurocrash的专栏
12-16 967
工具好用，但是会有一个缺点，就是会让你不得不依赖说明书。对于我这个记忆力很差的人来说，每次使用工具都要去翻说明书是一件极其痛苦的事情，而且还有很多坑会忘记怎么填。基于此，我很多时候会觉得不如自己去理解一下工具制造的方法，然后自己造一个好了，好像我的大脑是对这种东西印象特别深刻，所以下次遇到问题我写个工具直接用的效率，比查说明书再重新趟一遍坑要高不少。今天，我要把aidl这个工具给拆了。 Part
使用AIDL实现进程间的通信
热门推荐
LiuHe
05-06 5万+
在Android中，如果我们需要在不同进程间实现通信，就需要用到AIDL技术去完成。AIDL（Android Interface Definition Language）是一种接口定义语言，编译器通过*.aidl文件的描述信息生成符合通信协议的Java代码，我们无需自己去写这段繁杂的代码，只需要在需要的时候调用即可，通过这种方式我们就可以完成进程间的通信工作。关于AIDL的编写规则我在这里就不多介绍了，读者可以到网上查找一下相关资料。接下来，我就演示一个操作AIDL的最基本的流程。首先，我们需要建立一个服务
使用 AIDL实现进程间通信
04-18
这篇博文“使用AIDL实现进程间通信”详细介绍了如何利用AIDL进行跨进程的数据交换。 首先，理解AIDL的基本概念至关重要。AIDL本质上是一种简单的接口定义语言，它允许开发者定义在两个不同进程之间传递的数据类型和...
Android AIDL实现进程间通信探索
09-01
Android AIDL（Android Interface Definition Language）是Android系统提供的一种进程间通信（IPC, Inter-Process Communication）机制，它允许不同进程之间的应用程序组件相互调用方法，实现数据交换。在Android中...
使用AIDL实现进程间的图像
06-01
本篇文章将深入探讨如何使用AIDL实现进程间的图像传输。 首先，我们需要了解AIDL的基本概念。AIDL是一种简单的接口定义语言，它允许我们定义服务端暴露给客户端的接口方法。这些方法的参数和返回值可以是基本类型，...
Android使用AIDL实现进程间通信
03-28
本篇文章将深入探讨如何在Android中使用AIDL来实现进程间通信。 首先，理解AIDL的基本概念。AIDL是一种接口定义语言，类似于Java中的接口，但它的目的是跨越进程边界。通过AIDL，我们可以定义一个接口，该接口会被...
Binder、AIDL、远程服务结合源码学习记录
小白成长记
03-17 1184
Binder与AIDL结合学习记录什么是binderbinder中的transact和onTransact的区别什么是AIDLAIDL中的stub和proxy远程服务与本地服务 本篇文章为自己学习binder过程中的知识总结和疑惑的解答，有什么错误请批评指正，互相进步。 什么是binder Binder主要作用是进程间通信，其他几种进程间通信方法有文件系统、socket、管道、Intents、ContentProviders、Messenger、Binder。 Android系统分为三层，从上往下分别是ap
Android Binder机制浅谈以及使用Binder进行跨进程通信的俩种方式（AIDL以及直接利用Binder的transact方法实现）
XJ200012的博客
06-14 5156
此篇文章是对Binder的学习以及使用Binder的方式和总结，图文并茂，附上源码说明
（五十七）Android O WiFi的扫描流程梳理续——梳理java与c++之间的aidl-cpp通信
JT的专栏
07-06 7641
前言：之前在（五十） Android O WiFi的扫描流程梳理 中梳理到wificond，就是找不到wificond对应的具体实现类，本文在现有发现上继续梳理，服务端是有cpp实现的，这种aidl实现方式被Google成为aidl-cpp1.问题在梳理WiFi 扫描流程的时候遇到如下方法，然后找不到对应服务端的实现类，现在专门梳理下找到的线索。mWificond = mWifiInjector....
Linux 角度看binder原理（四
Arthas的博客
08-21 1142
因为是interface_cast所以就是去android::os::IServiceManager里寻找asInterface方法，这里有一个主要注意的点，在最新的Android12中，Servicemanager已经不是直接和binder驱动交互了，它的实现通过aidl来系统生成代码，这个IServiceManager不是当前frameworks下的这个文件，是通过aidl生成的。在done中创建新线程，触发done的只有BINDER_WORK_TRANSACTION和发送死亡通知的时候。
Android 入门宝典 - 进程间通信 AIDL
qq_43323826的博客
09-17 201
AIDL： server： 请求抽象成接口，编写aidl接口 service 实现接口，开启服务时返回 binder 实例 AndroidManifest 配置 service，使其可被访问（自定义 action） client： 拷贝 aidl 文件到和 server 相同路径下，使其可以实例接口 Intent（action）访问，需要添加包名（setPackage（XXX）） 通过保留 ...
四、AIDL（一）同一应用中使用AIDL及原理
最新发布
追梦的土豆的博客
01-07 1143
Android AIDL 原理及同一应用中如何使用
Android 跨进程通信 深入浅出AIDL（二）
chuanao8829的博客
10-20 205
前言 概要 解剖 asInterface asBinder IInterface DESCRIPTOR onTransact服务端接收 transact客户端调用 ...
Android 中跨进程通信 AIDL 使用和分析
XFORG1992的博客
03-17 359
AIDL Android Interface Definition Language(AIDL), 即Android接口定义语言. 我们定义一些接口,服务端负责实现这些接口,而客户端是来调用这些接口的.当客户端和服务端不在一个进程 中时,客户端如何跨进程调用服务端的服务呢? 服务端实现 Binder 对象 在服务端实现一个特殊的对象(Binder对象),这个对象有两个特性： 一个是具有完成特定...
Android跨进程通信方式总结
ming15920的博客
08-27 1045
1、AIDL定义 IPC：Inter-Process Communication，即跨进程通信 AIDL：Android Interface Definition Language，即Android接口定义语言，进程间通信的桥梁；用于让某个Service与多个App之间进行跨进程通信，从而可以实现多个App共享同一个Service的功能。 2、Android跨进程通信实现方式 Android跨进程通信实现方式采用远程Service。 3、使用场景 多个应用程序共享同一个后台服务（远...
如何使用aidl进行进程间通信
05-13
下面是使用 AIDL 进行进程间通信的步骤： 1.定义 AIDL 接口 首先，在服务端和客户端之间定义一个 AIDL 接口。在 AIDL 文件中，定义需要向客户端公开的方法和参数。 2.实现 AIDL 接口 在服务端中，实现定义的 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值