Android中Message的使用

Messenger，直译为信使，顾名思义，通过它可以在不同进程中传递Messenger对象传递数据。Messenger是一种轻量级的IPC方案，底层实现是AIDL，通过它的两个构造方法就能明显开出来。

Messenger每次处理一个请求，所以不用考虑线程同步问题。

 

实现一个Messenger有如下步骤：

1. 服务端进程

   创建Service处理客户端连接请求

   创建Handler用于创建Messenger对象

   在Service的onBind中返回Messenger对象底层的Binder即可。

public class MessengerService extends Service {

    private static String TAG = " MessengerService";

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case Constants.MSG_FROM_CLIENT:
                    // 收到客户端消息
                    Log.i(TAG, "receive msg from client:" + msg.getData().getString("msg"));

                    // 还可以对客户端发出回应
                    Messenger client = msg.replyTo;
                    Message replyMessage = Message.obtain(null, 
                            Constants.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "嗯，你的消息我收到了，稍后回复你。");
                    replyMessage.setData(bundle);
                    try {
                        client.send(replyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

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

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

2. 客户端进程

    绑定服务端Service，用服务端返回的IBinder对象创建一个Messger。

    通过Messenger对象发送消息。

public class MessengerActivity extends AppCompatActivity {

    private static final String TAG = "MessengerActivity";

    private Messenger mService;

    @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);
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message msg = Message.obtain(null, Constants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "hello ,this is client.");
            msg.setData(data);
            msg.replyTo = mGetReplyMessenger;
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };

    private Messenger mGetReplyMessenger = new Messenger(new MessengerHandle());

    private static class MessengerHandle extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case Constants.MSG_FROM_SERVICE :
                    Log.i(TAG, "收到服务端消息" + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
}

 

缺点：Messager是串形方式处理客户端请求，服务端需要一个个处理，如果有大量的并非请求，使用Messenger就不太合适了。可以用AIDL来实现跨进程的方法调用。