Android-服务Service(Messenger跨进程通讯)

本文学习目标:

  1. 学会如何使用Messenger进行跨进程通讯;
  2. 延伸阅读:
    Android 消息处理机制:https://www.jianshu.com/p/02962454adf7

在上一章中介绍了服务使用,服务启动的两种方式,startService()和bindService(),startService启动的服务,跟启动它的应用组件是没有联系的,因此不管是否跨进程,startService都是可以成功的。而在跨进程服务,bindService()会异常,在onServiceConnected方法中报类型转换异常,说明这时候不能使用这个Binder对象进行转换了。这时候,就需要使用Messenger了。

其实Messenger底层也是使用aidl的方式来实现的,只不过其使用handler来处理消息,因为handler是线程安全的,所以Messenger也是线程安全的,自然Messenger只能处理单线程的问题,如果要使用多线程就该使用aidl的方式实现。

其实,Messenger也是通过bindService的方式,只是需要定义不用的IBinder对象。

主要步骤:

  1. 服务实现Handler,来处理客户端发送的消息Message;
  2. 根据Handler创建一个Messenger对象;
  3. 通过onBinder返回Messenger的Binder对象;
  4. 客户端使用IBinder将Messenger实例化,然后通过Messenger将Message发送给服务;

public class MessengerService extends Service {
    public final static String TAG = MessengerService.class.getSimpleName();
    public final static int MSG_SAY_HELLO = 1;

    public MessengerService() {
    }

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

    @Override
    public void onDestroy() {
        Log.d(TAG, "onDestroy");
        super.onDestroy();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * 1. 定义一个Handler,用于处理客户端发来的请求
     */
    class ProcessHandler extends Handler{

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MSG_SAY_HELLO:
                    Log.d(TAG, "service receiver from client: say hello");
                    break;

                default:
                        super.handleMessage(msg);
            }

        }
    }

    /**
     * 2. 创建一个Messenger并传入Handler实例对象
     */
    final Messenger mMessager = new Messenger(new ProcessHandler());

    @Override
    public IBinder onBind(Intent intent) {
        Log.d(TAG, "onBind");
        // 3.通过onBinder返回Messenger的Binder对象
        return mMessager.getBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.d(TAG, "onUnbind");
        return super.onUnbind(intent);
    }
}

清单定义:

        <service
            android:name=".MessengerService"
            android:enabled="true"
            android:exported="true"
            android:process=":messengerSer"/>
/**
     * 与服务端交互的Messender
     */
    Messenger mService = null;
    boolean mBound = false;
    /**
     * ServiceConnection代表与服务的连接,
     */
    ServiceConnection cnn2 = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            Log.d("###", "onServiceConnected");
            /**
             * 3. 通过服务端传递的IBinder对象,创建相应的Messenger
             * 然后通过Messenger对象与服务端进行交互
             */
            mService = new Messenger(iBinder);
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            Log.d("###", "onServiceDisconnected");
            mService = null;
            mBound = false;
        }
    };
// 绑定服务
Intent intent = new Intent(this, MessengerService.class);
bindService(intent, cnn2, BIND_AUTO_CREATE);
// 解绑服务
unbindService(cnn2);
mBound = false;
// 发送消息
Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO);
try {
    // 4. 通过Messenger发送消息
    mService.send(msg);
} catch (RemoteException e) {
    e.printStackTrace();
}

流程图:


流程图

效果:


image.png

此时,解决了客户端往服务发送消息。如果客户端需要接收服务的消息呢?

我们需要在客户端定义一个Messenger和Handler,然后发送消息的时候传递这个Messenger。

    /**
     * 定义客户端的Messenger和Handler
     */
    Messenger repo = new Messenger(new ClientHandler());

    class ClientHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MessengerService.MSG_REPO_SAY_HELLO:
                    Log.d("####", "client receive from server say hello");
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

发送消息的时候,设置replyTo

Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO);
msg.replyTo = repo; // 传递Messenger
try {
    mService.send(msg);
} catch (RemoteException e) {
    e.printStackTrace();
}

服务在处理Message时候,取出客户端的Messenger,然后发送消息

class ProcessHandler extends Handler{

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MSG_SAY_HELLO:
                    Log.d(TAG, "service receiver from client: say hello");
                    Messenger repo = msg.replyTo; // 获取客户端Messenger
                    Message rmsg = Message.obtain(null, MSG_REPO_SAY_HELLO);
                    try {
                        // 发送消息
                        repo.send(rmsg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;

                default:
                        super.handleMessage(msg);
            }

        }
    }

效果:
服务:


服务收到消息

客户端:


客户端收到消息

推荐阅读更多精彩内容