深入解析AIDL的实现:Messenger

原创 2017年07月10日 14:38:33

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

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

想阅读作者的更多文章,可以查看我 个人博客 和公共号:

振兴书城

版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

Spring Cloud构建微服务架构(三)断路器

在微服务架构中,我们将系统拆分成了一个个的服务单元,各单元间通过服务注册与订阅的方式互相依赖。由于每个单元都在不同的进程中运行,依赖通过远程调用的方式执行,这样就有可能因为网络原因或是依赖服务自身问题...

JavaSE的自动装箱和自动拆箱

JavaSE的自动装箱和自动拆箱

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

又一年对Android消息机制(Handler&Looper)的思考

前言Android消息机制对于每一个Android开发者来说都不陌生,在日常的开发中我们不可避免的要经常涉及这部分的内容。从开发角度来说,Handler是Android消息机制的上层接口,这使得在开发...

当你编码时你在做什么:谈编程的本质(二)可爱的树

憋了好久的一篇,主题有点大一直没有写完,中间隔了很长时间现在已经有点捡不起来了,索性先发出来吧。至少个人觉得,完成的部分还是总结了一些有用的东西。关于Tree之上的属性、递归算法等,只能等状态回来了再...

OOM问题总结

OutOfMemoryError(OOM)就是常说的内存泄露问题。为了能够使Android应用程序能够高效快速地运行,所以Android的每个应用程序都会用一个专有的Davilk虚拟机(Android...

异常、堆内存溢出、OOM的几种情况

1堆内存溢出 2Java异常 OOM1、堆内存溢出【情况一】:   java.lang.OutOfMemoryError: Java heap space:这种是java堆内存不够,一个原因是真不够...

程序员的八重境界

看到一篇有趣的文章The Eight Levels of Programmers。以前似乎看过不少这种程序员的多少个级别、境界,但这篇语言很风趣,而且分类比较细化,让人觉得挺合情合理、无法反驳的。绝大...
  • dc_726
  • dc_726
  • 2017-08-31 04:58
  • 21926

JAVA回忆录之泛型篇

泛型是什么泛型是JDK1.5版本中加入的,在没有泛型之前,从集合中读取到的每一个对象都必须进行转化。如果有人不小心插入了类型错误的对象,在运行时的转化处理就会出错。有了泛型之后,可以告诉变一起每个集合...

如何避免OOM 异常?

如何避免OOM 异常

深入Guava Cache的refresh和expire刷新机制

Guava Cache是本地缓存的不二之选,用起来真不错呵,可是你真的知道怎么使用才能满足需求?今天我们深入探讨一下Expire和Refresh。
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)