Android 为更新的布尔值添加流

我有一个听众：

class Owner { 
    private lateinit var flow: Flow<Boolean>

    init {
        flow = callbackFlow {
        val callback = object : Listener {

            override fun onExit() {
                offer(false)
            }

            override fun onEnter() {
                offer(true)
            }
        }
        MyService.register(callback)
        awaitClose {
            //service.unregister(callback)
        }
    }

    fun getFlow(): Flow<Boolean> = flow 

}

类所有者{
私有lateinit变量流：流
初始化{
流量=回流{
val callback=object:Listener{
重写{
报价（假）
}
覆盖有趣的onEnter（）{
报价（真实）
}
}
MyService.register（回调）
等待结束{
//服务。取消注册（回调）
}
}
fun getFlow（）：Flow=Flow
}

因此，我希望每次调用回调时，流都会得到更新，观察流的任何其他类都会自然得到通知。如何做到这一点

---

如果我想在没有回调的情况下也将值设置为

true

或

false

，我可以这样做吗？

这里有一些自包含的代码，可以证明您的基本设计可以按您的预期工作。它注册两个监听器，启动

MyService

，让监听器观察一些事件，取消一个监听器，让其他监听器r one继续运行一段时间，然后取消所有操作并干净地完成

因此，你提出的问题实际上并没有指向任何需要解决的问题

import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlin.concurrent.thread

fun main() = runBlocking<Unit> {
    val owner = Owner()
    val consumer1 = launch {
        owner.flow.collect {
            println("listener 1: $it")
        }
    }
    val consumer2 = launch {
        owner.flow.collect {
            println("listener 2: $it")
        }
    }
    delay(100)
    MyService.start()
    delay(600)
    println("Cancelling consumer 2")
    consumer2.cancel()
    delay(600)
    MyService.stop()
    consumer1.cancel()
}

class Owner {
    val flow = callbackFlow() {
        val callback = object : Listener {
            override fun onEnter() {
                offer(true)
            }
            override fun onExit() {
                offer(false)
            }
        }

        MyService.register(callback)
        awaitClose {
            MyService.unregister(callback)
        }
    }
}

object MyService {
    private val listeners = LinkedHashSet<Listener>()
    @Volatile
    private var keepGoing = true

    fun register(listener: Listener) {
        listeners.add(listener)
    }

    fun unregister(listener: Listener) {
        listeners.remove(listener)
    }

    fun start() = thread {
        while (keepGoing) {
            listeners.forEach {
                it.onEnter()
            }
            Thread.sleep(100)
            listeners.forEach {
                it.onExit()
            }
            Thread.sleep(200)
        }
    }

    fun stop() {
        keepGoing = false
    }
}

interface Listener {
    fun onExit()
    fun onEnter()
}

---

@DrawnAccount在此崩溃时出现异常：

kotlinx.coroutines.channels.ClosedSendChannelException:Channel已关闭

正如它所说，这是因为您一直在关闭的通道中发送值（提供/发送）.

使用waitClose作为使其运行的最后一条语句。当流使用者取消流收集或基于回调的API手动调用SendChannel.close时，将调用waitClose参数。

当作业取消时，它也将关闭。在waitClose中，您应该注销回调。您可以发布代码吗？我添加了代码。而不是ks要获得帮助，请查看@DrawnRaContry以取消注释

服务。取消注册（回调）

。当然，注册和取消注册必须在同一个服务实例上使用。我没有注意到区别，但我会按照链接

fun getFlow（）：Flow=callbackFlow{…}

或

fun getFlow（）中的示例进行操作（服务：MyService）：Flow=callbackFlow{…}

listener 1: true
listener 2: true
listener 1: false
listener 2: false
listener 1: true
listener 2: true
listener 1: false
listener 2: false
Cancelling consumer 2
listener 1: true
listener 1: false
listener 1: true
listener 1: false

Process finished with exit code 0