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.

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:
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;
}
...
}
Veja a aparência de 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);
}
}
Há problemas com essa abordagem:
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.Dependências precisam ser declaradas em ordem. É obrigatório instanciar o
UserRepository
antes doLoginViewModel
para a criação.É 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:
// 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);
}
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
.
// 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();
}
Agora, você pode receber a instância de AppContainer
do aplicativo e
o compartilhado da instância 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);
}
}
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:
// 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
// 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
Você pode incluir a classe LoginViewModelFactory
no AppContainer
e fazer com que
LoginActivity
a 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();
}
}
Essa abordagem é melhor do que a anterior, mas ainda há alguns desafios que precisam ser considerados:
Você precisa gerenciar o
AppContainer
por conta própria, criando instâncias para todas as dependências manualmente.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:
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 objetosFlowContainer
dentro doAppContainer
, conforme demonstrado no próximo exemplo de código.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:
acessar a mesma instância de
LoginUserData
, que precisa ser compartilhada até que o fluxo de login seja concluído;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
.
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;
}
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()
.
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();
}
}
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ê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.