ext {

    kotlinVersion = '1.3.21'

    buildTools = '3.4.0-beta04'

    //Rx
    rxJavaVersion = '2.2.7'
    rxKotlinVersion = '2.2.0'
    rxAndroidVersion = '2.1.1'

    //Koin
    koinVersion = '1.0.2'

    dependencies = [
            kotlin               : "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlinVersion",
            rxJava               : "io.reactivex.rxjava2:rxjava:$rxJavaVersion",
            rxKotlin             : "io.reactivex.rxjava2:rxkotlin:$rxKotlinVersion",
            rxAndroid            : "io.reactivex.rxjava2:rxandroid:$rxAndroidVersion",
            koin                 : "org.koin:koin-android:$koinVersion",
    ]
}

Agora ja podemos utilizar no nosso projeto. Primeiro vamos configurar no build.gradle do projeto:

• Configurar: apply from: ‘dependencies.gladle’ dentro do buildScript
• Setar versões: o interessante é que quando vamos utilizar esse approach temos que utilizar aspas duplas na nossa dependência e, assim, setar a versão com o $kotlinVersion.

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {

    apply from: 'dependencies.gradle'

    repositories {
        google()
        jcenter()
        
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
        classpath "com.android.tools.build:gradle:$buildTools"
    }
}

allprojects {
    repositories {
        google()
        jcenter()
        
    }
}

task clean(type: Delete) {
    delete rootProject.buildDir
}

Agora podemos configurar as dependências da nossa domain(FINALMENTE!!)

Vamos ao build.greadle da domain e vamos criar uma variável dependencies que capta todas as dependências do arquivo que criamos anteriormente e, com isso, podemos utilizar as que queremos implementar como no gist abaixo.

apply plugin: 'java-library'
apply plugin: 'kotlin'

dependencies {

    def dependencies = rootProject.ext.dependencies

    implementation dependencies.kotlin
    implementation dependencies.rxJava
    implementation dependencies.koin
}

sourceCompatibility = JavaVersion.VERSION_1_8
targetCompatibility = JavaVersion.VERSION_1_8

Mas qual o motivo de criar isso tudo para um projeto simples?

Sendo simples ou não, o projeto vai ter todas as dependências centralizadas em apenas um lugar, ou seja, se outros módulos utilizam RxJava por exemplo, com esse approach garantimos que todos os módulos vão ter a mesma versão da lib. Com isso, evitamos de ter um módulo com versões diferentes de outros e, quando vamos atualizar para versões mais novas, todos os módulos são atualizados. Então, não importa se o projeto é simples, sempre temos que pensar em evitar retrabalho no futuro e tentar montar nossa estrutura o mais clean possível.

AGORA VAMOS PARA DENTRO DA DOMAIN!

Obs: nosso projeto mostrara uma lista de jobs Android e vamos utilizar a seguinte api: http://demo8470178.mockable.io/android-jobs

Vamos ter 4 pacotes na domain:

• Entities: é onde vamos criar nossas data classes. E a primeira que vamos criar será AndroidJob:

data class AndroidJob(
    val title: String,
    val experienceTimeRequired: Int,
    val native: Boolean,
    val country: String
)

• Repository: aqui ficam nossas interfaces de comunicação com o module data(próximo artigo), e segue nosso primeiro repository, que vai retornar uma lista observável de AndroidJobs:

interface AndroidJobsRepository {
    fun getJobs(forceUpdate: Boolean): Observable<List<AndroidJob>>
}

• UseCases: nossos casos de uso que serão solicitados pela camada de apresentação. E nosso primeiro use case será para pegar a lista de AndroidJobs:

class GetJobsUseCases(
    private val repository: AndroidJobsRepository,
    private val scheduler: Scheduler
) {

    fun execute(forceUpdate: Boolean): Observable<List<AndroidJob>> {
        return repository.getJobs(forceUpdate)
            .subscribeOn(scheduler)
    }
}

Podemos verificar no construtor que temos duas dependências necessárias para utilizar o UseCase, o repository de onde vamos solicitar a lista de dados, e um scheduler para informar a thread onde vamos assinar a nossa chamada. Essas duas dependências serão entregues utilizando injeção de dependência através do framework koin.

• Di: apenas um pacote para centralizar as dependências desse module:

val useCaseModule = module {

    factory {
        GetJobsUseCases(
            repository = get(),
            scheduler = Schedulers.io()
        )
    }
}

val domainModule = listOf(useCaseModule)

Criamos uma variável chamada useCaseModule que recebera um modulekoin, e dentro desse module as dependências que vamos prover estão. Utilizei o factory pois quero que crie uma nova instância toda vez que for requerida essa dependência. Temos repository = get(), onde o get significa que em algum lugar do projeto essa dependência ja foi criada e só vamos pegar ela para utilizar no UseCase e para o scheduler = Schedulers.io()passamos o Scheduler que queremos utilzar, e nesse caso foi o IO mas poderia ser computation etc. (https://stackoverflow.com/questions/33370339/what-is-the-difference-between-schedulers-io-and-schedulers-computation)

E por fim temos algo assim:

O nosso projeto ainda não faz nada, mas estamos construindo passo a passo. Por essa razão, agora o nosso prêmio é se contentar apenas com a criação da domain.

O ideal seria aplicar testes já nessa etapa, mas primeiro vamos entender os conceitos de modularização e, quando terminarmos, vamos dar start à implementação dos testes.

Domain repo : https://github.com/ifucolo/android-modularization/tree/domain

follow me: https://twitter.com/Iagolfucolo

Revisores:

Rafael Machado

Bruno Stone