如何在Usecase android中使用本地和远程

Question

I study domain in android programming and I have a question about that. Now, I have a getReportFromRemoteUsecase and getReportFromLocalUsecase. When the user refreshes UI, we call RemoteUseCase and get data from the remote, and store data in local. We return Flow from local and every change collect. How can use one Usecase for handle both of them in one Usecase. For example like this:

operator fun invoke() : Flow<T>{ 
  Repo.getFromRemote()
  return repo.getfromlocal()
 }

But this way has a problem. Because every time we want to update data we should return flow. I want just a one-time return flow and another time just update from the remote.

Answer 1

Okay, from what I understand from the question you are trying to figure out how to use a Local/Remote approach to fetch data, right?

This approach is mostly useful if you are working on an off-line first app. There are many recipes out there, but what I usually do is something like this:

class EmployeeRepository(
    private val remoteApi: RemoteRetrofitEmployeeApi,
    private val localDao: LocalRoomDao,
) {
    fun getEmployees(): Flow<ResultData<List<Employee>>> {
        // We create two flows here a remoteFlow that will fetch the data from a Retrofit interface
        // it will parse the data and sabe it in the local cache, here we are using a Room DAO as 
        // local cache
        val remoteFlow = flow {
            try {
                val retrofitResponse = remoteApi.getEmployees()
                val employeesDto = retrofitResponse.body()?.data?.asEmployeeDto()
                if (employeesDto != null) {
                    localDao.storeEmployees(employeesDto)
                }
                emit(ResultData.remote(
                    data = employeesDto?.asEmployeeModel(),
                    error = if (!retrofitResponse.isSuccessful) ResultData.Error.UNKNOWN else ResultData.Error.NO_ERROR_SET
                ))
            } catch (e: Throwable) {
                emit(ResultData.remote(
                    error = ResultData.Error.NO_CONNECTIVITY
                ))
            }
        }
        // Then we create a query on the Room DAO that will actively listen for any changes on the 
        // DB
        val localFlow = localDao.getAllEmployees()
            .map {
                it.asEmployeeModel()
            }
            .map {
                ResultData.local(it)
            }

        // Then we just zip both flows together
        return flowOf(localFlow, remoteFlow).flattenMerge()
    }
}

This is how the Retrofit Interface looks like:

interface RemoteRetrofitEmployeeApi {
    @GET("employees")
    suspend fun getEmployees(): Response<ApiEnvelopeResponse<List<ApiEmployeeResponse>>>

    @GET("employee/{id}")
    suspend fun getEmployee(
        @Path("id") id: Int
    ): Response<ApiEnvelopeResponse<ApiEmployeeResponse>>
}

This is how the DAO looks like:

@Dao
abstract class LocalRoomDao {
    @Query("SELECT * FROM db_employee_dto")
    abstract fun getAllEmployees(): Flow<List<DbEmployeeDto>>

    @Query("SELECT * FROM db_employee_dto where id = :id")
    abstract fun getEmployee(id: Int): Flow<DbEmployeeDto>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    abstract fun storeEmployees(
        employees: List<DbEmployeeDto>
    )

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    abstract fun storeEmployee(
        employees: DbEmployeeDto
    )
}

And notice that there is a Resource wrapper there that we use to keep track from where the data is coming from:

data class ResultData<T>(
    val data: T?,
    val source: Source,
    val error: Error = Error.NO_ERROR_SET
) {
    val isError: Boolean
        get() = error != Error.NO_ERROR_SET

    enum class Error {
        NO_CONNECTIVITY,
        NOT_SUCCESSFUL,
        UNKNOWN,
        NO_ERROR_SET
    }

    enum class Source {
        REMOTE,
        LOCAL
    }

    companion object {
        fun <T> local(data: T): ResultData<T> {
            return ResultData(data, Source.LOCAL)
        }

        fun <T> remote(data: T? = null, error: Error): ResultData<T> {
            return ResultData(data, Source.REMOTE, error)
        }
    }
}

This is a very broad answer, to a very broad question – if there's anything more specific that you would like to know, please provide more context. But if what you are looking for are the foundations to implement a component that would help you fetch and store cache data, this is it.