使用Messenger类

客户端

public class MainActivity extends AppCompatActivity {

    boolean bound=false;
    Intent intent;
    Messenger messengerSend;
    Messenger messengerRecv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        intent = new Intent(this,CustomBindService.class);
        bindService(intent,sc,Context.BIND_AUTO_CREATE);
    }

    Handler handler = new Handler(){

        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.e("androidLog","what="+msg.what);
        }
    };

    public void btnClick(View view) {
        switch (view.getId()){
            case R.id.btnStart:
                Message msg = new Message();
                msg.what=100;
                messengerRecv = new Messenger(handler);
                msg.replyTo=messengerRecv;
                try {
                    messengerSend.send(msg);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            case R.id.btnStop:
                stopService(intent);
                break;
        }
    }

    ServiceConnection sc= new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            messengerSend = new Messenger(service);
            bound = true;
        }

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

服务端

public class CustomBindService extends Service {

    Messenger messengerRev;
    Messenger messengerReply;

    public CustomBindService() {
        messengerRev = new Messenger(handler);
    }

    Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Log.e("androidLog","what="+msg.what);
            messengerReply = msg.replyTo;
            Message message = new Message();
            message.what=50;
            try {
                messengerReply.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

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

 

Messenger
Messenger，信使，作为进程间通信之一，内部原理是AIDL。

AIDL教程，可以去AIDL传送门了解。
使用
使用Messenger让服务端和客户端进行通信
服务端

新建服务

新建MessengerService，继承Service。

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


新建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)向客户端回复消息。

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

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


返回Binder

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

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

注册 MessagerService

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

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

创建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;
    }
});


创建信使Messenger clientMessager 。

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


连接远程服务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();
    }
}


向服务端发送消息

// 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向客户端回送消息。