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 基本用法...