所以我有一个 ViewModel 我正在尝试进行单元测试。它使用 stateIn 运算符。我找到了有关如何测试使用 stateIn 运算符创建的状态流的文档https://developer.android.com/kotlin/flow/test但即使我正在收集流，mapLatest也永远不会触发。

class DeviceConfigurationViewModel(\n    val systemDetails: SystemDetails,\n    val step: AddDeviceStep.ConfigureDeviceStep,\n    val service: DeviceRemoteService\n) : ViewModel(), DeviceConfigurationModel {\n\n    @OptIn(ExperimentalCoroutinesApi::class)\n    private val _state: StateFlow<DeviceConfigurationModel.State> =\n        service.state\n            .mapLatest { state ->\n                when (state) {\n                    DeviceRemoteService.State.Connecting -> {\n                        DeviceConfigurationModel.State.Connecting\n                    }\n                    is DeviceRemoteService.State.ConnectedState.Connected -> {\n                        state.sendCommand(step.toCommand(systemDetails))\n                        DeviceConfigurationModel.State.Connected\n                    }\n                    is DeviceRemoteService.State.ConnectedState.CommandSent -> {\n                        DeviceConfigurationModel.State.Configuring\n                    }\n                    is DeviceRemoteService.State.ConnectedState.MessageReceived -> {\n                        transformMessage(state)\n                    }\n                    is DeviceRemoteService.State.Disconnected -> {\n                        transformDisconnected(state)\n                    }\n                }\n            }\n            .distinctUntilChanged()\n            .stateIn(\n                viewModelScope,\n                SharingStarted.WhileSubscribed(5000), // Keep it alive for …

这SoundViewModel是一个ViewModel类，val listSoundRecordState可能被应用程序中的某些模块使用。

在代码 A 中，我fun collectListSoundRecord()在需要使用数据时调用listSoundRecordState。但fun collectListSoundRecord()可能会因为Jetpack Compose重新组合而反复启动，不知道会不会耗费很多系统资源？

在代码B中，我 private fun collectListSoundRecord()在 中启动init { }，collectListSoundRecord()只会启动一次，但即使我不需要使用数据listSoundRecordState，它也会保留在内存中直到App代码关闭，这种方式会消耗很多系统资源吗？

代码A

@HiltViewModel
class SoundViewModel @Inject constructor(
  ...
): ViewModel() {

    private val _listSoundRecordState = MutableStateFlow<Result<List<MRecord>>>(Result.Loading)
    val listSoundRecordState = _listSoundRecordState.asStateFlow()

    init { }

     //It may be launched again and again
    fun collectListSoundRecord(){
        viewModelScope.launch {
            listRecord().collect {
                result -> _listSoundRecordState.value =result
            }
        }
    }

    private fun listRecord(): Flow<Result<List<MRecord>>> …

设想

EventHandler.sharedFlow单击按钮时会发出热流。

Repository该流由在 中执行某些操作接收OnEach{}。

EventCollectorA然后，两个事件收集器和接收存储库流EventCollectorB。

然后，事件收集器流被组合并收集在 中MyViewModel。

问题

这两个事件收集器会导致onEach{...}每次单击时运行两次。但是我只想运行onEach{...}一次并在两个事件收集器中接收它。我怎样才能实现这个目标？

注意：我使用 Hilt 只拥有一个Repository,EventCollectorA实例EventCollectorB

代码

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        val viewModel = ViewModelProvider(this).get(MyViewModel::class.java)
        binding.buttonB.setOnClickListener {
            viewModel.userClickEvent("Click Event")
        }
    }
}

@HiltViewModel
class MyViewModel @Inject constructor(
    private val eventHandler: EventHandler,
    private val eventCollectorA: EventCollectorA,
    private val eventCollectorB: EventCollectorB,
) : ViewModel() { …

如果代码中发生某些情况，我想取消 kotlin 流程。

假设我有一个方法如下

fun test(): Flow<String> = flow {
    val lst = listOf("A", "B", "C")

    while(true) {
        lst.forEach { emit(it) }

    //If some condition occurs, need to return from here, else continue
    //How to stop flow here
    }
}

并称其为

test().collect { println(it)}

问题是，如何停止流在某些条件下（来自流生成器或流生成器之外）产生任何内容？

我注意到很多人和例子使用 Flows 作为 List<> 的包装器，例如这样：

@Query("SELECT * from some_model ORDER BY some_field")
fun getData(): Flow<List<some_model>>

据我所知，Flow 就像一种“异步序列”，所以我真的不明白“Flow<List<T>>”的含义。

为什么我们不能直接使用 Flow< T > ，这对我来说似乎很直观，我问这个问题是因为我在代码片段中看到它重复了很多次并且无法理解其背后的目的？

我们目前如何从 swift收集Flow？

通过在 Swift流的collect方法中对 Kotlin 的挂起函数的新支持，可以在 swift 中获得这个相当笨重的签名

vm.topStoriesFlow.collect(
 collector: Kotlinx_coroutines_coreFlowCollector,
 completionHandler: @escaping (KotlinUnit?, Error?) -> Void
)

知道如何使用它，或者即使当前支持它的使用吗？

我的问题实际上很笼统。我想知道如何对从Paging 3返回PagingSource的Room Dao查询进行单元测试。

    @Query("SELECT * FROM database")
    fun getChocolateListData(): PagingSource<Int, Chocolate>

@FlowPreview
@Test
fun saveChocolateToDbSavesData() = runBlocking {
    val dao: Dao by inject()

    val chocolate = Chocolate(
        name = "Dove"
    )
    dao.saveChocolate(chocolate) 

    val pagingSourceFactory = { dao.getChocolateListData() }
    val pagingDataFlow: Flow<PagingData<Chocolate>> = Pager(
        config = PagingConfig(
            pageSize = 50,
            maxSize = 200,
            enablePlaceholders = false
        ),
        pagingSourceFactory = pagingSourceFactory
    ).flow

    val chocolateListFlow = pagingDataFlow.testIn(coroutinesTestRule)
    Assert.assertEquals(PagingData.from(listOf(chocolate)), chocolateListFlow.emissions[0]) …