尝试将 SavedStateHandle.getLiveData() 公开为 MutableStateFlow，但 UI 线程冻结

Question

我正在尝试使用以下代码：

suspend fun <T> SavedStateHandle.getStateFlow(
    key: String,
    initialValue: T? = get(key)
): MutableStateFlow<T?> = this.let { handle ->
    withContext(Dispatchers.Main.immediate) {
        val liveData = handle.getLiveData<T?>(key, initialValue).also { liveData ->
            if (liveData.value === initialValue) {
                liveData.value = initialValue
            }
        }

        val mutableStateFlow = MutableStateFlow(liveData.value)

        val observer: Observer<T?> = Observer { value ->
            if (value != mutableStateFlow.value) {
                mutableStateFlow.value = value
            }
        }

        liveData.observeForever(observer)

        mutableStateFlow.also { flow ->
            flow.onCompletion {
                withContext(Dispatchers.Main.immediate) {
                    liveData.removeObserver(observer)
                }
            }.onEach { value ->
                withContext(Dispatchers.Main.immediate) {
                    if (liveData.value != value) {
                        liveData.value = value
                    }
                }
            }.collect()
        }
    }
}

我正在尝试像这样使用它：

    // in a Jetpack ViewModel
    var currentUserId: MutableStateFlow<String?>
        private set

    init {
        runBlocking(viewModelScope.coroutineContext) {
            currentUserId = state.getStateFlow("currentUserId", sessionManager.chatUserFlow.value?.uid)
            // <--- this line is never reached
        }
    }

UI 线程冻结。我有一种感觉，因为collect()我正在尝试创建由封闭协程上下文管理的内部订阅，但我还需要将此 StateFlow 作为一个字段。还有值的交叉写入（如果任何一个更改，如果它是一个新值，则更新另一个）。

总的来说，这个问题似乎喜欢collect()暂停，因为我在getStateFlow().

有谁知道创建 Flow 的“内部订阅”的好方法，而不会最终冻结周围的线程？的runBlocking {需要，这样我可以同步在视图模型构造函数赋值到外地。（这在“结构化并发”的范围内甚至可能吗？）

Answer 1

编辑：

// For more details, check: https://gist.github.com/marcellogalhardo/2a1ec56b7d00ba9af1ec9fd3583d53dc
fun <T> SavedStateHandle.getStateFlow(
    scope: CoroutineScope,
    key: String,
    initialValue: T
): MutableStateFlow<T> {
    val liveData = getLiveData(key, initialValue)
    val stateFlow = MutableStateFlow(initialValue)

    val observer = Observer<T> { value ->
        if (value != stateFlow.value) {
            stateFlow.value = value
        }
    }
    liveData.observeForever(observer)

    stateFlow.onCompletion {
        withContext(Dispatchers.Main.immediate) {
            liveData.removeObserver(observer)
        }
    }.onEach { value ->
        withContext(Dispatchers.Main.immediate) {
            if (liveData.value != value) {
                liveData.value = value
            }
        }
    }.launchIn(scope)

    return stateFlow
}

原来的：

您可以搭载 SavedStateHandle 中的内置通知系统，以便

val state = savedStateHandle.getLiveData<State>(Key).asFlow().shareIn(viewModelScope, SharingStarted.Lazily)

...
savedStateHandle.set(Key, "someState")

变异器不是通过 的方法发生的MutableLiveData，而是通过 的SavedStateHandle，它将在外部更新 LiveData（以及流程）。

Answer 2

我处于类似的位置，但我不想通过 LiveData 修改该值（如已接受的解决方案中所示）。我想仅使用流并将 LiveData 保留为状态句柄的实现细节。

我也不想var在 init 块中初始化它。我更改了您的代码以满足这两个约束，并且它不会阻塞 UI 线程。语法如下：

 val currentUserId: MutableStateFlow<String?> = state.getStateFlow("currentUserId", viewModelScope, sessionManager.chatUserFlow.value?.uid)

我提供了一个范围并使用它来启动一个协程来处理流的 onCompletion 和集合。这是完整的代码：

fun <T> SavedStateHandle.getStateFlow(
    key: String,
    scope: CoroutineScope,
    initialValue: T? = get(key)
): MutableStateFlow<T?> = this.let { handle ->
    val liveData = handle.getLiveData<T?>(key, initialValue).also { liveData ->
        if (liveData.value === initialValue) {
            liveData.value = initialValue
        }
    }
    val mutableStateFlow = MutableStateFlow(liveData.value)

    val observer: Observer<T?> = Observer { value ->
        if (value != mutableStateFlow.value) {
            mutableStateFlow.value = value
        }
    }
    liveData.observeForever(observer)

    scope.launch {
        mutableStateFlow.also { flow ->
            flow.onCompletion {
                withContext(Dispatchers.Main.immediate) {
                    liveData.removeObserver(observer)
                }
            }.collect { value ->
                withContext(Dispatchers.Main.immediate) {
                    if (liveData.value != value) {
                        liveData.value = value
                    }
                }
            }
        }
    }
    mutableStateFlow
}