Migración de la capa de casos de uso

Para tener una idea más clara de cómo se puede separar la lógica de cada nivel dependiendo de su responsabilidad, se puede migrar las clases relacionadas con los casos de uso a un nuevo módulo.

Nota: Para ver el resultado de esta migración, puedes revisar el código a partir de la rama extra_use_cases_module.

Crear nuevo módulo

1.- Da clic derecho sobre la carpeta principal del proyecto y selecciona la opción Nuevo -> Módulo.

2.- Selecciona el tipo de módulo que vas a crear como se indica en la siguiente imagen (para los casos de uso, bastará crear una biblioteca de tipo Android o Android Library).

3.- Nombra al nuevo módulo usecases y cambia su nombre de paquete como se muestra en la siguiente imagen. Selecciona la opción de finalizar.

Configurar archivos build.gradle

1.- Implementa las dependencias con las que los casos de uso trabajan: los niveles de datos, entidades, Kotlin y RxJava como se muestra en el siguiente fragmento de código.

build.gradle (usecases)

dependencies {
    //Project
    implementation project(":data")
    implementation project(":domain")

    //Kotlin
    implementation kotlinLib

    //RxJava
    implementation rxJavaLib
}

2.- Agrega la dependencia de casos de uso a la aplicación como se muestra en el siguiente fragmento de código.
build.gradle (app)

dependencies {
    //Project
    ...
    implementation project(":usecases")
    ...
}

Mover casos de uso al nuevo módulo

1.- Toma todos los cases de uso en el módulo de app y mueve cada uno de ellos a un nuevo archivo que puedas llamar UseCases en el módulo que acabas de crear.

UseCases.kt

package com.platzi.android.rickandmorty.usecases

import com.platzi.android.rickandmorty.data.CharacterRepository
import com.platzi.android.rickandmorty.data.EpisodeRepository
import com.platzi.android.rickandmorty.domain.Character
import com.platzi.android.rickandmorty.domain.Episode
import io.reactivex.Flowable
import io.reactivex.Maybe
import io.reactivex.Single

class GetAllCharactersUseCase(
    private val characterRepository: CharacterRepository
) {

    fun invoke(currentPage: Int): Single<List<Character>> =
        characterRepository.getAllCharacters(currentPage)
}

class GetAllFavoriteCharactersUseCase(
    private val characterRepository: CharacterRepository
) {

    fun invoke(): Flowable<List<Character>> = characterRepository.getAllFavoriteCharacters()
}

class GetEpisodeFromCharacterUseCase(
    private val episodeRepository: EpisodeRepository
) {

    fun invoke(episodeUrlList: List<String>): Single<List<Episode>> =
        episodeRepository.getEpisodeFromCharacter(episodeUrlList)
}

class GetFavoriteCharacterStatusUseCase(
    private val characterRepository: CharacterRepository
) {

    fun invoke(characterId: Int): Maybe<Boolean> =
        characterRepository.getFavoriteCharacterStatus(characterId)
}

class UpdateFavoriteCharacterStatusUseCase(
    private val characterRepository: CharacterRepository
) {

    fun invoke(character: Character): Maybe<Boolean> =
        characterRepository.updateFavoriteCharacterStatus(character)
}

2.- Asegúrate de que tanto Activities y Fragments, así como ViewModels, utilicen los casos de uso a partir del módulo que creaste. Ejemplo: CharacterListViewModel utiliza el caso de uso GetAllCharactersUseCase a partir del módulo usecases como se muestra en el siguiente fragmento de código.

CharacterListViewModel.kt

...
import com.platzi.android.rickandmorty.usecases.GetAllCharactersUseCase
...
class CharacterListViewModel(
    private val getAllCharactersUseCase: GetAllCharactersUseCase
): ViewModel() {
...
}

Podemos llegar a la conclusión de que, al separar parte de nuestra lógica en distintos módulos o paquetes, tienes un panorama más amplio de las clases que se llevan a cabo en tus proyectos, y de esa manera, se vuelve más fácil agregar, modificar o quitar funcionalidades.