标签: kotlin-stateflow

我遇到过建议切换到 StateFlow 的文章。就像这里的那个一样。同样在新的 Android studio 中，StateFlow 支持自动包含在数据绑定功能中，包括协程依赖项。实时数据已在大多数应用程序中使用。我们应该从 LiveData 迁移到 StateFlow 吗？有什么好处？

假设我有一个MutableStateFlow变量。三种情况的主要区别和用法是什么

mutable.value = 1
mutable.emit(2)
mutable.update {3}

我很困惑，有人可以向我解释一下，这两者之间的主要区别是什么？我很难理解。mutableState 是随 Jetpack Compose 引入的，现在我的问题是，我们是否应该在视图模型中使用它来替代 Mutabel 状态流？它们的目的和主要区别是什么？

我的 viewModel 中有 2 个 stateFlow。为了将它们收集到片段中，我必须启动协程两次，如下所示：

    lifecycleScope.launchWhenStarted {
        stocksVM.quotes.collect {
            if (it is Resource.Success) {
                it.data?.let { list ->
                    quoteAdapter.submitData(list)
                }
            }
        }
    }

    lifecycleScope.launchWhenStarted {
        stocksVM.stockUpdate.collect {
            log(it.data?.data.toString())
        }
    }

如果我有更多的 stateFlow，我必须分别启动协程。有没有更好的方法来处理我的片段/活动或其他地方的多个 stateFlow？

嘿，我正在学习 kotlin 中的流程。我正在学习MutableStateFlow和MutableSharedFlow。我尝试在现实世界的例子中学习MutableStateFlow。但我无法获得MutableSharedFlow示例，它更适合。我尝试了一些MutableStateFlow

例如，当我们从 api 获取数据时，我们可以使用 seal 类来进行相应的填充。

LoggedState.kt

sealed class LoggedState {
    data class OnSuccess(val data: List<XYZ>) : LoggedState()
    object OnEmpty : LoggedState()
    data class IsLoading(val isLoading: Boolean = true) : LoggedState()
    data class OnError(val message: String) : LoggedState()
} 

设置ViewModel.kt

class SettingsViewModel : ViewModel() {

 var loggedMutableStateFlow = MutableStateFlow<LoggedState>(LoggedState.OnEmpty)

 fun fetchData(){
   val result = dataRepository.getLogged()
                result.handleResult(
                    onSuccess = { response ->
                        val data = response?.items
                        if (!data.isNullOrEmpty()) {
                            loggedMutableStateFlow.value …

通过 Viewmodel 中的 LiveData，我们可以像这样使用 switchMap 或 Transformations.map

val recipesList = cuisineType.switchMap { repository.getDisplayRecipes(it.cuisineType).asLiveData() }

使用 StateFlow 实现此目的的最佳方法是什么？我知道我们可以像下面一样使用地图，但是这会返回 Flow<Flow<List<Recipe>>> ，这似乎不正确

val recipeListFlow = cuisineTypeStateFlow.map {
    repository.getDisplayRecipes(it.cuisineType)
}

我正在尝试使用状态流和分页 3 来实现 android MVI 架构，但是当我有一个包含分页数据的视图状态时，我感到很困惑。

问题是我将视图模型中的视图状态公开为状态流对象，但现在在该视图状态内我有另一个来自分页库的流对象。

状态流中可以有一个流吗？如果它\xe2\x80\x99s 不是我应该做什么？

这是我的代码，以供更多说明。

任务库

override fun list(\npageNumber: Int,\npageSize: Int,\ngroupId: Long?,\nquery: String\n): Flow<PagingData<Task>> {\nreturn Pager(\n    config = PagingConfig(\n        pageSize = Consts.PageSize,\n        maxSize = 200,\n        enablePlaceholders = false\n    ),\n    remoteMediator = TaskRemoteMediator(query, groupId, db, taskApi),\n    pagingSourceFactory = {\n        TaskDataSource(taskApi, groupId, query)\n    }\n).flow\n}\n

任务视图模型

viewModelScope.launch {\ntry {\n    _taskListViewState.emit(TaskListViewState.Loading)\n    val tasks = taskRepo.list(1, Consts.PageSize, intent.groupId, "")\n    _taskListViewState.emit(TaskListViewState.Data(tasks))\n} catch (e: Exception) {\n    _taskListViewState.emit(TaskListViewState.Error(R.string.unknown_error))\n}\n}\n

任务列表视图状态

sealed class TaskListViewState {\nobject Idle …

正如我在标题中提到的，我很好奇两者之间的一般差异。你能帮忙吗？我找不到具体的区别，因为互联网上有复杂的例子。

1. 在性能方面有哪些差异？
2. 在哪些场景下有优势？
3. 将 StateFlow 与 Kotlin Flow 结合使用是有利的。但是在使用 LiveData 的项目中不切换到 StateFlow 会有什么风险呢？
4. Google 是否会弃用 LiveData？:)

我有一个登录表格。我用来StateFlow发送LoginResult（调用 API 之后）从ViewModel到Activity。在活动中，如果登录失败，我将显示错误对话框。
第一次运行良好，但从第二次登录失败后，错误对话框将不再显示。我测试了.value两者.emitStateFlow

private val _loginResult = MutableStateFlow(LoginResult())
val loginResult: StateFlow<LoginResult> = _loginResult

fun login(email: String, password: String) {
    viewModelScope.launch {
        when (val result = loginRepository.login(email, password)) {
            is Result.Fail-> {
                _loginResult.value = LoginResult(error = "Login failed")
                // _loginResult.emit(LoginResult(error = "Login failed")) same issue
            }
            ...
       }
   }
}

我正在尝试让显示缩放功能与 JetPack Compose 一起使用。我有一个 ViewModel 将共享首选项值公开为流，但这绝对是不正确的，如下所示：

@HiltViewModel
class MyViewModel @Inject constructor(
    @ApplicationContext private val context: Context
) : ViewModel() {
    private val _densityFactor: MutableStateFlow<Float> = MutableStateFlow(1.0f)
    val densityFactor: StateFlow<Float>
        get() = _densityFactor.asStateFlow()

    private fun getDensityFactorFromSharedPrefs(): Float {
        val sharedPreference = context.getSharedPreferences(
            "MY_PREFS",
            Context.MODE_PRIVATE
        )
        return sharedPreference.getFloat("density", 1.0f)
    }

    // This is what I look at and go, "this is really bad."
    private fun densityFactorFlow(): Flow<Float> = flow {
        while (true) {
            emit(getDensityFactorFromSharedPrefs())
        }
    }

    init {
        viewModelScope.launch(Dispatchers.IO) {
            densityFactorFlow().collectLatest { …