Injeção manual de dependência

A arquitetura de apps recomendada do Android incentiva a divisão do código em classes para tirar proveito da separação de preocupações, um princípio em que cada classe da hierarquia tem uma única responsabilidade definida. Isso leva a classes menores e mais numerosas, que precisam ser conectadas para atender às dependências umas das outras.

Os apps para Android geralmente são compostos por muitas classes, e algumas delas dependem umas das outras.
Figura 1. Um modelo do gráfico de aplicativo de um app para Android.

As dependências entre as classes podem ser representadas como um gráfico, em que cada classe se conecta às classes de que depende. A representação de todas as classes e dependências delas representam o gráfico do aplicativo. Na Figura 1, é possível ver uma abstração do gráfico do aplicativo. Quando uma classe A (ViewModel) depende de uma classe B (Repository), há uma linha que aponta de A para B representando essa dependência.

A injeção de dependência ajuda a fazer essas conexões e permite que você troque implementações para testes. Por exemplo, ao testar um ViewModel que dependa de um repositório, você pode transmitir implementações diferentes de Repository com falsificações ou simulações para testar os casos diferentes.

Conceitos básicos da injeção de dependência manual

Esta seção aborda como aplicar a injeção de dependência manual em um cenário real de apps para Android. Ela trata de uma abordagem iterada de como é possível começar a usar a injeção de dependência no seu app. A abordagem melhora até chegar a um ponto muito parecido com o que o Dagger geraria automaticamente para você. Para ver mais informações sobre o Dagger, consulte Princípios básicos do Dagger.

Considere um fluxo como um grupo de telas no app que correspondem a um recurso. Login, registro e finalizações de compra são exemplos de fluxos.

Ao cobrir um fluxo de login para um app para Android típico, o LoginActivity depende de LoginViewModel, que, por sua vez, depende de UserRepository. Em seguida, UserRepository depende de UserLocalDataSource e uma UserRemoteDataSource, que, por sua vez, depende de um serviço Retrofit.

LoginActivity é o ponto de entrada para o fluxo de login, e o usuário interage com a atividade. Assim, LoginActivity precisa criar o LoginViewModel com todas as dependências dele.

As classes Repository e DataSource do fluxo têm esta aparência:

Kotlin

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

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

Java

    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;
        }

        ...
    }
    

Veja a aparência de LoginActivity:

Kotlin

    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)
        }
    }
    

Java

    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);
        }
    }
    

Há problemas com essa abordagem:

  1. Há muitos códigos de texto clichê. Se sua intenção for criar outra instância de LoginViewModel em outra parte do código, haverá duplicação de código.

  2. Dependências precisam ser declaradas em ordem. É obrigatório instanciar UserRepository antes de LoginViewModel para criá-lo.

  3. É difícil reutilizar objetos. Se sua intenção for reutilizar o UserRepository em vários recursos, será necessário fazer ele seguir o padrão singleton. O padrão singleton dificulta o teste, porque todos os testes compartilham a mesma instância singleton.

Como gerenciar dependências com um contêiner

Para resolver o problema de reutilização de objetos, você pode criar a própria classe de dependências de contêiner, que você usará para conseguir dependências. Todas as instâncias fornecidas por esse contêiner podem ser públicas. No exemplo, como você só precisa de uma instância de UserRepository, é possível tornar as dependências privadas com a opção de torná-las públicas no futuro se elas precisarem ser fornecidas:

Kotlin

    // 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)
    }
    

Java

    // 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);
    }
    

Como essas dependências são usadas em todo o aplicativo, elas precisam ser colocadas em um lugar comum que todas as atividades possam usar: a classe do aplicativo. Crie uma classe de aplicativo personalizada que contenha uma instância de AppContainer.

Kotlin

    // 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()
    }
    

Java

    // 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();
    }
    

Agora você pode receber a instância de AppContainer do aplicativo e receber o compartilhado da instância de UserRepository:

Kotlin

    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)
        }
    }
    

Java

    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);
        }
    }
    

Dessa forma, você não tem um UserRepository singleton. Em vez disso, você tem um AppContainer compartilhado por todas as atividades que contêm objetos do gráfico e que criam instâncias desses objetos que outras classes podem consumir.

Se LoginViewModel for necessário em mais lugares no aplicativo, é recomendável ter um local centralizado onde você pode criar instâncias de LoginViewModel. É possível mover a criação de LoginViewModel para o contêiner e fornecer novos objetos desse tipo com uma fábrica. O código de um LoginViewModelFactory tem esta aparência:

Kotlin

    // Definition of a Factory interface with a function to create objects of a type
    interface Factory {
        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)
        }
    }
    

Java

    // Definition of a Factory interface with a function to create objects of a type
    public interface Factory {
        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);
        }
    }
    

Você pode incluir o LoginViewModelFactory no AppContainer e fazer com que LoginActivity o consuma:

Kotlin

    // 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()
        }
    }
    

Java

    // 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();
        }
    }
    

Essa abordagem é melhor do que a anterior, mas ainda há alguns desafios a serem considerados:

  1. Você gerenciar o AppContainer por conta própria, criando instâncias para todas as dependências manualmente.

  2. Ainda há muitos códigos de texto clichê. Você precisa criar fábricas ou parâmetros manualmente dependendo de se quer reutilizar um objeto ou não.

Como gerenciar dependências em fluxos de aplicativos

AppContainer torna-se complicado quando você quer incluir mais funções no projeto. Quando o app fica maior e você começa a apresentar diferentes fluxos de recursos, surgem ainda mais problemas:

  1. Quando há fluxos diferentes, é recomendável que os objetos estejam no escopo desse fluxo. Por exemplo, ao criar LoginUserData, que pode consistir no nome de usuário e senha usados somente no fluxo de login, não convém persistir dados do fluxo de login antigo de um usuário diferente. É recomendável criar uma nova instância para cada novo fluxo. Para isso, crie objetos FlowContainer dentro do AppContainer, conforme demonstrado no próximo exemplo de código.

  2. Otimizar o gráfico do aplicativo e os contêineres de fluxo também pode ser difícil. É preciso lembrar de excluir instâncias que não são necessárias, dependendo do fluxo em uso.

Imagine que você tem um fluxo de login que consiste em uma atividade (LoginActivity) e vários fragmentos (LoginUsernameFragment e LoginPasswordFragment). Essas visualizações buscam:

  1. acessar a mesma instância de LoginUserData, que precisa ser compartilhada até que o fluxo de login seja concluído;

  2. criar uma nova instância de LoginUserData quando o fluxo começar novamente.

É possível fazer isso usando um contêiner de fluxo de login. Esse contêiner precisa ser criado quando o fluxo de login é iniciado e precisa ser removido da memória quando o fluxo termina.

Veja como adicionar um LoginContainer ao código de exemplo. Convém criar várias instâncias de LoginContainer no app. Portanto, em vez de torná-lo um singleton, crie uma classe com as dependências necessárias para o fluxo de login do AppContainer.

Kotlin

    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
    }
    

Java

    // 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;
    }
    

Depois de ter um contêiner específico para um fluxo, é preciso decidir quando criar e excluir a instância do contêiner. Como o fluxo de login é autossuficiente em uma atividade (LoginActivity), a atividade gerencia o ciclo de vida desse contêiner. LoginActivity pode criar a instância em onCreate() e excluí-la em onDestroy().

Kotlin

    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()
        }
    }
    

Java

    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();
        }
    }
    

Como em LoginActivity, os fragmentos de login podem acessar o LoginContainer pelo AppContainer e usar a instância compartilhada de LoginUserData.

Como neste caso você está lidando com a lógica do ciclo de vida da visualização, é recomendável usar a observação do ciclo de vida.

Conclusão

A injeção de dependência é uma boa técnica para criar apps para Android escalonáveis e testáveis. Use contêineres como uma maneira de compartilhar instâncias de classes em diferentes partes do app e como um local centralizado para criar instâncias de classes usando fábricas.

Quando o app ficar maior, será preciso escrever muitos códigos clichê (como fábricas), que podem ser propensos a erros. Também é preciso gerenciar o escopo e o ciclo de vida dos contêineres, otimizando e descartando os que não são mais necessários para liberar memória. Fazer isso incorretamente pode levar a bugs e a vazamentos de memória sutis no app.

Na próxima página, você aprenderá a usar o Dagger para automatizar esse processo e gerar automaticamente o mesmo código que você teria escrito manualmente.