Template | Use Case | Domain Layer

BaseRxUseCase.kt

package com.mobiledevpro.interactor.usecase.base

import com.mobiledevpro.interactor.usecase.base.executor.ExecutionThread
import com.mobiledevpro.interactor.usecase.base.executor.PostExecutionThread
import io.reactivex.Scheduler
import io.reactivex.disposables.CompositeDisposable
import io.reactivex.disposables.Disposable

abstract class BaseRxUseCase(
    executionThread: ExecutionThread,
    postExecutionThread: PostExecutionThread
) {

    protected val executionThreadScheduler: Scheduler = executionThread.scheduler

    protected val postExecutionThreadScheduler: Scheduler = postExecutionThread.scheduler

    private val disposables = CompositeDisposable()

    open fun dispose() {
        if (!disposables.isDisposed) {
            disposables.dispose()
        }
    }

    protected fun addToDisposable(disposable: Disposable) {
        disposables.add(disposable)
    }
}

ExecutionThread.kt

interface ExecutionThread {
    val scheduler: Scheduler
}

ObservableUseCase.kt

abstract class ObservableUseCase<Results, in Params>(
    executionThread: ExecutionThread,
    postExecutionThread: PostExecutionThread
) : BaseRxUseCase(executionThread, postExecutionThread) {

    /**
     * Builds Observable
     */
    abstract fun buildUseCaseObservable(params: Params? = null): Observable<Results>

    /**
     * Executes the current use case.
     */
    fun execute(observer: DisposableObserver<Results>, params: Params? = null) {
        val observable = this.buildUseCaseObservable(params)
            .subscribeOn(executionThreadScheduler)
            .observeOn(postExecutionThreadScheduler)
        addToDisposable(observable.subscribeWith(observer))
    }

    /**
     * Executes the current use case.
     */
    fun execute(params: Params? = null): Observable<Results> =
        this.buildUseCaseObservable(params)
            .subscribeOn(executionThreadScheduler)
            .observeOn(postExecutionThreadScheduler)

}

PostExecutionThread.kt

interface PostExecutionThread {
    val scheduler: Scheduler
}

It's a real Use Case from my app, based on templates above

class GetVehicleUseCase(
    threadExecutor: ExecutionThread,
    postExecutionThread: PostExecutionThread,
    private val vehicleRepository: VehicleDetailsNewRepository,
    private val dealerRepository: DealerRepository
) : ObservableUseCase<InventoryItem, String>(threadExecutor, postExecutionThread) {

    override fun buildUseCaseObservable(params: String?): Observable<InventoryItem> =
        vehicleRepository.updateSelectedStockNumber(params ?: "")
            .flatMap {
                dealerRepository.getCurrentDealerId()
            }
            .flatMapObservable {
                vehicleRepository.getCachedVehicleData(it, params ?: "")
            }

}

How to execute Use case:

getVehicleUseCase.execute(stockNumber)