Android 进程通讯之Messenger

Android 进程通讯有很好几种，比如：

1> Bundle 

2> 文件共享

3> AIDL

4> Messenger

5> ContentPrivider

6> Socket

现在只讲 Messenger ，Messenger是基于 AIDL的封装。让我们在不需要自己去编写AIDL 的情况下，使用进程通讯。

========================================

                 客户端 -- 服务端 单向 通讯       

========================================

 

=========== Step1： 配置多配进程 =============

说到多进程，首先要在 AndroidManifest 配置两个进程，如：

<activity android:name=".messenger.MessengerActivity">
</activity>

<service android:name=".messenger.MessengerService"
                android:process=":msgservice">
</service>

 

activity 没有配置进程，就默认在App进程 com.leo.dicaprio.myutilapp里面，

service配置了进程，所以在 com.leo.dicaprio.myutilapp.msgservice 进程里面

运行起来，在Android Studio 可以看到两个进程

 

=========== Step2 ： 创建服务端  =============

创建一个服务Service,Service内部了维护了一个Handler，Handler的作用是处理通讯数据。使用Handler去创建Messenger。

Messenger是进程通讯的桥梁。但绑定服务时，会返回给客户端。

class MessengerService : Service() {

    companion object {
        const val WHAT = 1000
        const val CLIENT_DATA = "client_data"
    }

    private val handler = object : Handler() {
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
            if (msg?.what == WHAT) {
                val string = msg.data.getString(CLIENT_DATA)
                Log.d("MessengerService","content : $string")
            }
        }
    }

    private val mMessenger = Messenger(handler)

    override fun onBind(intent: Intent?) = mMessenger.binder
}

 

=========== Step3 ： 创建客户端  =============

绑定服务Service，成功绑定Service后，获取服务端返回的Binder创建Messenger，然后用Messenger 向服务端发送数据。

class MessengerActivity : AppCompatActivity() {

    companion object {
        fun launch(context: Context) {
            context.startActivity<MessengerActivity>()
        }
    }


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_messenger)

        //绑定服务
        val intent = Intent(this, MessengerService::class.java)
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
    }


    private val serviceConnection = object : ServiceConnection {

        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            //通过获取服务端返回的 IBinder 创建 Messenger
            val messenger = Messenger(service)

            //创建 Message
            val msg = Message()
            msg.what = MessengerService.WHAT
            val bundle = Bundle()
            bundle.putString(MessengerService.CLIENT_DATA, "this is a client message")
            msg.data = bundle

            //Messenger 把 Message 发出去
            messenger.send(msg)
        }

        override fun onServiceDisconnected(name: ComponentName?) {
        }
    }

    override fun onDestroy() {
        unbindService(serviceConnection)
        super.onDestroy()
    }

来，看下结果.....明显。客户端通过 Messenger 发送了 message给 服务端，服务端的Handler 收到Message解析成功，打印..

 

到了这里，最基本的进程通讯就完成。但是上面的只是 客户端 → 服务端 单向通讯，那需要 客户端 -- 服务端 双向通讯呢？

好，下面就来一波....

 

========================================

                 客户端 -- 服务端  双向 通讯       

========================================

 

===== Step1 ： 创建客户端  =====

其实只是在原来基础，消息 多配置了一个 Messenger ，传这个Messenger 传给服务端，服务端拿到这个Messenger

就通过其发送消息给客户端。

class MessengerActivity : AppCompatActivity() {

    companion object {
        fun launch(context: Context) {
            context.startActivity<MessengerActivity>()
        }
    }


    private val handler = object : Handler() {
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
            if (msg?.what == MessengerService.WHAT) {
                val data = msg.data
                val string = data.getString(MessengerService.SERVICE_DATA)
                Log.d("MessengerService", "content : $string")
            }
        }
    }

    private val clientMessenger = Messenger(handler)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_messenger)

        //绑定服务
        val intent = Intent(this, MessengerService::class.java)
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
    }

    private val serviceConnection = object : ServiceConnection {

        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            //通过获取服务端返回的 IBinder 创建 Messenger
            val messenger = Messenger(service)

            //创建 Message
            val msg = Message()
            msg.what = MessengerService.WHAT
            val bundle = Bundle()
            bundle.putString(MessengerService.CLIENT_DATA, "这是客户端发出的消息")
            msg.data = bundle

            // 设置 一个 Messenger 给服务端
            msg.replyTo = clientMessenger

            //Messenger 把 Message 发出去
            messenger.send(msg)
        }

        override fun onServiceDisconnected(name: ComponentName?) {
        }
    }

    override fun onDestroy() {
        unbindService(serviceConnection)
        super.onDestroy()
    }
    
}

对比一下，就是 多了 ：msg.replyTo = clientMessenger   这行代码，以及 创建 clientMessenger   的代码。比较简单

 

 

===== Step2 ： 创建服务端  =====

服务端也简单，就是拿到 Messenger ，通过 Messenger 发消息....

class MessengerService : Service() {

    companion object {
        const val WHAT = 1000
        const val CLIENT_DATA = "client_data"
        const val SERVICE_DATA = "service_data"
    }

    private val handler = object : Handler() {
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
            if (msg?.what == WHAT) {
                val string = msg.data.getString(CLIENT_DATA)
                Log.d("MessengerService", "content : $string")

                //通过 message 获取 Messenger
                val messenger = msg.replyTo
                val replyMessage = Message()
                replyMessage.what = WHAT
                val bundle = Bundle()
                bundle.putString(SERVICE_DATA, "这是服务端发出的消息")
                replyMessage.data = bundle

                //通过 Messenger 发送 message
                messenger.send(replyMessage)
            }
        }
    }

    private val mMessenger = Messenger(handler)

    override fun onBind(intent: Intent?) = mMessenger.binder
}

好了，看下运行结果：

 

好了，到这里，基本上展示Messenger 基本用法...

 

以上代码亲测没问题，有问题请留言。谢谢！