Use Case with Coroutines

CoroutinesUseCase.kt

/**
 * Abstract class for a UseCase that returns an instance of a [T].
 */
abstract class UseCase<T, in Params> internal constructor(
        private val postExecutionContext:CoroutineContext,
        private val logException: LogException) : CoroutineScope {

    private val executionJob: Job by lazy { Job() }

    override val coroutineContext: CoroutineContext by lazy {
        Dispatchers.IO + executionJob
    }

    /**
     * Builds a [T] which will be used when the current callback is executed.
     */
    internal abstract suspend fun buildUseCaseObservable(params: Params): T

    /**
     * Executes the current use case.
     */
    fun execute(params: Params,
                onError: (e: Throwable) -> Unit = {},
                onSuccess: (T) -> Unit = {}) {

        launch{
            try {
                val response  = buildUseCaseObservable(params)

                withContext(postExecutionContext) {
                    onSuccess(response)
                }
            } catch (e: Exception) {
                withContext(postExecutionContext) {
                    logException.logException(e)
                    onError(e)
                }
            }catch (e: OutOfMemoryError){
                onError(KnownException(KnownError.OUT_OF_MEMORY_ERROR, e.message?:""))
            }
        }
    }

    /**
     * Dispose execution
     */
    fun dispose() {
        executionJob.cancel()
    }
}