PDF - VERSÃO DE IMPRESSÃO

Lição 20: Android Studio, widgets, sessões e diretórios do Android

objetivo

Olá, estudante, tudo bem? Depois dessa jornada onde você pôde ter uma visão geral de como desenvolver aplicativos Android com segurança, boas práticas e ferramentas, chegou a hora de finalizarmos a disciplina aprendendo um pouco mais sobre ele, o Android Studio: seus widgets, sessões e diretórios.

Dessa forma, o objetivo desta lição é proporcionar a você, estudante, uma compreensão sólida da estrutura de um projeto Android desenvolvido com Kotlin, permitindo-lhe que reconheça e organize corretamente os diretórios, arquivos e componentes essenciais da aplicação. Ao longo desta lição, serão explorados os principais recursos do Android Studio, incluindo a configuração de widgets e o gerenciamento de sessões bem como o papel de cada parte da arquitetura do projeto — como as pastas res, manifest, java e gradle — na construção de aplicativos funcionais e escaláveis.

Além disso, você entenderá as práticas recomendadas para a realização de testes unitários e de interface, estes, essenciais para garantir a qualidade, a estabilidade e a confiabilidade dos aplicativos desenvolvidos.

Ao final da lição, você, futuro(a) Técnico(a) em Desenvolvimento de Sistemas, será capaz de estruturar corretamente um projeto Android, compreender a função dos principais diretórios e arquivos, configurar elementos interativos (widgets) e aplicar testes automatizados para validar o funcionamento da aplicação, de forma eficiente e profissional. Vamos lá?

problematização

No início da jornada de desenvolvimento para Android, muitos estudantes enfrentam uma barreira comum: a dificuldade em compreender a organização e o funcionamento interno do Android Studio e dos projetos nele desenvolvidos. Sem esse entendimento, tarefas básicas como localizar arquivos, configurar elementos da interface, compreender o ciclo de vida de uma aplicação ou aplicar testes tornam-se confusas e propensas a erros.

Além disso, a falta de familiaridade com widgets, sessões e diretórios pode comprometer a eficiência do desenvolvimento, resultando em aplicativos com falhas estruturais, de usabilidade ou de desempenho. Por isso, conhecer em profundidade o Android Studio, os widgets disponíveis, as sessões de execução e a função de cada diretório dentro do projeto é essencial para garantir um processo de criação fluido, seguro e organizado. Essa base técnica permite ao futuro desenvolvedor transformar ideias em aplicativos funcionais, bem estruturados e capazes de evoluir com qualidade.

Agora, vamos entender como o Android Studio, os widgets, as sessões e os diretórios do Android funcionam na prática?

case

Para ilustrar como o Android Studio, os widgets, as sessões e os diretórios do Android funcionam na prática, conheça a empresa fictícia DevTrack Solutions, que enfrentava baixa produtividade em projetos Android devido à dificuldade dos desenvolvedores iniciantes em compreender a estrutura dos projetos. Essa falta de entendimento causava retrabalho, desorganização de arquivos e erros relacionados tanto às widgets quanto às sessões de execução.

Para superar essas dificuldades, a equipe da empresa investiu em capacitação técnica, aprimorando o uso do Android Studio, a organização dos diretórios e a aplicação correta de widgets e sessões. Com isso, os desenvolvedores passaram a integrar melhor os recursos visuais à lógica do aplicativo, realizar testes automatizados e identificar, com mais precisão, as falhas.

Como resultado, a produtividade da equipe aumentou significativamente, o tempo de entrega dos projetos foi reduzido e a qualidade final dos aplicativos começou a refletir uma estrutura mais organizada, com menos erros e melhor desempenho. Assim, a DevTrack Solutions conseguiu alinhar sua prática de desenvolvimento às boas práticas do ecossistema Android, entregando soluções mais estáveis e profissionais aos seus clientes.

É importante destacar que esse é apenas um exemplo ilustrativo. Com a mesma atenção à capacitação técnica, à organização do projeto e ao uso correto de recursos do Android, é possível criar diversos outros aplicativos, ampliando a variedade bem como a qualidade das soluções desenvolvidas. Vamos aprender mais?

Conceitualização

O Android Studio é o ambiente de desenvolvimento integrado (IDE) oficial para criação de aplicativos Android. Conforme apontado por Developer Android (Conheça [...], 2025, on-line), ele foi desenvolvido com base no editor de código e nas ferramentas para desenvolvedores avançados do IntelliJ IDEA. Desenvolvido e mantido pelo Google, o ambiente fornece todas as ferramentas necessárias para programar, testar e empacotar aplicações móveis com eficiência. Sua principal finalidade é oferecer um espaço completo e integrado onde o desenvolvedor pode escrever código Kotlin ou Java, construir interfaces visuais, simular dispositivos, gerenciar bibliotecas e executar testes com facilidade.

A interface do Android Studio é composta por diferentes painéis que ajudam a organizar o trabalho do desenvolvedor. O painel Project permite visualizar a estrutura de arquivos do projeto, o Editor central é onde o código-fonte é escrito, e a janela de Logcat funciona como uma ferramenta de linha de comando que despeja um registro de mensagens do sistema, incluindo mensagens escritas por você no app com a class Log, além de mensagens do sistema e erros em tempo real durante a execução do aplicativo.

Ao iniciar um novo projeto, o Android Studio solicita a configuração inicial, incluindo o nome do aplicativo, a linguagem de programação (Kotlin, nesse caso), o tipo de dispositivo-alvo (telefone, tablet, TV etc.) e o template da tela inicial. Após a criação, o projeto é estruturado automaticamente em diretórios como java/, res/, manifests/ e arquivos como build.gradle, essenciais para a configuração do projeto.

O Gradle, por sua vez, é o sistema de automação utilizado pelo Android Studio para compilar o projeto, gerenciar dependências (como bibliotecas externas) e configurar versões de build. Developer Android (Visão [...], 2025a, on-line) explica que os aplicativos são realmente criados usando o sistema de construção do Gradle. Por meio do arquivo build.gradle, o desenvolvedor define, por exemplo, quais bibliotecas serão usadas no projeto, a versão mínima do Android suportada e os módulos que fazem parte do app. Entender essa estrutura e os recursos do Android Studio é o primeiro passo para um desenvolvimento Android eficiente, organizado e alinhado às boas práticas da plataforma.

Estrutura de diretórios de um projeto Android

Em projetos Android desenvolvidos com Kotlin, compreender a estrutura de diretórios é essencial para manter a organização do código, facilitar a manutenção do projeto e garantir o bom funcionamento da aplicação. Essa estrutura é automaticamente gerada pelo Android Studio quando um novo projeto é criado e segue um padrão que separa responsabilidades de forma clara.

A pasta src/ (source) contém o código-fonte do aplicativo. Dentro dela, a subpasta main/ abriga os arquivos principais, como o código Kotlin (java/), os recursos visuais e textuais (res/) e o arquivo de configuração central do aplicativo (AndroidManifest.xml). A pasta java/, apesar do nome, armazena também os arquivos escritos em Kotlin, respeitando o caminho do pacote da aplicação. É onde ficam as Activities, ViewModels, Composables e outras classes que compõem a lógica do aplicativo.

A pasta res/ (resources) armazena os recursos utilizados pelo aplicativo, como imagens, textos, cores e arquivos de layout. Nela, o diretório drawable/ armazena imagens e ícones, layout/ contém os arquivos de definição de interface (como XMLs, ou, em projetos mais modernos, estruturas auxiliares para Compose), e values/ guarda arquivos XML que definem cores, strings e estilos reutilizáveis, promovendo tanto a organização quanto a reutilização de elementos visuais e textuais.

Segundo Developer Android (Ferramenta [...], 2025, on-line), o AndroidManifest.xml descreve informações essenciais sobre o app para as ferramentas de build do Android, para o sistema operacional Android e para o Google Play. Ele define informações essenciais como o nome do pacote, permissões necessárias (por exemplo, acesso à internet), declarações de atividades (Activities), serviços e a MainActivity, que é o ponto de entrada da aplicação. Além disso, ele também participa do controle do ciclo de vida do app, pois especifica como os componentes se comportam e interagem com o sistema Android.

Já os arquivos build.gradle são responsáveis pela configuração e automação da construção do aplicativo. No build.gradle (nível de módulo), o desenvolvedor define as versões do SDK, as dependências (como bibliotecas externas), plugins e configurações de build. No build.gradle (nível de projeto), são definidas regras globais para todos os módulos. Esses arquivos trabalham em conjunto com o Gradle para compilar, empacotar e distribuir o aplicativo corretamente.

Entender a função de cada pasta e arquivo nessa estrutura é fundamental para o desenvolvedor conseguir navegar, modificar e escalar um projeto Android de maneira profissional e eficiente.

Widgets no Android com Jetpack Compose

No contexto do desenvolvimento Android com Jetpack Compose, que, segundo Developer Android (Desenvolver [...], c2025, on-line), é um kit de ferramentas moderno recomendado para criar interfaces nativas com menos código, maior tecnologia e API Kotlin intuitivas, os widgets são componentes visuais reutilizáveis que permitem ao desenvolvedor construir interfaces de forma modular, prática e declarativa. Esses widgets correspondem aos elementos que o usuário vê e com os quais interage em um aplicativo, como botões, textos, campos de entrada e imagens, ou seja, eles constituem a base visual e interativa de qualquer aplicação.

O Jetpack Compose, sendo um framework moderno da Google para construção de User Interface (UI), oferece uma coleção rica de widgets nativos escritos em Kotlin. Exemplos comuns incluem Button, Text, TextField, Image, Checkbox e Card. Esses elementos são chamados diretamente em funções composables, o que simplifica a criação de interfaces e reduz a necessidade de arquivos XML, característicos do modelo tradicional.

A composição e customização desses widgets são altamente flexíveis. Com Jetpack Compose, o desenvolvedor pode agrupar widgets em layouts (Column, Row, Box), aplicar modificadores (Modifier.padding, Modifier.clickable, Modifier.fillMaxWidth) e personalizar aspectos como cores, bordas, tamanhos e comportamento, diretamente no código Kotlin. Isso favorece a reutilização de componentes e a criação de interfaces consistentes com menos esforço.

Além da construção visual, é essencial aplicar boas práticas de responsividade e acessibilidade. Para garantir que o aplicativo funcione bem em diferentes tamanhos de tela e dispositivos, os widgets devem ser utilizados com dimensões flexíveis e adaptáveis, evitando valores fixos, quando possível. Para promover a acessibilidade, é recomendável incluir descrições nos componentes interativos (por meio de contentDescription), utilizar contraste adequado de cores e permitir navegação assistiva, como suporte a leitores de tela.

Neste sentido, dominar os widgets do Jetpack Compose, além de facilitar o desenvolvimento visual de aplicativos Android modernos, também contribui para a criação de interfaces mais intuitivas, inclusivas e alinhadas às diretrizes do Material Design.

Sessões e ciclo de vida da aplicação Android

Em aplicativos Android, o conceito de sessão refere-se ao período no qual o usuário está ativamente utilizando o aplicativo, ou seja, desde o momento em que ele é aberto até seu encerramento, ou passagem, para segundo plano.

Entender como as sessões funcionam é essencial para garantir uma experiência contínua e coerente, por meio da preservação de dados e do ajuste do comportamento da interface bem como para evitar perdas inesperadas de informações durante o uso.

O gerenciamento do ciclo de vida da aplicação é uma das responsabilidades mais importantes do desenvolvedor e diferencia-se do gerenciamento do ciclo de vida de uma sessão, pois está relacionado à forma como os componentes do app são criados, exibidos, pausados e destruídos. Tradicionalmente, esse ciclo é controlado por meio da Activity, que passa por estados como onCreate, onStart, onResume, onPause, onStop e onDestroy. Esses métodos definem o momento em que uma tela é inicializada, exibida, interrompida ou encerrada.

No Jetpack Compose, embora a abordagem visual seja diferente, ainda é necessário compreender o ciclo de vida das Activities e ViewModels, já que Compose se integra com essas estruturas para reagir de forma segura e eficiente às mudanças de estado. Para visualizar melhor essa sequência de estados, observe a Figura 1:

Figura 1 – Ciclo de vida das Actitivies em aplicativos AndroidFonte: adaptada de Developer Android (Visão [...], 2025b, on-line).

#PraCegoVer: a imagem é um fluxograma que descreve o ciclo de vida de uma atividade (Activity) no sistema Android, ilustrando os estados e métodos chamados desde o lançamento até o encerramento da atividade. No início, temos o estado "Activity launched" (atividade lançada), que aciona o método onCreate(), responsável pela criação inicial da atividade. Em seguida, vem onStart(), indicando que a atividade está prestes a se tornar visível, depois, onResume(), momento em que a atividade passa para o estado "Activity running" (atividade rodando), totalmente em primeiro plano e interativa. Durante a execução, se outra atividade vem para primeiro plano, o método onPause() é chamado, quando a atividade atual perde o foco, mas ainda pode estar parcialmente visível. Se a atividade se torna completamente invisível, o método onStop() é chamado. Se o usuário retorna à atividade após onPause(), o fluxo volta para onResume(). Caso a atividade esteja parada (após onStop()), ao ser reiniciada, chama-se onRestart(), que leva novamente para onStart() e onResume(). Se a atividade está sendo finalizada, normalmente, pelo sistema ou pelo usuário, chama-se onDestroy(), levando ao estado "Activity shut down" (atividade encerrada). Existe ainda a possibilidade de o sistema matar o processo da aplicação (indicando "App process killed") para liberar memória a apps com mais prioridade, o que interrompe imediatamente o ciclo de vida. Setas indicam as transições possíveis entre esses métodos e estados, com explicações textuais sobre o que ocorre em cada fase, como "User navigates to the activity" (usuário navega para a atividade), "User returns to the activity" (usuário retorna) e "Apps with higher priority need memory" (apps com mais prioridade precisam de memória). As cores destacam os estados principais: azul para o início, verde para o estado rodando, cinza para os métodos callbacks, e laranja para os estados de encerramento da atividade ou do processo do aplicativo.

Outro ponto fundamental é a persistência e recuperação de dados durante mudanças de configuração, como a rotação da tela ou a mudança de idioma. Técnicas tais qual o uso de rememberSaveable no Compose ou o uso de ViewModel com SavedStateHandle, ajudam a manter os dados da interface preservados mesmo quando a Activity é recriada. Isso evita frustrações, por exemplo, a perda de informações digitadas pelo usuário ou a reinicialização desnecessária de processos.

Portanto, gerenciar corretamente as sessões e o ciclo de vida da aplicação tem impacto direto na performance e experiência do usuário. Aplicativos que não lidam bem com essas transições tendem a consumir mais recursos do sistema, apresentar travamentos ou comportamento inesperado. Por sua vez, apps bem planejados nesse aspecto oferecem fluidez, preservam o contexto do usuário e otimizam o uso de memória e bateria, promovendo maior satisfação e retenção.

saiba aplicar

Para você, futuro(a) Técnico(a) em Desenvolvimento de Sistemas, dominar a estrutura de um projeto Android no Android Studio é fundamental para construir aplicativos organizados, eficientes e fáceis de manter. Compreender o papel de diretórios como res, manifest, java e gradle, além de saber configurar corretamente widgets e sessões, permite que você, enquanto futuro profissional, desenvolva soluções mais estáveis e escaláveis.

Essa base técnica também facilita a aplicação de testes unitários e de interface, contribuindo diretamente para a qualidade final do software. Ao aplicar esses conhecimentos, você se tornará mais preparado para enfrentar os desafios do mercado e entregar produtos que atendam aos padrões profissionais exigidos pela indústria.

Agora é sua vez! Você aplicará como observar e reagir aos estados do ciclo de vida da Activity em um aplicativo feito com Jetpack Compose. Para isso, siga os passos:

1. Crie um projeto com as seguintes opções:

a. Nome do projeto: CicloDeVidaCompose.
b. Tipo de template: Empty Activity.

2. Crie a interface com Compose criando o componente CicloDeVidaUI() conforme a Figura 2, a seguir:

Figura 2 – Componente CicloDeVidaUIFonte: o autor.

#PraCegoVer: a figura apresenta um trecho de código em Jetpack Compose. Na linha 1, temos @Composable; na linha 2, fun CicloDeVidaUI() {; na linha 3, Column(; na linha 4, modifier = Modifier.fillMaxSize().padding(24.dp),; na linha 5, verticalArrangement = Arrangement.Center; na linha 6, ) {; na linha 7, Text(text = "Monitorando o ciclo de vida da Activity", style = MaterialTheme.typography.headlineSmall); na linha 8, Spacer(modifier = Modifier.height(16.dp)); na linha 9, Text(text = "Abra o Logcat ou observe os Toasts ao interagir com o app."); na linha 10, }; e, na linha 11, }.

3. No Arquivo MainActivity.kt, inclua o Toast e o Log para acompanhar a execução em todos os métodos do ciclo de vida da Activity, conforme a Figura 3:

Figura 3 – MainActivityFonte: o autor.

#PraCegoVer: a figura apresenta um trecho de código em Kotlin. Na linha 1, class MainActivity : ComponentActivity() {; na linha 2, private val TAG = "CicloDeVida"; na linha 3 em branco; na linha 4, override fun onCreate(savedInstanceState: Bundle?) {; na linha 5, super.onCreate(savedInstanceState); na linha 6, enableEdgeToEdge(); na linha 7, setContent {; na linha 8, PM2_Licao20Theme {; na linha 9, CicloDeVidaUI(); na linha 10, }; na linha 11, }; na linha 12, Toast.makeText(this, "onCreate", Toast.LENGTH_SHORT).show(); na linha 13, Log.d(TAG, "onCreate chamado"); na linha 14, }. Na linha 16, override fun onStart() {; na linha 17, super.onStart(); na linha 18, Toast.makeText(this, "onStart", Toast.LENGTH_SHORT).show(); na linha 19, Log.d(TAG, "onStart chamado"); na linha 20, }. Na linha 22, override fun onResume() {; na linha 23, super.onResume(); na linha 24, Toast.makeText(this, "onResume", Toast.LENGTH_SHORT).show(); na linha 25, Log.d(TAG, "onResume chamado"); na linha 26, }. Na linha 28, override fun onPause() {; na linha 29, super.onPause(); na linha 30, Toast.makeText(this, "onPause", Toast.LENGTH_SHORT).show(); na linha 31, Log.d(TAG, "onPause chamado"); na linha 32, }. Na linha 34, override fun onStop() {; na linha 35, super.onStop(); na linha 36, Toast.makeText(this, "onStop", Toast.LENGTH_SHORT).show(); na linha 37, Log.d(TAG, "onStop chamado"); na linha 38, }. Na linha 40, override fun onRestart() {; na linha 41, super.onRestart(); na linha 42, Toast.makeText(this, "onRestart", Toast.LENGTH_SHORT).show(); na linha 43, Log.d(TAG, "onRestart chamado"); na linha 44, }. Na linha 46, override fun onDestroy() {; na linha 47, super.onDestroy(); na linha 48, Toast.makeText(this, "onDestroy", Toast.LENGTH_SHORT).show(); na linha 49, Log.d(TAG, "onCreate chamado"); na linha 50, }; e, por fim, na linha 51, }.

Cada método do ciclo de vida possui um momento específico para ser utilizado, portanto, compreender isso é essencial para o bom funcionamento do aplicativo. Por exemplo, é possível liberar memória em onPause ou onStop, recarregar dados em onStart e salvar informações importantes antes que a tela seja destruída em onDestroy. Esse domínio é fundamental para desenvolver aplicativos estáveis, responsivos e que ofereçam uma boa experiência ao usuário.

Agora, desafie seus colegas e/ou professores a implementar novas funcionalidades ou explorar diferentes maneiras de visualizar o que acontece em cada um dos estados do ciclo de vida da Activity.

REFERÊNCIAS

CONHEÇA o Android Studio. Developer Android, 11 out. 2025. Disponível em: https://developer.android.com/studio/intro?hl=pt-br. Acesso em: 13 out. 2025.

DESENVOLVER IU para Android. Developer Android, c2025. Disponível em: https://developer.android.com/develop/ui?hl=pt-br. Acesso em: 13 out. 2025.

FERRAMENTA de linha de comando Logcat. Developer Android, 27 jul. 2025. Disponível em: https://developer.android.com/tools/logcat?hl=pt-br. Acesso em: 13 out. 2025.

VISÃO geral do build do Gradle. Developer Android, 27 jul. 2025a. Disponível em: https://developer.android.com/build/gradle-build-overview?hl=pt_br. Acesso em: 13 out. 2025.

VISÃO geral do manifesto do app. Developer Android, 11 out. 2025b. Disponível em: https://developer.android.com/guide/topics/manifest/manifest-intro?hl=pt-br. Acesso em: 13 out. 2025.

Page updated

Google Sites

Report abuse