深入解析AIDL的实现：Messenger

最新推荐文章于 2022-02-08 16:45:42 发布
最新推荐文章于 2022-02-08 16:45:42 发布
阅读量1k 收藏
点赞数
分类专栏： Android Android进阶之路 文章标签： android messenger aidl
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/stven_king/article/details/74922503
版权

Messenger可以翻译为信使，顾名思义，通过它可以在不同进程中传递Message对象，在Message中放入我们需要传递的数据，就可以轻松地实现数据的进程间传递了。Messenger是一种轻量级的IPC方案，它是AIDL在Android中的一种经典实践。

文章主要讲述Messenger利用AIDL进行进程间通信，其中不免会涉及到AIDL的知识点。对ADIL不熟悉的同学可以阅读我之前写过的一篇Android：IPC之AIDL的学习和总结。

【本篇文章中讲述的都是跨进程通信，在相同进程中使用Messenger文章不做讲述！！】

本来想先通过Demo来引出Messenger，然后再根据Demo一步一步分析源码。但是最后还是觉得本次应该先讲述Messenger的基础知识，结合aidl的知识分析源码，然后再通过讲述Demo深入一些分析Android当时设计Messenger的心情。
先来看看Messenger的主要成员变量和成员方法：

public final class Messenger implements Parcelable {
    private final IMessenger mTarget;
    public Messenger(Handler target) {
        mTarget = target.getIMessenger();
    }
    public void send(Message message) throws RemoteException {
        mTarget.send(message);
    }
    public IBinder getBinder() {
        return mTarget.asBinder();
    }
	/**其他代码省略**/
	//重点mTarget为IMessenger.Stub.asInterface
    public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }
}

Messenger一共有两个构造函数，一个通过IBinder构造，一个是通过Handler构造。
两种实现方式意义相同么（这是一个非常重要的问题）？

//Handler#getIMessenger
final IMessenger getIMessenger() {
	synchronized (mQueue) {
		if (mMessenger != null) {
			return mMessenger;
		}
		mMessenger = new MessengerImpl();
		return mMessenger;
	}
}
//Handler#MessengerImpl
//重点MessengerImp是继承IMessenger.Stub
private final class MessengerImpl extends IMessenger.Stub {
	public void send(Message msg) {
		msg.sendingUid = Binder.getCallingUid();
		Handler.this.sendMessage(msg);
	}
}

IMessenger是一个aidl接口，MessengerImpl为它的实现类

package android.os;
import android.os.Message;
/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

之前介绍的Android：IPC之AIDL的学习和总结文章中对aidl接口在编译后生成的Java类文件做了详细的分析和讲解。
这次我们再看一遍生成的IMessenger.java文件，对此熟悉的同学可以略过了。

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: frameworks/base/core/java/android/os/IMessenger.aidl
 */
package android.os;
/** @hide */
public interface IMessenger extends android.os.IInterface {
    public void send(android.os.Message msg) throws android.os.RemoteException;
    /** Local-side IPC implementation stub class. */
    public static abstract class Stub extends android.os.Binder implements android.os.IMessenger {
        private static final java.lang.String DESCRIPTOR = "android.os.IMessenger";
        static final int TRANSACTION_send = (android.os.IBinder.FIRST_CALL_TRANSACTION +
            0);
        /** Construct the stub at attach it to the interface. */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }
        /**
         * Cast an IBinder object into an android.os.IMessenger interface,
         * generating a proxy if needed.
         */
        public static android.os.IMessenger asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof android.os.IMessenger))) {
                return ((android.os.IMessenger) iin);
            }
            return new android.os.IMessenger.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_send: {
                data.enforceInterface(DESCRIPTOR);
                android.os.Message _arg0;
                if ((0 != data.readInt())) {
                    _arg0 = android.os.Message.CREATOR.createFromParcel(data);
                } else {
                    _arg0 = null;
                }
                this.send(_arg0);
                return true;
            }
            }
            return super.onTransact(code, data, reply, flags);
        }
		//远端代理类
        private static class Proxy implements android.os.IMessenger {
            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 void send(android.os.Message msg)
                throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((msg != null)) {
                        _data.writeInt(1);
                        msg.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_send, _data, null,
                        android.os.IBinder.FLAG_ONEWAY);
                } finally {
                    _data.recycle();
                }
            }
        }
    }
}

看完这个IMessenger.java这个类，我们再回一下刚才Messenger的两个构造方法。

使用Handler构造：

//Messenger#Messenger
public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}
//Handler#getIMessenger
final IMessenger getIMessenger() {
    synchronized (mQueue) {
        if (mMessenger != null) {
            return mMessenger;
        }
        mMessenger = new MessengerImpl();
        return mMessenger;
    }
}
//Handler#MessengerImpl
//重点MessengerImp是继承IMessenger.Stub
private final class MessengerImpl extends IMessenger.Stub {
    public void send(Message msg) {
        msg.sendingUid = Binder.getCallingUid();
        Handler.this.sendMessage(msg);
    }
}

使用Handler构造出来的Messenger的mTarget成员变量类型为IMessenger.Stub即Binder的实现类。

使用IBinder构造：

/**其他代码省略**/
//重点mTarget为IMessenger.Stub.asInterface
public Messenger(IBinder target) {
	mTarget = IMessenger.Stub.asInterface(target);
}

IMessenger.java类中我们可以看到IMessenger.Stub.asInterface方法获得是IMessenger.Proxy类型对象，为Binder的代理类。这样构造出来的Messenger即为Binder的代理类。

通过源码的详细比较我们得出了结论：

  • 使用Handler构造出来的Messenger为Binder的实现类；
  • 使用使用IBinder构造构造出来的Messenger为Binder的代理类；

到这里我们队Messenger代码的研究就差不多结束了，接下来我们现在实现一个简单的利用Messenger在两个不同的进程进行简单通信的例子，希望通过这个Demo的讲解能将我们前面的知识消化吸收。

现在看看服务端的代码

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            String msgString = msg.getData().getString("msg");
            if (!TextUtils.isEmpty(msgString)) {
                Log.d(TAG, "handleMessage: msg = [" + msgString + "]");
            }
        }
    }
    //创建service端处理消息的Messenger
    private final Messenger mMessenger = new Messenger(new MessengerHandler());
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

客户端代码：

public class MessengerActivity extends AppCompatActivity {
    private static final String TAG = "MessengerActivity";
    private Messenger mService;
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //构造客户端的Messenger往服务端发消息
            mService = new Messenger(service);
            Message msg = Message.obtain();
            Bundle data = new Bundle();
            String msgString = "hello ,this is client.";
            data.putString("msg", msgString);
            msg.setData(data);
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        bindService(new Intent(this, MessengerService.class),mConnection,
                Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(mConnection);
    }
}

将MessengerService在AndroidManifest.xml注册在另个一remote进程中：

<service android:name=".MessengerService"
                 android:enabled="true"
                 android:exported="true"
                 android:process=":remote" />

在com.example.ybb.aidlexample:remote进程中的Logcat输出结果：

06-28 14:55:29.793 22206-22206/com.example.ybb.aidlexample:remote D/MessengerService: handleMessage() : msg = [hello ,this is client.]

是不是感觉很简单呢？那么如果在这个代码上修改一下：让客户端和服务端能互相发送和接受消息。

首相我们回想一下：

  • 发送消息必须要得到远端的Binder对象来构造Messenger；
  • 处理消息必须新建一个Handler来构造Messenger；

就以上这两点我们来重新写一下service端和Client端的代码：

Service端代码：

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    private static class MessengerHandler extends Handler{
        boolean received = false;
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            String msgString = msg.getData().getString("msg");
            if (!TextUtils.isEmpty(msgString)) {
                Log.d(TAG, "handleMessage: msg = [" + msgString + "]");
            }
            if (!received) {
                //利用Client端接受处理消息的Messenger来发送Message
                Messenger client = msg.replyTo;
                Message data = Message.obtain();
                Bundle bundle = new Bundle();
                bundle.putString("reply", "Your messages had received~!");
                data.setData(bundle);
                try {
                    client.send(data);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                received = true;
            }
        }
    }
    private final Messenger mMessenger = new Messenger(new MessengerHandler());
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

Client端代码：

public class MessengerActivity extends AppCompatActivity {
    private static final String TAG = "MessengerActivity";
    private static class ClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            String replyString = msg.getData().getString("reply");
            if (!TextUtils.isEmpty(replyString)) {
                Log.d(TAG, "handleMessage() : reply = [" + replyString + "]");
            }
        }
    }
    private Messenger clientHandler = new Messenger(new ClientHandler());
    private Messenger mService;
    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message msg = Message.obtain();
            Bundle data = new Bundle();
            String msgString = "hello ,this is client.";
            data.putString("msg", msgString);
            msg.setData(data);
            //将处理消息的Messenger绑定到消息上带到服务端
            msg.replyTo = clientHandler;
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        bindService(new Intent(this, MessengerService.class),mConnection,
                Context.BIND_AUTO_CREATE);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(mConnection);
    }
}

运行结果：
messenger-logcat.jpg

文章到这里就全部讲述完啦，若有其他需要交流的可以留言哦！！

想阅读作者的更多文章，可以查看我 个人博客 和公共号：
振兴书城

静默加载
关注
专栏目录
Android中的Service：Binder，Messenger，AIDL（2）
lypeer的专栏
06-06 5万+
前言前面一篇博文介绍了关于Service的一些基本知识，包括service是什么，怎么创建一个service，创建了一个service之后如何启动它等等。在这一篇博文里有一些需要前一篇铺垫的东西，建议没有看过前一篇博文的同学先去看一下前一篇： Android中的Service：默默的奉献者 (1) 。但是在前一篇博文中也有一些遗漏的东西——主要是关于bindService()这一块的具体细节。由于这
Android 关于AIDL你需要知道的一切
咸鱼君i
05-06 6833
好的，由于上周拖更，本次带来Android进程通信详解–AIDL，虽然网上关于这个内容的资料丰富且详细，但一千个读者就有一千个哈姆雷特不是嘛，对于任何东西都要有自己的见解。Service关于AIDL，Service就是我们不得不提的东西了，它是Android四大组件之一，太基础的东西这里我们就不再赘述，下面还是给出一些我对于Service的认识：上图为Service的生命周期从图里不难看出，Serv
AIDL的示例以及自己简单实现一个AIDL
08-27
AIDL的示例以及自己简单实现一个AIDL ,code具有一定的参考意义，让人理解AIDL是怎么完成远程调用的
AIDL的实现
weixin_34125592的博客
09-23 87
2019独角兽企业重金招聘Python工程师标准>>> ...
AndroidStudio实现AIDL
weixin_30852419的博客
07-08 161
AIDL的使用步骤 aidl远程调用传递的参数和返回值支持Java的基本类型（int long booen char byte等）和String，List，Map等。当然也支持一个自定义对象的传递。 服务端 新建一个MyAidlDemoServer工程，然后在java目录下右键新建一个aidl File，然后在该目录下新建一个IMyAidlInterface.aidl文件，代码如下： ...
AIDL简单实现（1）
dawuafang
06-04 111
1、服务端 服务端首先要创建一个Service用来监听客户端的连接请求，然后创建一个AIDL文件，将暴露给的客户端的接口在这个AIDL文件中声明，最后在Service中实现这个AIDL接口即可 2、客户端 客户端首先要绑定服务端的Service，绑定成功后，将服务端返回的Binder对象转成AIDL接口所属的类型，接着就可以调用AIDL中的方法了。 3、AIDL接口创建 AID...
AIDL实现
的专栏
03-21 448
AIDL:Android Interface Definition Language,即Android接口定义语言.      Android系统中的进程之间不能共享内存，因此，需要提供一些机制在不同进程之间进行数据通信。      为了使其他的应用程序也可以访问本应用程序提供的服务，Android系统采用了远程过程调用（Remote Procedure Call，RPC）方式来实现。
进行跨应用通信：Android Intent机制深入解析
通过Intent，可以实现不同组件之间的数据传递和交互。 ## 1.2 Intent的作用和特点 Intent主要用于在应用内或应用间传递数据、启动组件、执行动作等操作。其特点包括灵活性强、简单易用、支持显式和隐式两种方式...
Messenger的IPC方案demo
12-01
**标题与描述解析** 标题"Messenger的IPC方案demo"表明我们将探讨的是Android系统中的一...在提供的压缩包中，`MessengerActivity`可能是实现这一通信的关键部分，深入研究其代码将有助于更深入地理解Messenger IPC。
深入理解AsyncChannel、Messenger
ulangch的博客
08-21 2324
这篇文章主要介绍Android AsyncChannel原理及其应用实例 注：文章参考的是Andrdoid 8.0源码 #
Messenger与AIDL的异同
dawuafang
08-30 210
最近做项目需要使用进程间通信，大家知道应用层的进程间通信无非Broadcast，Activity，Service，Content Provider四大组件。Broadcast适用于一对多，我这里是一对一（子进程与主进程）的关系，且Broadcast性能较差，所以不用Broadcast。另外Content Provider主要用户本地持久化数据的通信，我这里主要是内存级别的数据，所以也不用Conte...
AIDL的简单实现
chixi8818的博客
12-01 327
AIDL的解释这里就不多做赘述了，大家可以百度一下，应该很轻松可以百度出很多，虽然也要人工筛选一下百度的结果(啊呵呵哒)。 这里面我只就自己根据网上的资料写的例子做一些流程叙述，让大家也能够轻松实现一个AIDL例子。 话不多说，第一步： 1，建一个项目，Andro...
知识点-----AIDL（一）简单的aidl实现
qq_36968707的博客
01-07 1393
AIDL是什么 AIDL（Android Interface Definition Language）是Android系统自定义的接口描述语言。可以用来实现进程间的通讯。 AIDL 支持的数据类型 共 4 种： Java 的基本数据类型 List 和 Map  元素必须是 AIDL 支持的数据类型 Server 端具体的类里则必须是 ArrayList 或者 HashMap ...
AIDL实现及原理
小强Stronger的博客
11-24 676
AIDL全称Android Interface Definition Language（AndRoid接口描述语言）是一种借口描述语言; 编译器可以通过aidl文件生成一段代码，通过预先定义的接口达到两个进程内部通信进程跨界对象访问的目的.AIDL的IPC的机制和COM或CORBA类似, 是基于接口的，但它是轻量级的。它使用代理类在客户端和实现层间传递值.
AIDL的原理实现
Yo.o
02-08 1996
​ 前言 Binder 驱动是基于 CS 模型设计的跨进程通信驱动, 想要使用 Binder 驱动进行通信, 需要三个步骤 定义交互规范 服务端实现 客户端实现 一、 定义交互规范 public interface IService extends IInterface { /* 跨进程提供服务的接口描述 */ String DESCRIPTOR = IService.class.getName(); /* 跨进程提供服务的接口中 getServic
AIDL的实现总结
taowuhua的博客
09-03 361
由于应用程序之间不能共享内存。在不同应用程序之间交互数据（跨进程通讯）,故使用AIDL的方式。比如天气预报的实现，数据在的刷新可以通过常驻的服务，另一个应用每次绑定服务的时候调用bingservice获取数据（通过打印日志可以发现onstartConand方法会得到调用，发送数据的地方可以写在这里）注意：服务运行在主线程中，普通的服务需要在执行耗时任务的时候需要开启一个线程，防止出现oom。而对于...
AIDL简述与实现
麻仓叶会打码
04-18 394
AIDL（Android Interface Define Language），是android的一种接口定义语言，类似于IDL。借助它，你可以定义接口，使得客户端和服务端之间实现进程间通信。对android来说， 一个进程无法通过正常的方法来访问另一个进程的内存空间。可以说，他们需要把对象分解成操作系统可以理解的原子类型，然后使对象突破限制在不同进程之间进行传输。具体实现这种机制的代码写起来非常...
AIDL实现原理
to_perfect的博客
05-23 1259
这篇文章将带你细看AIDL的结构和实现原理
Android进程通信深入解析：Messenger与AIDL实战
本文将深入探讨两种主要的跨进程通信方式：Messenger和AIDL（Android Interface Definition Language）。这两种方式都是基于Android的Binder机制来实现的。 1. Messenger使用 Messenger是一种轻量级的IPC解决方案，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值