Injeção de dependência manual (Views)

Conceitos e implementação do Jetpack Compose

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 mais classes menores que precisam ser conectadas para atender às dependências umas das outras.

Os apps 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 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 a classe A (ViewModel) depende da 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 deRepository 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 manual de dependências em um cenário real de um app 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 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. Em seguida, UserRepository depende de um UserLocalDataSource e um UserRemoteDataSource, que, por sua vez, dependem 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 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 singleton pattern. 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 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 privadas com a opção de torná-las públicas no futuro, se necessário:

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 local comum que todas as atividades possam usar: a classe Application. Crie uma classe Application personalizada que contenha uma instância 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 acessar a instância do AppContainer no aplicativo e receber a instância compartilhada do 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, ter um local centralizado em que você cria instâncias de LoginViewModel faz sentido. Você pode 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<LoginViewModel> {
   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<LoginViewModel> {

   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. É possível fazer isso criando 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.