Using coroutines for the first time. Need help.
Here is my flow:
Presenter wants to login so calls Repository Interface. Repository implements RepositoryInterface. So Repository calls APIInterface. APIInterface is implemented by APIInterfaceImpl. The APIInterfaceImpl finally calls the MyRetrofitInterface.
Here is the flow diagrammatically:
Presenter -> Repository -> APIInterfaceImpl -> MyRetrofitInterface
Once I get login response:
APIInterfaceImpl -> Repository -> Stores the data in cache -> Gives http status code to Presenter
Here is my code:
RepositoryInterface.kt
fun onUserLogin(loginRequest: LoginRequest): LoginResponse
Repository.kt
class Repository : RepositoryInterface {
private var apiInterface: APIInterface? = null
override fun onUserLogin(loginRequest: LoginRequest): LoginResponse {
return apiInterface?.makeLoginCall(loginRequest)
}
}
APIInterface.kt
suspend fun makeLoginCall(loginRequest): LoginResponse?
APIInterfaceImpl.kt
override suspend fun makeLoginCall(loginRequest: LoginRequest): LoginResponse? {
if (isInternetPresent(context)) {
try {
val response = MyRetrofitInterface?.loginRequest(loginRequest)?.await()
return response
} catch (e: Exception) {
//How do i return a status code here
}
} else {
//How do i return no internet here
return Exception(Constants.NO_INTERNET)
}
}
MyRetrofitInterface.kt
@POST("login/....")
fun loginRequest(@Body loginRequest: LoginRequest): Deferred<LoginResponse>?
My questions are:
It is a good practice to launch a coroutine in a local scope which can be implemented in a lifecycle aware classes, for example Presenter or ViewModel. You can use next approach to pass data:
Create sealed
Result
class and its inheritors in separate file:
sealed class Result<out T : Any>
class Success<out T : Any>(val data: T) : Result<T>()
class Error(val exception: Throwable, val message: String = exception.localizedMessage) : Result<Nothing>()
Make onUserLogin
function suspendable and returning Result
in RepositoryInterface
and Repository
:
suspend fun onUserLogin(loginRequest: LoginRequest): Result<LoginResponse> {
return apiInterface.makeLoginCall(loginRequest)
}
Change makeLoginCall
function in APIInterface
and APIInterfaceImpl
according to the following code:
suspend fun makeLoginCall(loginRequest: LoginRequest): Result<LoginResponse> {
if (isInternetPresent()) {
try {
val response = MyRetrofitInterface?.loginRequest(loginRequest)?.await()
return Success(response)
} catch (e: Exception) {
return Error(e)
}
} else {
return Error(Exception(Constants.NO_INTERNET))
}
}
Use next code for your Presenter
:
class Presenter(private val repo: RepositoryInterface,
private val uiContext: CoroutineContext = Dispatchers.Main
) : CoroutineScope { // creating local scope
private var job: Job = Job()
// To use Dispatchers.Main (CoroutineDispatcher - runs and schedules coroutines) in Android add
// implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1'
override val coroutineContext: CoroutineContext
get() = uiContext + job
fun detachView() {
// cancel the job when view is detached
job.cancel()
}
fun login() = launch { // launching a coroutine
val request = LoginRequest()
val result = repo.onUserLogin(request) // onUserLogin() function isn't blocking the Main Thread
//use result, make UI updates
when (result) {
is Success<LoginResponse> -> { /* update UI when login success */ }
is Error -> { /* update UI when login error */ }
}
}
}
EDIT
We can use extension functions on Result
class to replace when
expression:
inline fun <T : Any> Result<T>.onSuccess(action: (T) -> Unit): Result<T> {
if (this is Success) action(data)
return this
}
inline fun <T : Any> Result<T>.onError(action: (Error) -> Unit): Result<T> {
if (this is Error) action(this)
return this
}
class Presenter(...) : CoroutineScope {
// ...
fun login() = launch {
val request = LoginRequest()
val result = repo.onUserLogin(request)
result
.onSuccess {/* update UI when login success */ }
.onError { /* update UI when login error */ }
}
}