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.

Figura 1. Um modelo do gráfico de aplicativo de um app 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 as respectivas dependências 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ências ajuda a fazer essas conexões e permite que você troque implementações para testes. Por exemplo, ao testar um ViewModel que depende 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 manual de dependências

Esta seção aborda como aplicar a injeção manual de dependências em um cenário real de um app Android. Ela usa uma abordagem iterada de como é possível começar a usar a injeção de dependências no seu app. Essa 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, correspondente a um recurso. Login, registro e finalizações de compra são exemplos de fluxos.

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

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 respectivas dependências.

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 boilerplate. Caso sua intenção fosse criar outra instância de LoginViewModel em outra parte do código, haveria duplicação de código.

2. Dependências precisam ser declaradas em ordem. É obrigatório instanciar o UserRepository antes do LoginViewModel para a criação.

3. É difícil reutilizar objetos. Caso sua intenção fosse reutilizar o UserRepository em vários recursos, seria necessário fazer com que ele seguisse o padrão singleton. O padrão singleton dificulta a testagem, já que 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 contêiner de dependências, que pode ser usada 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 particulares, com a opção de fazer com que elas sejam públicas no futuro caso precisem 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 Application. Crie uma classe Application personalizada contendo 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();
}

Observação: AppContainer é apenas uma classe normal com uma instância exclusiva compartilhada no app e colocada na classe Application. No entanto, o AppContainer não segue o padrão singleton (link em inglês). No Kotlin, ele não é um object e, no Java, ele não é acessado com o método Singleton.getInstance() típico.

Agora, você pode receber a instância de AppContainer do aplicativo e 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ê possa 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 uma LoginViewModelFactory tem esta aparência:

Kotlin

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

Java

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

Você pode incluir a classe LoginViewModelFactory no AppContainer e fazer com que LoginActivity a 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 que precisam ser considerados:

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

2. Ainda há muito código boilerplate. Você precisa criar fábricas ou parâmetros manualmente, dependendo de querer reutilizar um objeto ou não.

Como gerenciar dependências em fluxos de aplicativos

O AppContainer se torna complicado quando você quer incluir mais funcionalidades 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 de cada um. 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ê tenha 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ça 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 removido da memória ao fim do fluxo.

Veja como adicionar um LoginContainer ao exemplo de código. 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 que você consegue 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), ela 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.

Observação: caso queira que o contêiner sobreviva às mudanças de configuração, siga o guia Como salvar estados da IU. Isso precisa ser processado da mesma forma que o encerramento de processos. Caso contrário, o app pode perder o estado em dispositivos com menos memória.

Conclusão

A injeção de dependências é uma boa técnica para criar apps 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 aplicativo ficar maior, vai ser necessário programar muitos códigos boilerplate (como fábricas), que podem ser propensos a erros. Também é preciso gerenciar o escopo e 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 vazamentos de memória sutis no app.

Na seção sobre o Dagger, você vai aprender a usar esse framework para automatizar esse processo e gerar o mesmo código que você teria programado manualmente.