Question about loading

[fabiosaracino]

Dear author,
I'm reading the book and putting the examples into practice. I was wondering how I can encapsulate the loading status within the ApiResult class used within the UseCase class to output the success (or failure) of I/O operations.
I cannot find the right position to put the emit(ApiResult.Loading).
Thank you in advance!

This is the ApiResult class:

sealed class ApiResult<out T: Any> {
    data class Success<out T: Any>(val data: T): ApiResult<T>()
    class Error(val exception: UseCaseException): ApiResult<Nothing>()
    data object Loading: ApiResult<Nothing>()
}

This is the UseCase class:

abstract class UseCase<T: UseCase.Request, R: UseCase.Response>
    (private val dispatcher: CoroutineDispatcher) {

    fun execute(input: T): Flow<ApiResult<R>> =
        executeData(input)
            .map {
                ApiResult.Success(it) as ApiResult<R>
            }
            .flowOn(dispatcher)
            .catch {
                emit(ApiResult.Error(UseCaseException.createFromThrowable(it)) as ApiResult<R>)
            }

    protected abstract fun executeData(input: T): Flow<R>

    interface Request
    interface Response
}

and this is ChecUserEmaiUseCase class

class CheckUserEmailUseCase(
    dispatcher: CoroutineDispatcher,
    private val userRepository: UserRepository
): UseCase<CheckUserEmailUseCase.Request, CheckUserEmailUseCase.Response>(dispatcher) {

    override fun executeData(input: Request): Flow<Response> =
        userRepository.checkEmail(input.email)
            .map {
                Response(it)
            }

    data class Request(val email: String): UseCase.Request
    data class Response(val found: Boolean): UseCase.Response
}

[daniel-iroka]

The Loading in cases like this should come first, as that is what the user will see first while you load up your data to be displayed. But this happens at the UI level since it involves the UI. And that is when you make use of the Sealed classes in a when expression to determine the state of the UI.

[fabiosaracino]

Thank you @daniel-iroka. In fact I already implement the solution you suggest, but I was wondering if it was possible to emit the Loading as done with the exception ( emit(ApiResult.Error(UseCaseException.createFromThrowable(it)) as ApiResult) )

[daniel-iroka]

Yes @fabiosaracino because you are emitting a value, but you could only use emit here if you were returning a Flow that has the same type as the value you are trying to emit. But this wouldn't make much sense to do here as you will only be emitting . The Loading subclass should only be used at the UI level and as part of the UI state.

[alexandrudumbravan]

@fabiosaracino Apologies for the late reply. My answer won't add much to the conversation, because @daniel-iroka had me covered (thank you BTW) but I feel like I should add it as well.
When I wrote the exercise I went back and forth on whether I should put the loading as part of the Result, but felt like the loading state has no data and it represents more of a UI state which is why I moved it out of the domain and defined it in the state, although it's pretty common to see it in the domain layer as well.
When it comes to using Flows and emitting data then all the paper in the world couldn't cover the ways you can combine the Flow functions:

• on example is to use onStart to emit your Loading there. You'll have to check your object lifecycles and Flow types here because depending on the flows you use this might not always be emitted
• an alternative would be to start with flowOf(Result.Loading as Result) and then use zip, combine or the operator that suits this approach (this might cause sidefects because everytime you load, even from Room which is fast you might see a glitchy UI)

Thank you both for your support.