Como primeiro passo, vamos entender o funcionamento do nosso projeto, tanto na parte de features quanto na implementação de código. Dessa maneira, identificaremos o cenário atual e como o Navigation, o componente que estudaremos nesse curso, acabará nos ajudando.
O projeto é uma simulação de loja online de produtos esportivos chamada Alura Esporte. Na primeira tela, temos uma lista de produtos com o preço de cada um deles:
Bola de futebol R$100,00
Camisa R$80,00
Chuteira R$120,00
Bermuda R$60,00
Se clicamos em um desses elementos, vamos para uma tela de detalhes do produto. Nela, o nome do produto e o valor são apresentados em uma fonte maior, e na parte de baixo da tela temos um botão de "Comprar". Clicando nele, temos acesso à ultima tela, que é a tela de pagamento. Essa tela possui o valor do produto e campos para serem preenchidos com os dados do cartão (número, data de validade e código de verificação). Como se trata de uma simulação e não existem validações ou integrações com algum tipo de API de pagamento, esses campos podem ser preenchidos livremente. Clicando em "confirmar", a mensagem "Compra realiza" é exibida na tela. Esse é o cenário normal no fluxo do nosso aplicativo.
Agora que entendemos a parte visual, vamos analisar como funciona o nosso código e quais são as peculiaridades que poderemos melhor. Antes de tudo, é importante ressaltar que estamos mantendo a arquitetura que vimos no curso de Architecture Components, representada pelo diagrama abaixo.

Como a imagem mostra, na nossa aplicação teremos Activities/Fragments, ViewModels, LiveData, repositórios, e, especificamente aqui, trabalharemos diretamente com um banco de dados interno, sem integração com uma Web API (para evitarmos maiores complexidades no projeto). Com exceção desse último ponto, o núcleo do nosso projeto é o apresentado no diagrama.
Tendo entendido a estrutura, vamos analisar a implementação. Se queremos ver a tela de lista de produtos, podemos acessar o nosso source set do java br.com.alura.aluraesporte. Dentro desse diretório, teremos nossa ui os nossos fragments, onde estarão representadas as telas.
Sendo assim, teremos um fragment para lista de produtos, outro para tela de pagamento, outro para detalhes do produto e assim por diante. Cada tela é representada por um fragment, e, consequentemente, teremos apenas uma activity mantendo essas telas.
Como comentamos no curso de fragments, existe a possibilidade de criar aplicativos com vários fragments e uma única activity. No curso atual, optamos por essa amostra justamente para mostrar como seria essa implementação.
Em ProdutosActivity, por mais que tenhamos os detalhes de cada um dos produtos, temos também o pagamento - o que não faz muito sentido com base nesse nome. Porém, isso é apenas para termos essa demonstração, e iremos refatorar o código no futuro.
private const val COMPRA_REALIZADA = "Compra realizada"
class ProdutosActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.produtos_activity)
if (savedInstanceState == null) {
val produtosFragment: ListaProdutosFragment by inject()
transacaoFragment {
replace(R.id.container, produtosFragment)
}
}
}
override fun onAttachFragment(fragment: Fragment?) {
super.onAttachFragment(fragment)
when (fragment) {
is ListaProdutosFragment -> {
fragment.quandoProdutoSelecionado = { produtoSelecionado ->
val detalhesProdutoFragment: DetalhesProdutoFragment by inject()
val argumentos = Bundle()
argumentos.putLong(CHAVE_PRODUTO_ID, produtoSelecionado.id)
detalhesProdutoFragment.arguments = argumentos
transacaoFragment {
addToBackStack(null)
replace(R.id.container, detalhesProdutoFragment)
}
}
}
is DetalhesProdutoFragment -> {
fragment.quandoProdutoComprado = { produtoComprado ->
val pagamentoFragment: PagamentoFragment by inject()
val dado = Bundle()
dado.putLong(CHAVE_PRODUTO_ID, produtoComprado.id)
pagamentoFragment.arguments = dado
transacaoFragment {
addToBackStack(null)
replace(R.id.container, pagamentoFragment)
}
}
}
is PagamentoFragment -> {
fragment.quandoPagamentoRealizado = {
Toast.makeText(this, COMPRA_REALIZADA, Toast.LENGTH_LONG).show()
}
}
}
}
}
No começo, criamos a nossa lista de produtos (ListaProdutosFragment) e fazemos as configurações via onAttachFragment para pegarmos os listeners - temos o listener para a lista de produtos, outro para detalhes do produto e outro para o pagamento. Quanto mais criamos fragments para mantermos uma única activity principal, mais aumentamos a complexidade de implementação desses listeners.
Uma tela mais complexa, com vários botões e vários listeners, nossa activity será muito grande, e manter esse código acabará sendo não trivial. Pensando nesse tipo de implementação, temos a alternativa de utilizar um componente chamado Navigation. Mas como ele pode melhorar a nossa experiência?
O Navigation vem com a proposta de implementar um aplicativo com vários telas considerando uma única activity, da mesma maneira que vimos no nosso projeto. A diferença é que isso será uma experiência mais fácil para quem desenvolve aplicativos, nos permitindo um resultado diferente daquele obtido quando mantemos todo o código na activity e sem uma visualização das interações possíveis.
Inclusive, o Navigation, por padrão, tem uma proposta interessante de seguir os princípios de navegação dentro de um aplicativo. Essas e outras informações serão destrinchadas durante o curso.
Recapitulando: no cenário atual, temos um aplicativo muito simples que utiliza uma arquitetura aprendida em outros cursos, porém com a dificuldade de manter todo o código (diversos fragments) em uma única activity. Nosso objetivo é facilitar o desenvolvimento desse código com o Navigation.
Sinta-se à vontade para explorar o projeto e aprender mais sobre ele. Por exemplo, estamos utilizando injeção de dependência com coin, repositórios, room e outras tecnologias que já conhecemos nos cursos anteriores.
Um detalhe importante: no coin, fizemos duas instâncias do banco de dados - uma de teste e outra de produção. O objetivo da instância de teste é preencher os produtos, de forma que não precisaremos coloca-los manualmente. Também temos uma novidade, que são as Coroutines, uma abordagem para processamento paralelo (como se fossem threads, mas com uma certa diferença). Esse conteúdo será abordado nos exercícios do curso.
Se tiver com dúvidas em relação a alguma abordagem, não deixe de buscar o fórum do curso! A seguir conhecemos um pouco mais sobre a proposta do Navigation e outros detalhes teóricos para prosseguirmos com o curso.