Android基于Message的进程间通信之Messenger使用及解析

1、Messenger 简介

说到Android进程间通信,大家肯定能想到的是编写aidl文件,然后通过aapt生成的类方便的完成服务端,以及客户端代码的编写。如果你对这个过程不熟悉,可以查看Android aidl Binder框架浅析;

当然今天要说的通信方式肯定不是通过编写aidl文件的方式,那么有请今天的主角:Messenger。ok,这是什么样的一个类呢?我们看下注释

This allows for the implementation of message-based communication across processes

允许实现基于消息的进程间通信方式。

平时一说进程间通讯,大家都会想到AIDL,其实messenger和AIDL作用一样,都可以进行进程间通讯。它是基于消息的进程间通信,就像子线程和UI线程发送消息那样,是不是很简单,还不用去写AIDL文件,是不是有点小爽。哈哈。

此外,还支持记录客户端对象的Messenger,然后可以实现一对多的通信;甚至作为一个转接处,任意两个进程都能通过服务端进行通信。

与 AIDL 比较:

当您需要执行 IPC 时,为您的接口使用 Messenger 要比使用 AIDL 实现更加简单,因为 Messenger 会将所有服务调用排入队列,而纯粹的 AIDL 接口会同时向服务发送多个请求,服务随后必须应对多线程处理。

对于大多数应用,服务不需要执行多线程处理,因此使用 Messenger 可让服务一次处理一个调用。如果您的服务必须执行多线程处理,则应使用 AIDL 来定义接口。

2、通信实例

1)Service端

代码

package com.ryg.chapter_2.messenger;

import android.app.Service;
import android.content.Intent;
import android.os.*;
import android.util.Log;
import com.ryg.chapter_2.utils.MyConstants;

/**
 * FileName:
 * Author: nanzong
 * Date: 2019-06-20 17:23
 * Description:
 * History:
 */
public class MessengerService extends Service {

    private static final String TAG = "MessengerActivity";

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_CLIENT:
                    Log.d(TAG, "receive msg from Client:" + msg.getData().getString("mymsg"));
                    Messenger msgfromClient = msg.replyTo;
                    Message relpyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "  嗯 , 你的消息我已经收到,稍后会回复你!");
                    relpyMessage.setData(bundle);
                    try {
                        msgfromClient.send(relpyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    private final Messenger mMessenger = new Messenger(new MessengerHandler());

    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }

}

服务端就是一个Service,只需要去声明一个Messernger (Handler handler)对象,然后onBind方法中返回一个mMessenger.getBinder();

然后等客户端将消息发送到Handler中的handleMessage,根据msg.what去判断什么操作,最终将结果通过msgfromClient.replyTo.send(relpyMessage);返回

注册文件

  
            
                
            
        

别忘了注册service

2)客户端

Activity

package com.ryg.chapter_2.messenger;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.*;
import android.util.Log;
import com.ryg.chapter_2.R;
import com.ryg.chapter_2.utils.MyConstants;

public class MessengerActivity extends Activity {

    private static final String TAG = "MessengerActivity";

    private Messenger mServerMessenger;
    @SuppressLint("HandlerLeak")
    private Messenger mClientMessenger = new Messenger(new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_SERVICE:
                    Log.d(TAG, "receive msg from Service:" + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    });


    private ServiceConnection mConnection = new ServiceConnection() {

        //Activity 与 Service连接成功使回调该方法
        @Override
        public void onServiceConnected(ComponentName className, IBinder service) {
            mServerMessenger = new Messenger(service);
            Log.d(TAG, "bind service");
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("mymsg", "hello, this is client.");
            msg.setData(data);
            msg.replyTo = mClientMessenger;  //指定回信人是客户端定义的

            try {
                mServerMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        //Activity 与 Service 断开连接  回调该方法
        @Override
        public void onServiceDisconnected(ComponentName name) {
            mServerMessenger = null;
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        //绑定服务
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

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

首先bindService,然后再onServiceConnected中拿到回调的service( Binder)对象,通过 mServerMessenger = new Messenger(service);然后就可以使用mServerMessenger.send(msg);发送给服务端了

     mServerMessenger = new Messenger(service);
            Log.d(TAG, "bind service");
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("mymsg", "hello, this is client.");
            msg.setData(data);
            msg.replyTo = mClientMessenger;  //指定回信人是客户端定义的

            try {
                往服务端发送消息
                mServerMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

那么服务端会收到消息,处理完成会将结果返回,传到client的mMessenger中的Handler的handleMessage方法中给对应地方进行处理

3) 运行结果

2019-06-28 08:56:57.480 21990-21990/com.ryg.chapter_2 D/MessengerActivity: bind service
2019-06-28 08:56:59.482 22039-22039/com.ryg.chapter_2:remote D/MessengerActivity: receive msg from Client:hello, this is client.
2019-06-28 08:56:59.482 21990-21990/com.ryg.chapter_2 D/MessengerActivity: receive msg from Service:  嗯 , 你的消息我已经收到,稍后会回复你!

通过代码可以看到服务端往客户端传递数据是通过msg.replyTo这个对象的,那么服务端完全可以做到,使用一个List甚至Map去存储所有绑定客户端的msg.replyTo对象,然后想给谁发消息都可以。

3、源码分析

Messenger 有两个构造函数

  • 以Handler 为参数
  • 以IBinder 为参数
//服务端构建对象
public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}
//客户端构建对象
public Messenger(IBinder target) {
    mTarget = IMessenger.Stub.asInterface(target);    //和前面的 AIDL 很相似吧
}

1)客户端向服务端通信

服务端

服务端的onBind是这么写的:

    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }

那么点进去:

    /**
     * Retrieve the IBinder that this Messenger is using to communicate with
     * its associated Handler.
     * 
     * @return Returns the IBinder backing this Messenger.
     */
    public IBinder getBinder() {
        return mTarget.asBinder();
    }

可以看到返回的是mTarget.asBinder();
我们前边构建Messenger对象的代码 new Messenger(new Handler());
mTarget就是这么来的

public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}

Handler返回

 final IMessenger getIMessenger() {
        synchronized (mQueue) {
            if (mMessenger != null) {
                return mMessenger;
            }
            mMessenger = new MessengerImpl();
            return mMessenger;
        }
    }

    private final class MessengerImpl extends IMessenger.Stub {
        public void send(Message msg) {
            msg.sendingUid = Binder.getCallingUid();
            Handler.this.sendMessage(msg);
        }
    }

mTarget是一个MessengerImpl对象,那么asBinder实际上是返回this,也就是MessengerImpl对象;

这是一个内部类,继承IMessenger.Stub,然后实现了一个send方法,该方法就是将接收到的消息通过Handler.this.sendMessage(msg);发送到handleMessage方法。

看到这,大家有没有想到什么,难道不觉得extends IMessenger.Stub这种写法异常的熟悉么?

我们传统写aidl文件,aapt给我们生成什么,生成IXXX.Stub类,然后我们服务端继承IXXX.Stub实现接口中的方法。

这里依赖了一个aidl生成的类
/Users/nanzong/Library/Android/sdk/sources/android-28/android/os/IMessenger.aidl

package android.os;  

import android.os.Message;  

/** @hide */  
oneway interface IMessenger {  
    void send(in Message msg);  
}  

Messenger就是依赖了该aidl文件生成的类,继承了该类的IMessenger.Stub类,实现了send方法,send方法中参数会通过客户端传递过来,最终发送给Handler进行处理。

客户端

客户端首先通过onServiceConnected拿到sevice(Ibinder)对象,这里没什么特殊的,我们平时的写法也是这样的,只不过我们平时会这么写:

IMessenger.Stub.asInterface(service)拿到接口对象进行调用;

我们代码中是

  mService = new Messenger(service);

  public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }

和我们平时aidl写法没有任何区别,通过编写aidl文件,服务端onBind利用Stub编写接口实现返回;客户端利用回调得到IBinder对象,使用IMessager.Stub.asInterface(target)拿到接口实例进行调用;

2)服务端与客户端通信

那么,客户端与服务端通信的确没什么特殊的地方,我们完全也可以编写个类似的aidl文件实现;那么服务端是如何与客户端通信的呢?

还记得,客户端send方法发送的是一个Message,这个Message.replyTo指向的是一个mMessenger,我们在Activity中初始化的。

那么将消息发送到服务端,肯定是通过序列化与反序列化拿到Message对象,我们看下Message的反序列化的代码:

# Message

private void readFromParcel(Parcel source) {
        what = source.readInt();
        arg1 = source.readInt();
        arg2 = source.readInt();
        if (source.readInt() != 0) {
            obj = source.readParcelable(getClass().getClassLoader());
        }
        when = source.readLong();
        data = source.readBundle();
        replyTo = Messenger.readMessengerOrNullFromParcel(source);
        sendingUid = source.readInt();
    }

主要看replyTo,调用的Messenger.readMessengerOrNullFromParcel

 public static Messenger readMessengerOrNullFromParcel(Parcel in) {
        IBinder b = in.readStrongBinder();
        return b != null ? new Messenger(b) : null;
    }


 public static void writeMessengerOrNullToParcel(Messenger messenger,  Parcel out) {
        out.writeStrongBinder(messenger != null ? messenger.mTarget.asBinder() : null);
    }

通过上面的writeMessengerOrNullToParcel可以看到,它将客户端的messenger.mTarget.asBinder()对象进行了恢复,客户端的message.mTarget.asBinder()是什么?

客户端也是通过Handler创建的Messenger,于是asBinder返回的是:

public Messenger(Handler target) {
        mTarget = target.getIMessenger();
    }
 final IMessenger getIMessenger() {
        synchronized (mQueue) {
            if (mMessenger != null) {
                return mMessenger;
            }
            mMessenger = new MessengerImpl();
            return mMessenger;
        }
    }

    private final class MessengerImpl extends IMessenger.Stub {
        public void send(Message msg) {
            msg.sendingUid = Binder.getCallingUid();
            Handler.this.sendMessage(msg);
        }
    }

   public IBinder getBinder() {
        return mTarget.asBinder();
    }

那么asBinder,实际上就是MessengerImpl extends IMessenger.Stub中的asBinder了。

#IMessenger.Stub

@Override 
public android.os.IBinder asBinder(){
return this;
}

那么其实返回的就是MessengerImpl对象自己。到这里可以看到message.mTarget.asBinder()其实返回的是客户端的MessengerImpl对象。

msgfromClient.replyTo.send(msgToClient);

public void send(Message message) throws RemoteException {
        mTarget.send(message);
    }

这个mTarget实际上就是对客户端的MessengerImpl对象的封装,那么send(message)(屏蔽了transact/onTransact的细节),这个message最终肯定传到客户端的handler的handleMessage方法中。

总结下:

客户端与服务端通信,利用的aidl文件,没什么特殊的
服务端与客户端通信,主要是在传输的消息上做了处理,让Messager.replyTo指向的客户端的Messenger,而Messenger又持有客户端的一个Binder对象(MessengerImpl)。服务端正是利用这个Binder对象做的与客户端的通信。

你可能感兴趣的:(Android基于Message的进程间通信之Messenger使用及解析)