Livedata观察者第二次触发

Question

我希望当我单击一个侧菜单之一时，观察者将触发API时会触发。当我单击菜单之一时， retrofit 实际上给了我正确值的响应。问题是，观察者并未第二次触发。我已经跟踪问题，并发现我的存储库即使我的翻新已经更新了 mutableLivedata ，也没有返回值。

remotedatasource.kt

    override fun getDisastersByFilter(filter: String?): LiveData<ApiResponse<DisastersDTO?>> {
        val result = MutableLiveData<ApiResponse<DisastersDTO?>>()

        apiService.getDisastersByFilter(filter).enqueue(object : Callback<DisastersResponse> {
            override fun onResponse(
                call: Call<DisastersResponse>,
                response: Response<DisastersResponse>
            ) {
                if(response.isSuccessful) {
                    val data = response.body()
                    data?.disastersDTO?.let {
                        result.postValue(ApiResponse.Success(it))
                        Log.d("RemoteDataSource", "$it")
                    } ?: run {
                        result.postValue(ApiResponse.Error("Bencana alam tidak ditemukan"))
                    }
                } else {
                    result.postValue(ApiResponse.Error("Terjadi kesalahan!"))
                }
            }

            override fun onFailure(call: Call<DisastersResponse>, t: Throwable) {
                result.postValue(ApiResponse.Error(t.localizedMessage!!))
                Log.d("RemoteDataSource", t.localizedMessage!!)
            }

        })

        return result
    }

repository.kt

    override fun getDisastersByFilter(filter: String?): LiveData<Resource<List<Disaster>>> =
        remoteDataSource.getDisastersByFilter(filter).map {
            when (it) {
                is ApiResponse.Empty -> Resource.Error("Terjadi error")
                is ApiResponse.Error -> Resource.Error(it.errorMessage)
                is ApiResponse.Loading -> Resource.Loading()
                is ApiResponse.Success -> Resource.Success(
                    DataMapper.disastersResponseToDisasterDomain(
                        it.data
                    )
                )
            }
        }

shardviewmodel.kt

    fun getDisastersByFilter(filter: String? = "gempa"): LiveData<Resource<List<Disaster>>> =
        useCase.getDisastersByFilter(filter)
Here's the **MapsFragment**

    private val viewModel: SharedViewModel by activityViewModels()
    viewModel.getDisastersByFilter("gempa").observe(viewLifecycleOwner) {
            when (it) {
                is Resource.Success -> {
                    Log.d("MapsFragmentFilter", "${it.data}")
                    it.data?.let { listDisaster ->
                        if(listDisaster.isNotEmpty()) {
                            map.clear()
                            addGeofence(listDisaster)
                            listDisaster.map { disaster ->
                                placeMarker(disaster)
                                addCircle(disaster)
                            }
                        }
                    }
                }

                is Resource.Error -> Toast.makeText(context, "Filter Error", Toast.LENGTH_SHORT).show()

                is Resource.Loading -> {}
            }
        }

这是 mainActivity ，它触发了点击API的功能

    private val viewModel: SharedViewModel by viewModels()
    binding.navViewMaps.setNavigationItemSelectedListener { menu ->
            when (menu.itemId) {
                R.id.filter_gempa -> viewModel.getDisastersByFilter("gempa")
                R.id.filter_banjir -> viewModel.getDisastersByFilter("banjir")
                R.id.about_us -> viewModel.getDisasters()
            }

            binding.drawerLayoutMain.closeDrawers()

            true
        }

Answer 1

我无法确定您的发布内容，但是您的菜单选项调用 getDisastersbyfilter sharedViewModel ，看起来最终会调用 getdisasterbyfilter 在 remotedatasource 中。

该功能创建一个新的 livedata 并返回，以及您的所有其他功能（包括 viewModel 中的一个功能），只需返回该新 livedata 。因此，如果您想查看最终发布的结果，则需要观察该新的。

我不知道您发布的片段代码来自何处，但看起来您只是在打电话和观察 viewModel.getDisastersbyfilter 曾经 。因此，当第一次发生这种情况时，它会进行数据获取，然后在 livedata 上获得结果。 livedata 从代码的外观中不会再收到任何结果 - 这是一次一次性的一次性东西，以后再接收结果，然后毫无用处。

---

如果我做对了，您需要重新处理如何处理 livedata s。片段需要获得每个 viewModel.getDisastersbyfilter 调用的结果，因此可以观察结果 - 如果您的活动将事件传递给片段可能会更好（“此项目已单击”）和片段处理呼叫VM，并且可以在结果时观察结果（将其传递给函数，以使其启动，以便您不必继续重复观察者代码）

另一种方法是让片段观察 currentData livedata，这是有线的，以显示A 不同的源源的值。然后，当您调用 getDisastersbyfilter 时，该源将交换为新的。 CurrentData 一个人将任何新值发布到此新来源，而片段只需要观察一次 livedata 一次。所有数据都通过VM将其输送到其中。

我没有时间做一个示例，但请看一下此转换内容（这是开发人员的博客之一）：https://medium.com/androiddevelopers/livedata-beyond-the-viewmodel-reactive-patterns-using-transformations-和纳入属于fda520ba00b7的

Answer 2

我相信您做错了的是首先使用改造时使用Livedata。

当您的代码同步运行时，您会异步获得响应。因此，您需要使用 sustend 来利用暂停功能。

并且在从ViewModel调用此函数时，将其用 viewModelsCope.launch {} 将其包裹起来

fun getDisastersByFilter(filter: String? = "gempa") = viewModelScope.launch {
    useCase.getDisastersByFilter(filter).collect{
  // do something....
  // assign the values to MutableLiveData or MutableStateFlows
  }
}

。

我更喜欢流，下面给出的是一个示例，说明了您使用回调流程的情况。

    suspend fun getDisastersByFilter(filter: String?): Flow<ApiResponse<DisastersDTO?>> =
        callbackFlow {

            apiService.getDisastersByFilter(filter)
                .enqueue(object : Callback<DisastersResponse> {
                    override fun onResponse(
                        call: Call<DisastersResponse>,
                        response: Response<DisastersResponse>
                    ) {
                        if (response.isSuccessful) {
                            val data = response.body()
                            data?.disastersDTO?.let {
                                trySend(ApiResponse.Success(it))
//                                result.postValue(ApiResponse.Success(it))
                                Log.d("RemoteDataSource", "$it")
                            } ?: run {
                                trySend(ApiResponse.Error("Bencana alam tidak ditemukan"))
//                                result.postValue(ApiResponse.Error("Bencana alam tidak ditemukan"))
                            }
                        } else {
                            trySend(ApiResponse.Error("Terjadi kesalahan!"))
//                            result.postValue(ApiResponse.Error("Terjadi kesalahan!"))
                        }
                    }

                    override fun onFailure(call: Call<DisastersResponse>, t: Throwable) {
                        trySend(ApiResponse.Error(t.localizedMessage!!))
//                        result.postValue(ApiResponse.Error(t.localizedMessage!!))
                        Log.d("RemoteDataSource", t.localizedMessage!!)
                    }

                })
            awaitClose()
        }