Inserción manual de dependencias

La arquitectura de apps recomendada de Android te incentiva a dividir el código en clases para beneficiarte de la separación de preocupaciones, un principio en el que cada jerarquía tiene una responsabilidad única definida. Esto genera más clases pequeñas que deben estar conectadas entre sí para satisfacer las dependencias de cada una.

Las dependencias entre clases se pueden representar como un gráfico, en el que cada clase se conecta con las otras de las que depende. La representación de todas tus clases y sus dependencias conforma el gráfico de la aplicación. En la figura 1, puedes ver una abstracción del gráfico de la aplicación. Cuando la clase A (ViewModel) depende de la clase B (Repository), hay una línea que apunta de A a B que representa esa dependencia.

Inyectar dependencias ayuda a realizar esas conexiones y te permite intercambiar implementaciones para probarlas. Por ejemplo, cuando pruebas un ViewModel que depende de un repositorio, puedes pasar diferentes implementaciones de Repository con simulaciones o simulaciones para probar los diferentes casos.

Conceptos básicos de la inserción de dependencia manual

En esta sección, se explica cómo aplicar la inyección de dependencia manual en una situación real de una app para Android. Se explica en detalle cómo podrías comenzar a usar la inyección de dependencias en tu app. El enfoque mejora hasta que llega a un punto muy similar al que Dagger generaría automáticamente. Para obtener más información sobre Dagger, consulta Conceptos básicos de Dagger.

Considera un flujo como un grupo de pantallas de tu app que corresponden a una función. El acceso, el registro y la confirmación de compras son ejemplos de flujos.

Cuando abarcas un flujo de acceso para una app para Android normal, el LoginActivity depende de LoginViewModel, que a su vez depende de UserRepository. Luego, UserRepository depende de un UserLocalDataSource y un UserRemoteDataSource, que, a su vez, depende de un Retrofit. servicio.

LoginActivity es el punto de entrada al flujo de acceso, y el usuario interactúa con la actividad. Por lo tanto, LoginActivity necesita crear el LoginViewModel con todas sus dependencias.

Las clases Repository y DataSource del flujo se ven así:

class UserRepository(
    private val localDataSource: UserLocalDataSource,
    private val remoteDataSource: UserRemoteDataSource
) { ... }

class UserLocalDataSource { ... }
class UserRemoteDataSource(
    private val loginService: LoginRetrofitService
) { ... }

class UserLocalDataSource {
    public UserLocalDataSource() { }
    ...
}

class UserRemoteDataSource {

    private final Retrofit retrofit;

    public UserRemoteDataSource(Retrofit retrofit) {
        this.retrofit = retrofit;
    }

    ...
}

class UserRepository {

    private final UserLocalDataSource userLocalDataSource;
    private final UserRemoteDataSource userRemoteDataSource;

    public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) {
        this.userLocalDataSource = userLocalDataSource;
        this.userRemoteDataSource = userRemoteDataSource;
    }

    ...
}

A continuación, te mostramos cómo se ve LoginActivity:

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // In order to satisfy the dependencies of LoginViewModel, you have to also
        // satisfy the dependencies of all of its dependencies recursively.
        // First, create retrofit which is the dependency of UserRemoteDataSource
        val retrofit = Retrofit.Builder()
            .baseUrl("https://example.com")
            .build()
            .create(LoginService::class.java)

        // Then, satisfy the dependencies of UserRepository
        val remoteDataSource = UserRemoteDataSource(retrofit)
        val localDataSource = UserLocalDataSource()

        // Now you can create an instance of UserRepository that LoginViewModel needs
        val userRepository = UserRepository(localDataSource, remoteDataSource)

        // Lastly, create an instance of LoginViewModel with userRepository
        loginViewModel = LoginViewModel(userRepository)
    }
}

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // In order to satisfy the dependencies of LoginViewModel, you have to also
        // satisfy the dependencies of all of its dependencies recursively.
        // First, create retrofit which is the dependency of UserRemoteDataSource
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://example.com")
                .build()
                .create(LoginService.class);

        // Then, satisfy the dependencies of UserRepository
        UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
        UserLocalDataSource localDataSource = new UserLocalDataSource();

        // Now you can create an instance of UserRepository that LoginViewModel needs
        UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

        // Lastly, create an instance of LoginViewModel with userRepository
        loginViewModel = new LoginViewModel(userRepository);
    }
}

Este enfoque tiene problemas:

1. Hay mucho código estándar. Si quieres crear otra instancia de LoginViewModel en otra parte del código, habrá código duplicado.

2. Las dependencias deben declararse en orden. Tienes que crear una instancia de UserRepository antes de LoginViewModel para poder crearlo.

3. Es difícil reutilizar objetos. Si quieres volver a usar UserRepository en varias funciones, debes seguir el patrón de singleton. Ese patrón dificulta las pruebas, porque todas las pruebas comparten la misma instancia de singleton.

Cómo administrar dependencias con un contenedor

A fin de resolver el problema de reutilizar objetos, crea tu propia clase de contenedor de dependencias que uses para obtener dependencias. Todas las instancias que proporcione el contenedor pueden ser públicas. En el ejemplo, como solo necesitas una instancia de UserRepository, puedes hacer que sus dependencias sean privadas con la opción de hacerlas públicas en el futuro si es necesario proporcionarlas:

// Container of objects shared across the whole app
class AppContainer {

    // Since you want to expose userRepository out of the container, you need to satisfy
    // its dependencies as you did before
    private val retrofit = Retrofit.Builder()
                            .baseUrl("https://example.com")
                            .build()
                            .create(LoginService::class.java)

    private val remoteDataSource = UserRemoteDataSource(retrofit)
    private val localDataSource = UserLocalDataSource()

    // userRepository is not private; it'll be exposed
    val userRepository = UserRepository(localDataSource, remoteDataSource)
}

// Container of objects shared across the whole app
public class AppContainer {

    // Since you want to expose userRepository out of the container, you need to satisfy
    // its dependencies as you did before
    private Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("https://example.com")
            .build()
            .create(LoginService.class);

    private UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
    private UserLocalDataSource localDataSource = new UserLocalDataSource();

    // userRepository is not private; it'll be exposed
    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);
}

Debido a que esas dependencias se usan en toda la aplicación, deben colocarse en un lugar común que todas las actividades pueden usar: la clase Application. Crea una clase Application personalizada que contenga una instancia de AppContainer.

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
class MyApplication : Application() {

    // Instance of AppContainer that will be used by all the Activities of the app
    val appContainer = AppContainer()
}

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
public class MyApplication extends Application {

    // Instance of AppContainer that will be used by all the Activities of the app
    public AppContainer appContainer = new AppContainer();
}

Ahora puedes obtener la instancia de AppContainer desde la aplicación y obtener la instancia compartida de UserRepository:

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Gets userRepository from the instance of AppContainer in Application
        val appContainer = (application as MyApplication).appContainer
        loginViewModel = LoginViewModel(appContainer.userRepository)
    }
}

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Gets userRepository from the instance of AppContainer in Application
        AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
        loginViewModel = new LoginViewModel(appContainer.userRepository);
    }
}

De esta manera, no tienes un singleton UserRepository. En su lugar, tienes un AppContainer compartido entre todas las actividades que contiene objetos del gráfico y crea instancias de esos objetos que pueden consumir otras clases.

Si se necesita LoginViewModel en más lugares de la aplicación, puedes tener un lugar centralizado donde crees instancias de LoginViewModel. Puedes mover la creación de LoginViewModel al contenedor y proporcionar objetos nuevos de ese tipo con una fábrica. El código para un LoginViewModelFactory se ve así:

// Definition of a Factory interface with a function to create objects of a type
interface Factory<T> {
    fun create(): T
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory(private val userRepository: UserRepository) : Factory {
    override fun create(): LoginViewModel {
        return LoginViewModel(userRepository)
    }
}

// Definition of a Factory interface with a function to create objects of a type
public interface Factory<T> {
    T create();
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory implements Factory {

    private final UserRepository userRepository;

    public LoginViewModelFactory(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public LoginViewModel create() {
        return new LoginViewModel(userRepository);
    }
}

Puedes incluir el LoginViewModelFactory en el AppContainer y hacer que el LoginActivity lo consuma:

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
class AppContainer {
    ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)

    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Gets LoginViewModelFactory from the application instance of AppContainer
        // to create a new LoginViewModel instance
        val appContainer = (application as MyApplication).appContainer
        loginViewModel = appContainer.loginViewModelFactory.create()
    }
}

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
public class AppContainer {
    ...

    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

    public LoginViewModelFactory loginViewModelFactory = new LoginViewModelFactory(userRepository);
}

public class MainActivity extends Activity {

    private LoginViewModel loginViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Gets LoginViewModelFactory from the application instance of AppContainer
        // to create a new LoginViewModel instance
        AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
        loginViewModel = appContainer.loginViewModelFactory.create();
    }
}

Este enfoque es mejor que el anterior, pero todavía hay algunos desafíos que debes considerar:

1. Debes administrar el AppContainer por tu cuenta y crear instancias para todas las dependencias de forma manual.

2. Todavía hay mucho código estándar. Debes crear fábricas o parámetros de forma manual según si deseas reutilizar un objeto o no.

Cómo administrar dependencias en flujos de aplicaciones

AppContainer se complica cuando quieres incluir más funciones en el proyecto. Cuando se expande tu app y comienzas a ingresar diferentes flujos de funciones, surgen aún más problemas:

1. Si tienes flujos diferentes, es posible que quieras que los objetos solo se encuentren dentro del alcance de ese flujo. Por ejemplo, cuando creas LoginUserData (que puede consistir en el nombre de usuario y la contraseña utilizados únicamente en el flujo de acceso), no quieres conservar los datos de un flujo de acceso anterior de otro usuario. Deseas una instancia nueva para cada flujo nuevo. Para lograrlo, crea objetos FlowContainer dentro de AppContainer, como se muestra en el siguiente ejemplo de código.

2. La optimización del gráfico de la aplicación y los contenedores de flujo también puede ser difícil. Recuerda borrar las instancias que no necesites, según el flujo en el que te encuentres.

Imagina que tienes un flujo de acceso compuesto por una actividad (LoginActivity) y varios fragmentos (LoginUsernameFragment y LoginPasswordFragment). Esas vistas quieren:

1. Acceder a la misma instancia de LoginUserData que se debe compartir hasta finalizar el flujo de acceso

2. Crear una nueva instancia de LoginUserData cuando el flujo comience de nuevo

Puedes lograrlo con un contenedor de flujo de acceso. Se debe crear ese contenedor cuando se inicia el flujo de acceso y se lo debe quitar de la memoria cuando termina el flujo.

Agreguemos un LoginContainer al código de ejemplo. Quieres crear varias instancias de LoginContainer en la app, por lo que, en lugar de convertirla en un singleton, conviértela en una clase con las dependencias que necesita el flujo de acceso de AppContainer.

class LoginContainer(val userRepository: UserRepository) {

    val loginData = LoginUserData()

    val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

// AppContainer contains LoginContainer now
class AppContainer {
    ...
    val userRepository = UserRepository(localDataSource, remoteDataSource)

    // LoginContainer will be null when the user is NOT in the login flow
    var loginContainer: LoginContainer? = null
}

// Container with Login-specific dependencies
class LoginContainer {

    private final UserRepository userRepository;

    public LoginContainer(UserRepository userRepository) {
        this.userRepository = userRepository;
        loginViewModelFactory = new LoginViewModelFactory(userRepository);
    }

    public LoginUserData loginData = new LoginUserData();

    public LoginViewModelFactory loginViewModelFactory;
}

// AppContainer contains LoginContainer now
public class AppContainer {
    ...
    public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

    // LoginContainer will be null when the user is NOT in the login flow
    public LoginContainer loginContainer;
}

Una vez que tienes un contenedor específico para un flujo, debes decidir cuándo crear y borrar la instancia de contenedor. Debido a que tu flujo de acceso está contenido en una actividad (LoginActivity), esta es la que administra el ciclo de vida de ese contenedor. LoginActivity puede crear la instancia en onCreate() y borrarla en onDestroy().

class LoginActivity: Activity() {

    private lateinit var loginViewModel: LoginViewModel
    private lateinit var loginData: LoginUserData
    private lateinit var appContainer: AppContainer


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        appContainer = (application as MyApplication).appContainer

        // Login flow has started. Populate loginContainer in AppContainer
        appContainer.loginContainer = LoginContainer(appContainer.userRepository)

        loginViewModel = appContainer.loginContainer.loginViewModelFactory.create()
        loginData = appContainer.loginContainer.loginData
    }

    override fun onDestroy() {
        // Login flow is finishing
        // Removing the instance of loginContainer in the AppContainer
        appContainer.loginContainer = null
        super.onDestroy()
    }
}

public class LoginActivity extends Activity {

    private LoginViewModel loginViewModel;
    private LoginData loginData;
    private AppContainer appContainer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        appContainer = ((MyApplication) getApplication()).appContainer;

        // Login flow has started. Populate loginContainer in AppContainer
        appContainer.loginContainer = new LoginContainer(appContainer.userRepository);

        loginViewModel = appContainer.loginContainer.loginViewModelFactory.create();
        loginData = appContainer.loginContainer.loginData;
    }

    @Override
    protected void onDestroy() {
        // Login flow is finishing
        // Removing the instance of loginContainer in the AppContainer
        appContainer.loginContainer = null;

        super.onDestroy();
    }
}

Al igual que LoginActivity, los fragmentos de registro pueden acceder a LoginContainer desde AppContainer y usar la instancia LoginUserData compartida.

Debido a que en este caso se trata de la lógica del ciclo de vida de las vistas, la observación del ciclo de vida tiene sentido.

Conclusión

La inyección de dependencia es una buena técnica a la hora de crear apps para Android escalables que puedan someterse a prueba. Usa contenedores como una manera de compartir instancias de clases en diferentes partes de tu app y como un lugar centralizado para crear instancias de clases con fábricas.

Cuando se expanda tu aplicación, comenzarás a ver que escribes mucho código estándar (como fábricas), que puede ser propenso a errores. También debes administrar el alcance y el ciclo de vida de los contenedores por tu cuenta, optimizando y descartando los contenedores que ya no se necesitan para liberar memoria. Hacer esto de forma incorrecta puede generar errores sutiles y pérdidas de memoria en tu app.

En la sección sobre Dagger, aprenderás a usar Dagger para automatizar este proceso y generar el mismo código que habrías escrito de forma manual.