ViewModel中的StateFlow和SharedFlow，使用建议以及单元测试

StateFlow和SharedFlow都是kotlin中的数据流，官方概念简介如下：

StateFlow：一个状况容器式可观察数据流，能够向其搜集器发出当前状况和新状况。是热数据流。

SharedFlow：SharedFlow是StateFlow的可装备性极高的泛化数据流（StateFlow承继于SharedFlow）

对于两者的基本运用以及差异，此处不做详解，能够参考官方文档。本文会给出一些关于如何在业务中挑选挑选合适暖流(hot flow)的主张，以及单元测验代码。

StateFlow的一般用法如下图所示：

以读取数据库数据为例，Repository担任从数据库读取相应数据并返回一个flow，在ViewModel搜集这个flow中的数据并更新状况(StateFlow)，在MVVM模型中，ViewModel中露出出来的StateFlow应该是UI层中仅有的可信数据来历，注意是仅有，这点跟运用LiveData的时分不同。

咱们应该在ViewModel中露出出暖流(StateFlow或许SharedFlow)而不是冷流(Flow)

假如咱们假如露出出的是普通的冷流，会导致每次有新的流搜集者时就会触发一次emit，形成资源糟蹋。所以假如Repository供给的只有简单的冷流怎么办？很简单，将之转换成暖流就好了！通常能够选用以下两种方法：

1、还是正常搜集冷流，搜集到一个数据就往别的构建的StateFlow或SharedFlow发送

2、运用stateIn或shareIn拓宽函数转换成暖流

已然官方给咱们供给了拓宽函数，那肯定是直接运用这个方案最好，运用方法如下：

private const val DEFAULT_TIMEOUT = 500L
@HiltViewModel
class MyViewModel @Inject constructor(
    userRepository: UserRepository
): ViewModel() {
    val userFlow: StateFlow<UiState> = userRepository
        .getUsers()
        .asResult() // 此处返回Flow<Result<User>>
        .map { result ->
            when(result) {
                is Result.Loading -> UiState.Loading
                is Result.Success -> UiState.Success(result.data)
                is Result.Error -> UiState.Error(result.exception)
            }
        }
        .stateIn(
            scope = viewModelScope,
            initialValue = UiState.Loading,
            started = SharingStarted.WhileSubscribed(DEFAULT_TIMEOUT) 
        )
        // started参数确保了当装备改动时不会重新触发订阅
}

在一些业务复杂的页面，比方主页，通常会有多个数据来历，也就有多个flow，为了确保单一牢靠数据源原则，咱们能够运用combine函数将多个flow组成一个flow，然后再运用stateIn函数转换成StateFlow。

shareIn拓宽函数运用方法也是类似的，只不过没有初始值initialValue参数，此处不做赘述。

这两者如何挑选？

上文提到，咱们应该在ViewModel中露出出暖流，现在咱们有两个暖流-StateFlow和SharedFlow，如何挑选？

没什么特定的规矩，挑选的时分只需求想一下一下问题：

1.我真的需求在特定的时间、方位获取Flow的最新状况吗？
假如不需求，那考虑SharedFlow，比方常用的事情告诉功能。

2.我需求重复发射和搜集同样的值吗？
假如需求，那考虑SharedFlow，由于StateFlow会忽略连续两次重复的值。

3.当有新的订阅者订阅的时分，我需求发射最近的多个值吗？
假如需求，那考虑SharedFlow，能够装备replay参数。

compose中搜集流的方法

关于在UI层搜集ViewModel层的暖流方法，官方文档已经有介绍，但是没有弥补在JetPack Compose中的搜集流方法，下面弥补一下。

先添加依靠implementation 'androidx.lifecycle:lifecycle-runtime-compose:2.6.0-alpha03'

// 搜集StateFlow
val uiState by viewModel.userFlow.collectAsStateWithLifecycle()
// 搜集SharedFlow，差异在于需求赋初始值
val uiState by viewModel.userFlow.collectAsStateWithLifecycle(
    initialValue = UiState.Loading
)
when(uiState) {
    is UiState.Loading -> TODO()
    is UiState.Success -> TODO()
    is UiState.Error -> TODO()
}

运用collectAsStateWithLifecycle()也是能够确保流的搜集操作之发生在应用坐落前台的时分，防止形成资源糟蹋。

单元测验

由于咱们会在ViewModel中运用到viewModelScope，首要能够定义一个MainDispatcherRule，用于设置MainDispatcher。

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import org.junit.rules.TestRule
import org.junit.rules.TestWatcher
import org.junit.runner.Description
/**
 * A JUnit [TestRule] that sets the Main dispatcher to [testDispatcher]
 * for the duration of the test.
 */
class MainDispatcherRule(
  val testDispatcher: TestDispatcher = UnconfinedTestDispatcher()
) : TestWatcher() {
  override fun starting(description: Description) {
    super.starting(description)
    Dispatchers.setMain(testDispatcher)
  }
  override fun finished(description: Description) {
    super.finished(description)
    Dispatchers.resetMain()
  }
}

将MainDispatcherRule用于ViewModel单元测验代码中:

class MyViewModelTest {
  @get:Rule
  val mainDispatcherRule = MainDispatcherRule()
  ...
}

1.测验StateFlow

现在咱们有一个业务ViewModel如下：

@HiltViewModel
class MyViewModel @Inject constructor(
  private val userRepository: UserRepository
) : ViewModel() {
  private val _userFlow = MutableStateFlow<UiState>(UiState.Loading)
  val userFlow: StateFlow<UiState> = _userFlow.asStateFlow()
  fun onRefresh() {
    viewModelScope.launch {
      userRepository
        .getUsers().asResult()
        .collect { result ->
          _userFlow.update {
            when (result) {
              is Result.Loading -> UiState.Loading
              is Result.Success -> UiState.Success(result.data)
              is Result.Error -> UiState.Error(result.exception)
            }
          }
        }
    }
  }
}

单元测验代码如下：

class MyViewModelTest{
    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()
    // arrange
    private val repository = TestUserRepository()
    @OptIn(ExperimentalCoroutinesApi::class)
    @Test
    fun `when initialized, repository emits loading and data`() = runTest {
        // arrange
        val viewModel = MyViewModel(repository)
        val users = listOf(...)
        // 初始值应该是UiState.Loading，由于stateFlow能够直接获取最新值，此处直接做断言
        assertEquals(UiState.Loading, viewModel.userFlow.value)
        // action
        repository.sendUsers(users)
        viewModel.onRefresh()
        //check
        assertEquals(UiState.Success(users), viewModel.userFlow.value)
    }
}
// Mock UserRepository
class TestUserRepository : UserRepository {
  /**
   * The backing hot flow for the list of users for testing.
   */
  private val usersFlow =
    MutableSharedFlow<List<User>>(replay = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
  override fun getUsers(): Flow<List<User>> {
    return usersFlow
  }
  /**
   * A test-only API to allow controlling the list of users from tests.
   */
  suspend fun sendUsers(users: List<User>) {
    usersFlow.emit(users)
  }
}

假如ViewModel中运用的是stateIn拓宽函数：

@OptIn(ExperimentalCoroutinesApi::class)
@Test
fun `when initialized, repository emits loading and data`() = runTest {
    //arrange
    val viewModel = MainWithStateinViewModel(repository)
    val users = listOf(...)
    //action
    // 由于此时collect操作并不是在ViewModel中，咱们需求在测验代码中履行collect
    val collectJob = launch(UnconfinedTestDispatcher(testScheduler)) {
        viewModel.userFlow.collect()
    }
    //check
    assertEquals(UiState.Loading, viewModel.userFlow.value)
    //action
    repository.sendUsers(users)
    //check
    assertEquals(UiState.Success(users), viewModel.userFlow.value)
    collectJob.cancel()
}

2.测验SharedFlow

测验SharedFlow能够运用一个开源库Turbine，Turbine是一个用于测验Flow的小型开源库。

测验运用sharedIn拓宽函数的SharedFlow:

@OptIn(ExperimentalCoroutinesApi::class)
@Test
fun `when initialized, repository emits loading and data`() = runTest {
    val viewModel = MainWithShareInViewModel(repository)
    val users = listOf(...)
    repository.sendUsers(users)
    viewModel.userFlow.test {
        val firstItem = awaitItem()
        assertEquals(UiState.Loading, firstItem)
        val secondItem = awaitItem()
        assertEquals(UiState.Success(users), secondItem)
    }
}