[Domain Layer] #clean #architecture #android

FlowableUseCase.kt

package com.raywenderlich.android.creatures.domain.interactor
/**
 * Abstract class for a UseCase that returns an instance of a [Single].
 */
abstract class FlowableUseCase<T, in Params> constructor(
    private val threadExecutor: ThreadExecutor,
    private val postExecutionThread: PostExecutionThread) {

  private val disposables = CompositeDisposable()

  /**
   * Builds a [Single] which will be used when the current [FlowableUseCase] is executed.
   */
  protected abstract fun buildUseCaseObservable(params: Params? = null): Flowable<T>

  /**
   * Executes the current use case.
   */
  open fun execute(observer: DisposableSubscriber<T>, params: Params? = null) {
    val observable = this.buildUseCaseObservable(params)
        .subscribeOn(Schedulers.from(threadExecutor))
        .observeOn(postExecutionThread.scheduler) as Flowable<T>
    addDisposable(observable.subscribeWith(observer))
  }

  /**
   * Dispose from current [CompositeDisposable].
   */
  fun dispose() {
    if (!disposables.isDisposed) disposables.dispose()
  }

  /**
   * Dispose from current [CompositeDisposable].
   */
  private fun addDisposable(disposable: Disposable) {
    disposables.add(disposable)
  }
}

GetCreatures.kt

package com.raywenderlich.android.creatures.domain.interactor.browse

open class GetCreatures @Inject constructor(private val creatureRepository: CreatureRepository,
                                            threadExecutor: ThreadExecutor,
                                            postExecutionThread: PostExecutionThread):
    FlowableUseCase<List<Creature>, Void?>(threadExecutor, postExecutionThread) {

  public override fun buildUseCaseObservable(params: Void?): Flowable<List<Creature>> {
    return creatureRepository.getCreatures()
  }
}

PostExecutionThread.kt

package com.raywenderlich.android.creatures.domain.executor

import io.reactivex.Scheduler

interface PostExecutionThread {
  val scheduler: Scheduler
}

ThreadExecutor.kt

package com.raywenderlich.android.creatures.domain.executor

import java.util.concurrent.Executor

interface ThreadExecutor : Executor

UiThread.kt

package com.raywenderlich.android.creatures.ui

class UiThread @Inject internal constructor() : PostExecutionThread {
  override val scheduler: Scheduler
    get() = AndroidSchedulers.mainThread()
}