orcchg

class DefaultAuthInteractor @Inject constructor(
    private val checkUserRegisteredUseCase: CheckUserRegisteredUseCase,
    private val trustedLoginUserUseCase: TrustedLoginUserUseCase
) : AuthInteractor {

    /**
     * See how AuthInteractor coordinates the work between use-cases.
     */
    override fun login(): Completable =
        checkUserRegisteredUseCase.source()

orcchg

class TrustedLoginUserUseCase @Inject constructor(
    private val authTokenStorage: AuthTokenStorage,
    private val repository: AuthRepository,
    private val secureRandom: SecureRandom,
    schedulersFactory: SchedulersFactory
) : CompletableUseCase(schedulersFactory) {
  
    override fun sourceImpl(params: Params): Completable {
        val pinCode = params.require<String>(PARAM_KEY_REG_PIN_CODE)

orcchg

class GetStocksUseCase @Inject constructor(
    private val repository: StockListRepository,
    schedulersFactory: SchedulersFactory
) : SingleUseCase<List<Stock>>(schedulersFactory) {

    override fun sourceImpl(params: Params): Single<List<Stock>> =
        repository.stocks()
}

orcchg

class App : Application(), ApiContainer {

    @Inject
    @FeatureApis
    lateinit var featuresMap: Map<Class<*>, @JvmSuppressWildcards Api>

    @Suppress("Unchecked_Cast")
    override fun <T> getFeature(key: Class<T>): T =
        featuresMap[key] as T

orcchg

@Component(
    modules = [
        CoreApiModule::class,
        DataApiModule::class,
        FeatureApiModule::class
    ]
)
interface AppComponent {

    @FeatureApis

orcchg

@Module
object CoreApiModule {

    @Provides
    @IntoMap
    @ClassKey(NetworkCoreLibApi::class)
    @CoreApis
    fun networkApi(): Api = DaggerNetworkCoreLibComponent.factory().create()

    @Provides

orcchg

@Module
object DataApiModule {

    @Provides
    @IntoMap
    @ClassKey(StockListDataApi::class)
    @DataApis
    fun stockListDataApi(@CoreApis coreApis: Map<Class<*>, @JvmSuppressWildcards Api>): Api =
        DaggerStockListDataComponent.factory()
            .create(

orcchg

@Module
object FeatureApiModule {

    @Provides
    @IntoMap
    @ClassKey(StockListFeatureApi::class)
    @FeatureApis
    fun stockListFeatureApi(
        @CoreApis coreApis: Map<Class<*>, @JvmSuppressWildcards Api>,
        @DataApis dataApis: Map<Class<*>, @JvmSuppressWildcards Api>

orcchg

class App : Application(), ApiContainer {

    @Inject
    @FeatureApis
    lateinit var featuresMap: Map<Class<*>, @JvmSuppressWildcards Api>

    @Suppress("Unchecked_Cast")
    override fun <T> getFeature(key: Class<T>): T =
        featuresMap[key] as T
}

orcchg

interface ApiContainer {

    fun <T> getFeature(key: Class<T>): T
}

inline fun <reified T> ApiContainer.getFeature(): T =
    getFeature(T::class.java)