Android Messenger使用教程

Messenger

Messenger，信使，作为进程间通信之一，内部原理是AIDL。
AIDL教程，可以去AIDL传送门了解。

使用

使用Messenger让服务端和客户端进行通信

服务端

1. 新建服务
   新建MessengerService，继承Service。

public class MessagerService extends Service {
    public MessagerService() {
    }
}

2. 新建Handler，来处理客户端发送的消息

public static final int WHAT_TO_SERVER = 1;
public static final int WHAT_TO_CLIENT = 2;
/**
 * 服务端handler，用来处理client发来的message
 */
private Handler serverHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        if (null == msg) {
            return false;
        }
        switch (msg.what) {
            case WHAT_TO_SERVER:
                System.out.println("Message to client:" + msg.arg1);
                Messenger client = msg.replyTo;
                if (null == client) {
                    System.out.println("client null");
                    return false;
                }
                Message toClient = Message.obtain(null, WHAT_TO_CLIENT);
                toClient.arg1 = 101;
                try {
                    client.send(toClient);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            default:
                break;
        }
        return false;
    }
});

通过客户端发送过来的消息Message msg，调用msg.replyto获得客户端的信使Messenger client ，通过client.send(toClient)向客户端回复消息。

3. 新建信使Messenger，上一步创建的Handler实例作为参数。

/**
 * 服务端维护的Messenger
 */
private Messenger serverMessenger = new Messenger(serverHandler);

4. 返回Binder

@Override
public IBinder onBind(Intent intent) {
    // 返回Messenger的IBinder
    return serverMessenger.getBinder();
}

在onBind(Intent intent)方法中，返回上一步创建的Messenger.getBinder()。

5. 注册 MessagerService

<service
    android:name=".MessagerService"
    >
        <action android:name="com.jqchen.server.MessagerService"/>
    intent-filter>
service>

在注册文件AndroidManifest.xml文件中注册服务，设置action。

客户端

1. 创建Handler用来处理服务端发送的消息

public static final int WHAT_TO_SERVER = 1;
public static final int WHAT_TO_CLIENT = 2;
/**
 * 处理client接收的消息
 */
private Handler clientHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        if (null == msg) {
            return false;
        }
        switch (msg.what) {
            case WHAT_TO_CLIENT:
                System.out.println("Messager from server:" + msg.arg1);
                break;
            default:
                break;
        }
        return false;
    }
});

2. 创建信使Messenger clientMessager 。

/**
 * client信使
 */
private Messenger clientMessager = new Messenger(clientHandler);

3. 连接远程服务MessengerService，新建Messenger serverMessenger，用来向服务端发送消息。

/**
 * server信使
 */
private Messenger serverMessenger;
/**
 * messenger连接
 */
private ServiceConnection messagerConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        serverMessenger = new Messenger(service);
        System.out.println("Messager Service connect");
    }
    @Override
    public void onServiceDisconnected(ComponentName name) {
        System.out.println("Messager Service disconnect");
    }
};

/**
 * 绑定远程MessagerService
 */
private void messagerConnect() {
    try {
        Intent intent = new Intent();
        intent.setAction("com.jqchen.server.MessagerService");
        intent.setPackage("com.jqchen.server");
        bindService(intent, messagerConnection, BIND_AUTO_CREATE);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

4. 向服务端发送消息

// not connect
if (null == serverMessenger) {
    System.out.println("未连接");
    return;
}
// send messager
Message toServer = Message.obtain(null, WHAT_TO_SERVER);
toServer.arg1 = 100;
toServer.replyTo = clientMessager;
try {
    serverMessenger.send(toServer);
} catch (RemoteException e) {
    e.printStackTrace();
}

首先新建消息Message toServer ,将toServer.replyTo = clientMessager，这样，对应于服务端接收到此消息，获取到clientMessager，用此clientMessager向客户端回送消息。