Android LiveData MVVM 返回发射并使用 DAO 添加到数据库

我使用类似这样的架构：

视图模型

class AlbumListViewModel @Inject constructor(private val repository: AlbumRepository): ViewModel(){
    private var query = mutableLiveData("")
    private var albums : LiveData<Result<List<Album>>> = Transformations.switchMap(query, ::getAlbumsBySearch)

    private fun getAlbumsBySearch(searchQuery: String): LiveData<Result<List<Album>>>{
        return repository.getAlbumsBySearch(searchQuery)
    }
    fun handleSearchQuery(text: String?) {
        query.value = text
        Log.d("AlbumListViewModel SV", text.toString())
    }
}

存储库

class AlbumRepository @Inject constructor(private val remoteSource: AlbumRemoteDataSource, private val database: AppDatabase){

    fun getAlbumsBySearch(searchQuery: String): LiveData<Result<List<Album>>>{


        Log.d("RepositoryNew", searchQuery)
        val resultLiveData = resultLiveData(
            databaseQuery = {database.getAlbumDao().getAlbumsBySearch("%${searchQuery}%")},
            networkCall = {remoteSource.getAlbumsBySearch(searchQuery)},
            saveCallResult = {database.getAlbumDao().insertAll(it.results)}
        )
        Log.d("AlbumRepository", resultLiveData.value.toString())
        return resultLiveData
    }


}

远程存储库

class AlbumRemoteDataSource @Inject constructor(
    private val apiService: APIService
): BaseDataSource(){
    suspend fun getAlbumsBySearch(searchQuery: String): Result<BaseResponse<Album>>{
        val result = getResult{apiService.getAlbumsBySearch(searchQuery)}
        Log.d("AlbumRemoteDataSource", result.toString())
        return result
    }


}

得到结果

suspend fun <T> getResult(call : suspend () -> Response<T>) : Result<T>{
        return try {
            //Получаем ответ от вызова
            val response = call()
            if(response.isSuccessful) {
                //тело
                val body = response.body()
                if (body != null)
                    return Result.success(body)
            }
            error("${response.code()} ${response.message()} ${response.errorBody()}")
        } catch (e: Exception){
            Log.d("BaseDataSource", e.toString())
            Result.error(e.message ?: e.toString())
        }
    }

API服务

interface APIService{
    /**
     * Поиск album по любым параметрам с поиковым запросом "jack-johnson
     * https://itunes.apple.com/search?term=jack+johnson&entity=album
     */
    @GET("search")
    suspend fun getAlbumsBySearch(
        @Query("term") searchQuery: String,
        @Query("entity") typeEntity: String = "album") : Response<BaseResponse<Album>>

LiveData 扩展

fun <T, A> resultLiveData(
    databaseQuery: () -> LiveData<T>,
    networkCall: suspend () -> Result<A>,
    saveCallResult: suspend (A) -> Unit): LiveData<Result<T>> =

    liveData(Dispatchers.IO){
            emit(Result.loading())
            val responseSource = networkCall.invoke()
            Log.d("ResultLiveData Network", responseSource.toString())
            if(responseSource.status == Result.Status.SUCCESS) {
                saveCallResult(responseSource.data!!)
                Log.d("resultLiveData", "save database")
            }
            else if(responseSource.status == Result.Status.ERROR){
                emit(Result.error(responseSource.error))
                Log.d("resultLiveData", "error ${responseSource.error}")
            }
            val databaseSource = databaseQuery.invoke()
            emitSource(databaseSource.map { Result.success(it) })
        }

fun <T> mutableLiveData(defaultValue: T? = null): MutableLiveData<T>{
    val data = MutableLiveData<T>()

    if(defaultValue != null){
        data.value = defaultValue
    }

    return data
}

类 - 包装器

data class Result<out T>(
    val status : Status,
    val data: T?,
    val error: String?
){
    enum class Status{
        SUCCESS,
        LOADING,
        ERROR
    }

    companion object{
        fun <T> success(data: T) : Result<T> = Result(Status.SUCCESS, data, null)
        fun <T> error(error: String?, data: T? = null): Result<T> = Result(Status.ERROR, data, error)
        fun <T> loading(data: T? = null): Result<T> = Result(Status.LOADING, data, null)
    }

}

其实有很多用例：

1. 向存储库发出请求，存储库将保存到数据库中，如果数据发生变化，数据将从数据库通过 LiveData 到达
2. 发出纯请求并期望在相同的响应中得到结果，中间保存。
3. 好吧，还是这个选项。

即使在这个版本中，也有很多方法。例如，您可以先从数据库中进行选择，使缓存的数据可见，然后仅发出请求，将更新的数据插入数据库，并由 LiveData 更新。

您可以将插入和删除旧数据合并到一个事务中。

很多用例。

我们可能应该争取清洁架构。据她介绍，所有应用程序都应该分层。不应该依赖于数据库和外部服务，因此您需要添加 2 个以上的抽象级别（例如 LocalRepository (db) 和 RemoteRepository（外部服务）

如果我正确理解您的问题，那么Transformation. 这是一个例子：

private fun madLiveData(): LiveData<Int> { 
    return Transformations.map(dao.getLiveDataModel()) { model: Model ->
        doSomething(model) model.id } 
} 

private fun doSomething(Model: Model) {
     //Здесь сохраняйте в бд
}

PS。我被你的 liveData 弄糊涂了——我以为它是一个返回类型，但现在我意识到这是 coroutineScope 的名称。

那么你应该以不同的方式做事。

你可以写这样的东西

sealed class Result<out T> {
    object Loading: Result<Nothing>()
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
} 

一般来说，您可以在这里删除泛型并替换您自己的类型，这样会更容易，但这种解决方案是通用的。

在您从改造中获得响应的地方，您可以执行以下操作：

override suspend fun get(args: ArgumentsWrapper?): Result<MODEL> {
        return try {
            val result = parseResponse(getResponse(args))
            Result.Success(result)
        } catch (e: Exception) {
            Result.Error(e)
        }
    }


private fun parseResponse(response: Response<RESPONSE>): RESPONSE {
        val data: RESPONSE?

        if (response.isSuccessful)
            data = response.body()
        else
            throw getNetworkException(response) // это кастомный метод для генерации ошибки сервера в мой класс, можете тут бросать то что удобно будет вам. 

        if (data != null)
            return data
        else
            throw NetworkException(statusMessage = "Generated Network Error Something went wrong") // это кастомный Exception, вы тут можете вернуть либо свой либо один из готовых
    }

因此，在 ViewModel 中，您将已经收到错误或成功的结果。在 ViewModel 中你像这样处理它

fun getUsers() {
        liveData.launch {
            when (val result = dataSource.get()) {
                is Result.Success -> doSomethingWithData(result.data)
                is Result.Error -> handleError(result.exception)
            }
        }
    }