BindService ---使用Messenger在服务端接收信息给客户端发送的消息

﹏ヽ暗。殇╰゛Y 2023-06-20 10:47 24阅读 0赞

1，BindService ---使用Messenger

*  我们接着来了解服务与远程进程（即不同进程间）通信，而不同进程间的通信，最简单的方式就是使用 Messenger 服务提供通信接口，利用此方式，我们无需使用 AIDL 便可执行进程间通信 (IPC)。以下是 Messenger 使用的主要步骤：

【1】服务实现一个 Handler，由其接收来自客户端的每个调用的回调

【2】Handler 用于创建 Messenger 对象（对 Handler 的引用）

【3】Messenger 创建一个 IBinder，服务通过 onBind() 使其返回客户端

【4】客户端使用 IBinder 将 Messenger（引用服务的 Handler）实例化，然后使用Messenger将 Message 对象发送给服务

【5】服务在其 Handler 中（在 handleMessage() 方法中）接收每个 Message

2， Messenger 接口的简单服务示例

*  在服务端解释客户端发送的消息

【1】创建一个服务类MessengerService继承自Service

*  同时创建一个继承自Handler的IncomingHandler对象来接收客户端进程发送过来的消息并通过其handleMessage(Message msg)进行消息处理。
 *  接着通过IncomingHandler对象创建一个Messenger对象，该对象是与客户端交互的特殊对象，
 *  然后在Service的onBind中返回这个Messenger对象的底层Binder即可。

package com.ipctest.messenger;
    import android.app.Service;
    import android.content.Intent;
    import android.os.Handler;
    import android.os.IBinder;
    import android.os.Message;
    import android.os.Messenger;
    import android.util.Log;
    /**
    * Description:Messenger服务端简单实例,服务端进程
    */
    public class MessengerService extends Service {
    
    
        /** Command to the service to display a message */
        static final int MSG_SAY_HELLO = 1;
        private static final String TAG ="wxs" ;
    
    
        /**
         * 用于接收从客户端传递过来的数据
         */
        class IncomingHandler extends Handler {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MSG_SAY_HELLO:
                        Log.i(TAG, "thanks,Service had receiver message from client!");
                        break;
                    default:
                        super.handleMessage(msg);
                }
            }
        }
    
    
        /**
         * 创建Messenger并传入Handler实例对象
         */
        final Messenger mMessenger = new Messenger(new IncomingHandler());
    
    
        /**
         * 当绑定Service时,该方法被调用,将通过mMessenger返回一个实现
         * IBinder接口的实例对象
         */
        @Override
        public IBinder onBind(Intent intent) {
            Log.i(TAG, "Service is invoke onBind");
            return mMessenger.getBinder();
        }
    }

【2】客户端进程，

*  我们需要创建一个ServiceConnection对象，该对象代表与服务端的链接，
 *  当调用bindService方法将当前Activity绑定到MessengerService时，onServiceConnected方法被调用，利用服务端传递给来的底层Binder对象构造出与服务端交互的Messenger对象，接着创建与服务交互的消息实体Message，将要发生的信息封装在Message中并通过Messenger实例对象发送给服务端。

package com.ipctest.messenger;
    import android.app.Activity;
    import android.content.ComponentName;
    import android.content.Context;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.os.Message;
    import android.os.Messenger;
    import android.os.RemoteException;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    import com.ipctest.R;
    
    /**
    
    * Description: 与服务器交互的客户端
    */
    public class ActivityMessenger extends Activity {
        /**
         * 与服务端交互的Messenger
         */
        Messenger mService = null;
    
        /** Flag indicating whether we have called bind on the service. */
        boolean mBound;
        /**
         * 实现与服务端链接的对象
         */
        private ServiceConnection mConnection = new ServiceConnection() {
            public void onServiceConnected(ComponentName className, IBinder service) {
                /**
                 * 通过服务端传递的IBinder对象,创建相应的Messenger
                 * 通过该Messenger对象与服务端进行交互
                 */
                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;
            // 创建与服务交互的消息实体Message
            Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
            try {
                //发送消息
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_messenager);
            Button bindService= (Button) findViewById(R.id.bindService);
            Button unbindService= (Button) findViewById(R.id.unbindService);
            Button sendMsg= (Button) findViewById(R.id.sendMsgToService);
    
    
            bindService.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    Log.d("zj","onClick-->bindService");
                    //当前Activity绑定服务端
                    bindService(new Intent(ActivityMessenger.this, MessengerService.class), mConnection,
                            Context.BIND_AUTO_CREATE);
                }
            });
    
    
            //发送消息给服务端
            sendMsg.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    sayHello(v);
                }
            });
    
    
    
    
            unbindService.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    // Unbind from the service
                    if (mBound) {
                        Log.d("zj","onClick-->unbindService");
                        unbindService(mConnection);
                        mBound = false;
                    }
                }
            });
        }
    }

【3】清单目录添加Service

*  android:process=":remote" 表示我们是单独进程中创建的。

<service android:name=".messenger.MessengerService"

android:process=":remote"

【4】运行结果

*  运行效果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw_size_16_color_FFFFFF_t_70][]

*  Log打印

接着多次点击绑定服务，然后发送信息给服务端，最后解除绑定，Log打印如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw_size_16_color_FFFFFF_t_70 1][]

【5】总结：

*  通过上述例子可知Service服务端确实收到了客户端发送的信息，
 *  而且在Messenger中进行数据传递必须将数据封装到Message中，因为Message和Messenger都实现了Parcelable接口，可以轻松跨进程传递数据，
 *  而Message可以传递的信息载体有，what,arg1,arg2,Bundle以及replyTo
 *  至于object字段，对于同一进程中的数据传递确实很实用，但对于进程间的通信，则显得相当尴尬，
 *  在android2.2前，object不支持跨进程传输，但即便是android2.2之后也只能传递android系统提供的实现了Parcelable接口的对象，也就是说我们通过自定义实
 *  Parcelable接口的对象无法通过object字段来传递，因此object字段的实用性在跨进程中也变得相当低了。
 *  不过所幸我们还有Bundle对象，Bundle可以支持大量的数据类型。
 *  接着从Log我们也看出无论是使用拓展Binder类的实现方式还是使用Messenger的实现方式，
 *  它们的生命周期方法的调用顺序基本是一样的，即onCreate()、onBind、onUnBind、onDestroy，而且多次绑定中也只有第一次时才调用onBind()。

关于更多Service内容： [https://blog.csdn.net/cricket\_7/category\_9580061.html][https_blog.csdn.net_cricket_7_category_9580061.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191210090029930.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191210090027144.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NyaWNrZXRfNw==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_cricket_7_category_9580061.html]: https://blog.csdn.net/cricket_7/category_9580061.html