Android的进阶学习(五)--Messenger的使用和理解

有了上一篇《Android的进阶学习(四)--AIDL的使用与理解》的知识后,现在我们看Messenger就会更加容易了。所以,如果你还没有看《Android的进阶学习(四)--AIDL的使用与理解》,推荐看后再看这篇。


Messenger

Messenger就是基于Message的进程间通信,也就是我们可以向在线程间利用Handler.send(Message)一样,所以用起来是非常简单的。

由上篇文章,我们知道我们可以编写aidl文件来进行进程间的通讯,而现在,我们用Messnger就不需要显式使用aidl文件了,为什么说不是显式呢?看完你就懂了。

Messenger的使用

明白一个类的原理前,首先就因该学会使用,毕竟我们的最终目的是搞明白原理,让我们能够更好的使用。
这里我们还是选择一个远程的ServiceActivity之间的通信吧。

Service服务端

首先,我们写一个服务端Service

public class MyService extends Service {


    public final static String TAG = "MyService";

    public final static int SERVICEID = 0x0001;
    private Messenger messenger = new Messenger(new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if (msg.arg1 == SERVICEID) {
              //接受从客户端传来的消息
                Log.d(TAG, "客服端传来的消息===>>>>>>");
                String str = (String) msg.getData().get("content");
                Log.d(TAG, str);

                //发送数据给客户端
                Message msgTo = Message.obtain();
                msgTo.arg1 = 0X0002;
                Bundle bundle = new Bundle();
                bundle.putString("content", "我是从服务器来的字符串");
                msgTo.setData(bundle);
                try {
                    //注意,这里把数据从服务器发出了
                    msg.replyTo.send(msgTo);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    });

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreat");
    }

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

看看我们的`Service`服务端,可谓是真的很简单,我们首先生成的一个`messenger`并个这个`messenger`的构造函数中出入了一个`Handler`对象。然后在`onBind`方法中返回了一个`messenger.getBinder()`,思路也是相当的清晰。我们注意到在`Handler`中我们接受到消息后又给客户端发送了一条消息`msg.replyTo(msgTo)`,恩,`Messnger`是可以相互发送消息的。当然,这也就要求在客户端和服务端都有自己的`Messnger`。

最后,我们要么就直接安装运行`Service`,要么就注册`Service`的时候加上`Process`属性,因为我们要测试的是跨进程通信了。


######Activity客户端

 我们的`Activity`也是相当简单的,所以还是先上代码:


public class MainActivity extends AppCompatActivity {

 public final static String TAG = "MainActivity";
 public final static int ACTIVITYID = 0X0002;
 //客户端的Messnger
 private Messenger aMessenger = new Messenger(new Handler() {
     @Override
     public void handleMessage(Message msg) {
         super.handleMessage(msg);
         if (msg.arg1 == ACTIVITYID) {
          //客户端接受服务端传来的消息
             Log.d(TAG, "服务端传来了消息=====>>>>>>>");
             String str = (String) msg.getData().get("content");
             Log.d(TAG, str);
         }
     }
 });

//服务端传来的Messenger
 Messenger sMessenger;

 ServiceConnection serviceConnection = new ServiceConnection() {
     @Override
     public void onServiceConnected(ComponentName name, IBinder service) {
         sMessenger = new Messenger(service);

         Message message = Message.obtain();
         message.arg1 = 0x0001;
         //注意这里,把`Activity`的`Messenger`赋值给了`message`中,当然可能你已经发现这个就是`Service`中我们调用的`msg.replyTo`了。
         message.replyTo = aMessenger;

         Bundle bundle = new Bundle();
         bundle.putString("content", "我就是Activity传过来的字符串");
         message.setData(bundle);

         try {
           //消息从客户端发出
             sMessenger.send(message);
         } catch (RemoteException e) {
             e.printStackTrace();
         }
     }

     @Override
     public void onServiceDisconnected(ComponentName name) {
         Log.e(TAG, "连接Service失败");
     }
 };

 @Override
 protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
     startAndBindService();
 }

 private void startAndBindService() {
     Intent service = new Intent(MainActivity.this, MyService.class);
     startService(service);
     bindService(service, serviceConnection, Context.BIND_AUTO_CREATE);
 }

} ```

这里和上一篇的代码布局都几乎是一样的,只是这里我们把serviceConnection成功返回的IBinder转换成的是Messnger而已,接着就调用而messenger.send(message);,就这样,我们的消息就发送出了,和同一线程里面的消息发送几乎一样,只是这里的handmessage(Message message)是在不同的进程。
当然,为了接受从服务端发来的消息,我们在Activity中定义了一个Messenger,并且在客户端发给服务端的消息(Message)中把客户端的Messenger给赋值进Message中。

就这样,最简单的Messenger就完成了。

Demo运行结果

客户端:

Paste_Image.png

服务端:

Paste_Image.png

可见,当我们的服务端接收到消息后,就向客户端发出了一条消息。这种情况在我们的项目中也是经常可见的,例如,你下载一个很大的东西时,就直接开一个进程去下,让后下载完成后再将文件路径给发送给客户端......当然,这个demo中我们什么都没有去处理就直接返回了,在服务端是会有逻辑的,这里就没有过多的演示了。


Messenger的理解

知其所以然,我们就接着看看Messenger到底是何方神圣?

首先,我们还是从Service中看起,还记得我们在Servicenew了一个Messenger并且传入了一个Handler吧,然后在onBind()方法中就返回了一个messenger.getBinder()

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

一看,里面返回的就是mTarget.asBinder(),然后我们就找找mTarget

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

结果在Messenger的构造函数中发现了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);
      }
  }

getIMessenger()中就简单的判断一下mMessenger是否存,不存在的话就new一个返回,存在的话就直接返回,还是很简单的。接着我们就看看这个MessengerImpl到底是个什么东西?
由源码我们发现MessengerImpl就是Hnadler的一个内部类,然后继承于IMessenger.Stub。看到这里,或许就已经发现了,这和aidl中生成的类不是一样的吗?的确,这里就是实现的一个aidl文件。在这个类中,实现了以一个send方法,这个方法中调用了Handler.sendMessage()方法,这也就是为什么,我们的消息来得时候会出现在handlerMessage()中。这里,我们在理一下,客户端在调用send方法的时候,由于在不同的进程,传送的数据先回被序列化,然后进行跨进程传送,最后到了服务端进行解析,对应调用send方法执行。

不知道是否还记得,我们在用aidl通信的时候,我们在Service中首先要生成一个XXXX.Stub的实现类,然后再在onBind()中返回一个XXXX.Stub的引用。
现在我们在回首看一下,我们在Service中返回的mTarget.asBinder()其实就是MessengerImpl,当然asBinder()返回的就是自己本身。

当然,还有个问题我们得注意,就是服务端给客户端发送的消息。从demo中我们知道,我们在Serivice中使用msg.replyTo.send(msgTo);进行向客户端发送消息。而msgreplyTo这个属性在客户端中就是由客户端生成的Messenger。其实这里也是好理解的,首先,我们这里的跨进程主要就是通过Binder的,即我们在客户端和服务端传递Binder来进行通信。而这里的Messnger也就是一个包装了的Binder

Messenger.png

图画得很简单,但是也足以说明问题了。这里我们有两个进程,一个进程A,一个进程B,其中每个进程中我们都生成了一个相应的进程。接着就该注意一下了,当我们从A到B发送消息时,我们使用的是MessengerB.send(Message),B到A的时候是MessengerA.send(Message),这时候你可能就纳闷了,为什么不是用相应的发送?进程A中的MessengerB又是怎样来的?

联系上面的demo这就很说明问题了,我们假设进程A是客户端,B是服务端。那么进程A(Activity)中通过ServiceConnection就得到了进程B(Service)中Messenger中包装的Binder,在自己包装一下,就是MessengerB了。这也和上一篇中的在客户端调用aidl文件接口方法联系起来。

然后,我们需要知道的就是进程B(Service)中是怎样有进程A(Activity)的MessengerA的了?其实我想你已经明白了,就是在进程A给进程B发送的Message中,我们把MessengerA给传了过去。回想上面的代码,我们在客户端进行的message.replyTo = aMessenger;和在服务端进行的msg.replyTo.send(msgTo);就是把MessengerA给进行写入和读取。现在是不是有一种大彻大悟的感觉?如果没有,那就慢慢再理一下吧!


aidl实现双向通信

看了Messenger的实现方式,我们想一下用aidl来实现客户端与服务端的双向通信也是很容易的,那就在上一篇文章的基础上理一下思路吧。

1.我们在服务端aidl定义一个方法,接受一个Binder。
2.在客户端中我们也通过aidl生成一个Binder,然后当我们通过ServicConnection获取到服务端的Binder后,再调用接受Bindler的那个方法,并把客户端中生成的Binder给传进去。
3.服务端相应客户端请求的方法时,在调用客户端Binder发送消息即可。

基本思路就是这样,当然肯定没有谷歌的Messenger完美,但是可以加强我们对aidlMessenger的理解了。

总结

搞什么嘛,最后还不就是aidl,就是封装了一下而已。这也就是文章开头所说的不显式使用aidl


最后

我一个苦逼的大学生,而且专业还不对口,希望写写东西,加强理解与记忆,同时也希望自己的理解能帮到更多的人。所以,有什么错误的,写得不好的,希望指出,共同进步。

还有,这些是我参考《Android开发艺术探索》的,对,就是任大大的。

推荐阅读更多精彩内容