Service官方教程(8)Bound Service示例之2－跨进程使用Messenger

Compared to AIDL

　　When you need to perform IPC, using a Messenger for your interface is simpler than implementing it with AIDL, because Messenger queues all calls to the service, whereas, a pure AIDL interface sends simultaneous requests to the service, which must then handle multi-threading.

　　For most applications, the service doesn't need to perform multi-threading, so using a Messenger allows the service to handle one call at a time. If it's important that your service be multi-threaded, then you should use AIDL to define your interface.

Using a Messenger

　　If you need your service to communicate with remote processes, then you can use a Messenger to provide the interface for your service. This technique allows you to perform interprocess communication (IPC) without the need to use AIDL.

　　Here's a summary of how to use a Messenger:

　使用Messenger的步骤：

• The service implements a Handler that receives a callback for each call from a client.
• The Handler is used to create a Messenger object (which is a reference to the Handler).
• The Messenger creates an IBinder that the service returns to clients from onBind().
• Clients use the IBinder to instantiate the Messenger (that references the service's Handler), which the client uses to send Message objects to the service.
• The service receives each Message in its Handler—specifically, in the handleMessage() method.

　　In this way, there are no "methods" for the client to call on the service. Instead, the client delivers "messages" (Message objects) that the service receives in its Handler.

　注意，这种方式下，服务端没有函数给客户端调用。它们只能发送消息。

　　Here's a simple example service that uses a Messenger interface:

 public class MessengerService extends Service {
     /** Command to the service to display a message */
     static final int MSG_SAY_HELLO = ;

     /**
      * Handler of incoming messages from clients.
      */
     class IncomingHandler extends Handler {
         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_SAY_HELLO:
                     Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
                     break;
                 default:
                     super.handleMessage(msg);
             }
         }
     }

     /**
      * Target we publish for clients to send messages to IncomingHandler.
      */
     final Messenger mMessenger = new Messenger(new IncomingHandler());

     /**
      * When binding to the service, we return an interface to our messenger
      * for sending messages to the service.
      */
     @Override
     public IBinder onBind(Intent intent) {
         Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
         return mMessenger.getBinder();
     }
 }

　　Notice that the handleMessage() method in the Handler is where the service receives the incoming Message and decides what to do, based on the what member.

　　All that a client needs to do is create a Messenger based on the IBinder returned by the service and send a message using send(). For example, here's a simple activity that binds to the service and delivers the MSG_SAY_HELLO message to the service:

 public class MessengerActivity extends Activity {
     /** Messenger for communicating with the service. */
     Messenger mService = null;

     /** Flag indicating whether we have called bind on the service. */
     boolean mBound;

     /**
      * Class for interacting with the main interface of the service.
      */
     private ServiceConnection mConnection = new ServiceConnection() {
         public void onServiceConnected(ComponentName className, IBinder service) {
             // This is called when the connection with the service has been
             // established, giving us the object we can use to
             // interact with the service.  We are communicating with the
             // service using a Messenger, so here we get a client-side
             // representation of that from the raw IBinder object.
             mService = new Messenger(service);
             mBound = true;
         }

         public void onServiceDisconnected(ComponentName className) {
             // This is called when the connection with the service has been
             // unexpectedly disconnected -- that is, its process crashed.
             mService = null;
             mBound = false;
         }
     };

     public void sayHello(View v) {
         if (!mBound) return;
         // Create and send a message to the service, using a supported 'what' value
         Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, , );
         try {
             mService.send(msg);
         } catch (RemoteException e) {
             e.printStackTrace();
         }
     }

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

     @Override
     protected void onStart() {
         super.onStart();
         // Bind to the service
         bindService(new Intent(this, MessengerService.class), mConnection,
                 Context.BIND_AUTO_CREATE);
     }

     @Override
     protected void onStop() {
         super.onStop();
         // Unbind from the service
         if (mBound) {
             unbindService(mConnection);
             mBound = false;
         }
     }
 }

　　Notice that this example does not show how the service can respond to the client. If you want the service to respond, then you need to also create a Messenger in the client. Then when the client receives the onServiceConnected() callback, it sends a Message to the service that includes the client's Messenger in the replyTo parameter of the send() method.

　　You can see an example of how to provide two-way messaging in the MessengerService.java (service) and MessengerServiceActivities.java (client) samples.