Android 3 em 1: Java, Kotlin e Jetpack Compose na Palma da Mão

Olá! Que bom ter você aqui.

📘 Introdução (versão reescrita)

Olá! Que bom ter você aqui.

Seja muito bem-vindo(a) ao Android 3 em 1: Java, Kotlin e Jetpack Compose na Palma
da Mão.

Este material foi pensado especialmente para quem quer entrar no mundo do
desenvolvimento Android de forma leve, prática e sem complicação — mesmo que você
nunca tenha programado antes.

Ao longo das páginas, você vai:

• Conhecer a história e a evolução da plataforma Android;

• Aprender a configurar o ambiente de desenvolvimento com o Android Studio;
• Descobrir como usar as duas principais linguagens da plataforma: Java, a base
tradicional, e Kotlin, a linguagem moderna recomendada oficialmente pelo Google;
• E, claro, colocar a mão na massa para criar seus próprios aplicativos!

Aqui, você não vai apenas copiar códigos. A ideia é entender o que está por trás de cada
etapa, desde a criação de um projeto até o funcionamento das ferramentas, tudo com
explicações claras, exemplos reais e um passo a passo bem guiado.

Nota importante:
As informações históricas contidas neste material são de domínio público e organizadas com
base em fontes confiáveis. Nosso objetivo é facilitar seu aprendizado com responsabilidade,
clareza e foco na originalidade.

Essa introdução prepara o leitor com um tom leve, motivador e direto, e já planta a ideia de
que o livro vai evoluir tecnicamente depois. Quer que eu continue com a adaptação das
próximas seções nesse mesmo estilo?

Como este curso está estruturado

Bem-vindo ao livro Android 3 em 1: Java, Kotlin e Jetpack Compose na Palma da Mão!

Este material foi criado para acompanhar você em uma jornada completa pelo
desenvolvimento Android, indo do zero ao avançado, com foco prático e linguagem
acessível — ideal para quem está começando, pensando em transição de carreira, ou quer
aprender com clareza e estrutura.

🧩 Metodologia: do básico ao profissional, com linguagem humana

Começamos com Java, uma linguagem robusta e tradicional no mundo Android. Ela será sua
porta de entrada para entender a estrutura dos apps, os elementos visuais em XML, os
eventos e a lógica de funcionamento.

Tudo será explicado de forma gradual, passo a passo, com exemplos práticos, códigos
comentados e imagens que mostram como o app deve se comportar na tela.

À medida que você avança, o conteúdo vai:

Apresentar conceitos técnicos na dose certa;

Mostrar boas práticas de desenvolvimento;
Ensinar como pensar como um desenvolvedor Android.

🔁 Transição natural para Kotlin

Depois de dominar os fundamentos com Java, você vai ser introduzido(a) ao Kotlin, a
linguagem moderna e oficial do Android. Mas calma — isso será feito com comparações
diretas com Java, para facilitar o entendimento.

Você vai perceber que o Kotlin torna o código mais limpo e direto, sem perder clareza.

💡 E depois: Jetpack Compose

Com a base sólida em Java e Kotlin, entramos em Jetpack Compose, a nova abordagem de
construção de telas no Android.

Você vai aprender a criar interfaces modernas com menos código e maior controle sobre o
comportamento da sua aplicação — tudo isso com exemplos práticos, códigos explicados e
exercícios guiados.
🎓 Resultado esperado
Ao final do livro, você terá construído um aplicativo completo com:

• Interface gráfica funcional (com XML e depois Compose)

• Navegação entre telas
• Armazenamento local de dados
• Consumo de APIs externas
• Estrutura organizada e modular
• Fundamentos sólidos em Java e Kotlin

? Android Studio

O Android Studio é o ambiente oficial de desenvolvimento Android, disponibilizado pelo

Google. Ele é baseado no IntelliJ IDEA, uma poderosa IDE da JetBrains, e oferece suporte
total às linguagens Kotlin e Java.

Apresentado ao público em maio de 2013, o Android Studio teve sua primeira versão
estável lançada em dezembro de 2014. Desde então, substituiu o antigo ambiente baseado
no Eclipse com o plugin ADT (Android Developer Tools), trazendo mais recursos, integração
e produtividade ao desenvolvimento Android.

? Sistema Operacional Android

O Android foi criado com a proposta de ser um sistema operacional aberto, flexível e
acessível a diversos tipos de dispositivos. Seu desenvolvimento começou com a empresa
Android Inc., até ser adquirida pelo Google em 2005.

O primeiro aparelho com Android chegou ao mercado em 2008, marcando o início de uma
nova fase na tecnologia móvel. Com o passar dos anos, o Android evoluiu e se tornou o
sistema operacional mais usado no mundo, presente em celulares, tablets, TVs, relógios,
carros e muito mais.

Esse crescimento foi impulsionado pelo modelo de código aberto e pelo envolvimento ativo
da comunidade de desenvolvedores e fabricantes.

Instalando o Android Studio – Passo a Passo

Antes de baixar, verifique se seu computador atende aos requisitos:
Windows:

• Sistema: Windows 10 ou superior (64 bits)

• Memória: 8 GB (recomendado)
• Espaço em disco: 8 GB livres
• Processador: Intel ou AMD com suporte a virtualização

macOS:

• macOS 10.14 (Mojave) ou superior

• Mesmas recomendações de memória e espaço

Para Linux:

• Versão 64 bits com ambiente gráfico

• Ferramentas como glibc, kvm e unzip instaladas

2. Baixando o Android Studio

1. Acesse o site oficial:

? [Link]
2. Clique em "Download Android Studio" e aceite os termos.
3. Escolha o instalador compatível com seu sistema (Windows, macOS ou Linux).
4. 3. Instalando o Android Studio

Windows:

1. Execute o arquivo .exe baixado.

2. Clique em Next nas etapas do
3. Mantenha as opções padrão (Android Studio + SDK + Emulador).
4. Clique em Install e aguarde.
5. Ao fim, clique em Finish.

macOS:
1. Abra o .dmg e arraste o Android Studio para a pasta Aplicativos.
2. Execute o programa normalmente.
Linux:

1. Extraia o .zip baixado.

2. Navegue até a pasta bin e execute [Link].
Lembrando que a instalação que fizemos acima e Windows 11
4. Primeira Execução

1. Ao abrir o Android Studio pela primeira vez, selecione "Standard" para uma
instalação recomendada.
2. O programa vai baixar o SDK, o AVD (emulador de dispositivo) e outras
ferramentas.
3. Aguarde o processo e clique em Finish quando tudo estiver pronto.

Chegou a hora de instalar o Android Studio no Windows, que é o sistema mais comum no
Brasil. Vamos juntos, passo a passo, deixar tudo pronto para criar seu primeiro app!

[Link]

Provavelmente, por padrão, o arquivo será salvo na pasta "Downloads".

Agora, localize e execute o arquivo do Android Studio com um clique duplo.
Assim que continuar, a seguinte imagem será exibida:
"Neste momento, aparecerá a seguinte tela:"

Na sequencia automaticamente aparecera esta imagem clique (Next)

Clique novamente em (Next)

Assim que continuar, será mostrada a seguinte imagem:"

Clique em (Next)

Assim que continuar, será mostrada a seguinte imagem:

Se desejar criar um atalho, clique em "Install". Caso contrário, marque a opção e clique em
"Install", conforme mostrado na imagem abaixo.
Clique em Next para iniciar a instalação. Ao final, será criado um atalho na área de
trabalho automaticamente.

Durante a instalação, será exibida uma barra de progresso (progress bar, em inglês).

Quando a instalação for concluída, o botão Next será liberado para continuar.

Por fim, clique em Finish para concluir o processo.

Agora, o Android Studio será iniciado automaticamente. Caso isso não aconteça, você
pode abri-lo manualmente clicando no ícone do Android Studio na área de trabalho ou na
lista de programas do Windows.

Antes de começar a criar seus apps, é importante configurar o ambiente no Android Studio.
Um dos primeiros passos é entender e instalar o SDK (Software Development Kit), que é um
conjunto de ferramentas fundamentais para o desenvolvimento Android. Ele inclui APIs,
emuladores e recursos de depuração que ajudam a criar, testar e corrigir seus aplicativos.
Ao abrir o Android Studio pela primeira vez, o próprio programa normalmente orienta você na
instalação do SDK. Nessa etapa, é possível escolher a versão do Android desejada e instalar
outros componentes úteis, como plataformas específicas, ferramentas de compilação e
emuladores para simular diferentes dispositivos.
Abra o Android Studio e, com um projeto aberto, localize o ícone de engrenagem na barra
de ferramentas superior direita. Esse ícone é parte das configurações do IDE.

Clique na engrenagem para abrir o menu de configurações.

Selecione "SDK Manager" no menu suspenso. Isso abrirá a janela do SDK Manager, onde
você pode gerenciar as plataformas e ferramentas necessárias para o desenvolvimento.
Entendendo a aba SDK Platforms no Android Studio

Ao abrir o Android Studio e iniciar a configuração do ambiente, uma das etapas mais
importantes é escolher as versões do Android com as quais você irá trabalhar.

Isso é feito na aba "SDK Platforms", dentro do SDK Manager, como mostrado na imagem
acima com o título Android SDK.

Nessa seção, você pode selecionar as versões do Android que deseja instalar — por exemplo:
Android 11 (R), Android 13, 14, 15 ou até mesmo o Android 16, que está em fase de
testes.

Cada uma dessas versões representa uma plataforma que pode ser usada para desenvolver,
compilar e testar seus aplicativos Android.

Por que instalar várias versões?

Imagine que seu aplicativo vai ser usado por pessoas com celulares mais antigos e também
por quem acabou de comprar um aparelho novinho. Para garantir que ele funcione bem para
todos, é importante testá-lo em várias versões do Android.
Dica de amigo
Sempre tenha instalada a versão mais atual que você pretende usar no seu projeto.
Se o seu app vai funcionar em celulares mais antigos, vale a pena manter uma ou duas
versões mais antigas também.
E não se preocupe em marcar tudo — vá instalando aos poucos, conforme a necessidade
do seu projeto.

Agora o SDK Tools

Explorando a aba SDK Tools no Android Studio
Depois de escolher as versões do Android na aba SDK Platforms, é hora de conhecer outra
parte importante da configuração: a aba SDK Tools.
Essa seção reúne um conjunto de ferramentas essenciais que tornam possível criar, testar e
executar seus aplicativos Android. Pense nela como uma caixa de ferramentas onde você
encontra tudo o que precisa para fazer seu projeto funcionar da melhor forma possível.
Na aba SDK Tools, você vai ver uma lista de componentes que podem ser ativados de
acordo com as necessidades do seu projeto. Aqui estão os principais:

Ferramenta Oque Faz!

Android SDK Build-Tools Conjunto de ferramenta necessária para copilar o App,
sem ele não vai rodar o aApp
Android Plataform Tools Inclui ferramentas como o ADB (Android Debug
Bridge), que permite conectar e testar seu aplicativo em
dispositivos reais ou emuladores.
Android Emulator
Permite rodar um dispositivo Android virtual no seu
computador para testar seus apps.
Intel X86 Emulator Melhora o desempenho dos emuladores. Deixando tudo
mais rápido (usado em processadores Intel)
Google Play services Necessário para Apps que usem funções do google, com
mapas, login com conta Google, notificaões etc.
NDK(Native DevelopmentKit) Para quem precisa usar código em C ou C++ no
App(mais comum em jogod ou Apps de alto
desempenho)
CMaKe Funciona com o NDK para configurar e copilar o código
nativo do projeto

Como instalar ou configurar essas ferramentas

É tudo bem simples e o próprio Android Studio ajuda bastante:
No Android Studio, clique no ícone de engrenagem e vá em SDK Manager.

Acesse a aba "SDK Tools".

Marque as ferramentas que deseja instalar ou atualizar.
Clique em Apply e depois em
OK. O Android Studio fará o restante por você.

Dica: Se quiser visualizar as versões disponíveis de cada ferramenta, marque a opção "Show
Package Details" no canto inferior direito da janela.

Na imagem acima, todos os itens estão marcados, mas não é necessário selecionar tudo.
Marque apenas o que for realmente necessário.
Se você está começando agora, as opções a seguir são mais do que suficientes. Veja abaixo a
relação recomendada para iniciantes:

Android SDK Build-Tools

Android SDK Platform-Tools
Android Emulator
HAXM (caso seu processador seja compatível) nem sempre é requisitado
durante a instalação, mas pode ser necessário para melhorar o desempenho
dos emuladores.
Google Play services (se seu app usar serviços do Google)

Se futuramente você for desenvolver com código nativo (C/C++), pode ativar também:

NDK
CMake

Uma dica de quem já passou por aí

Não se preocupe em instalar tudo de uma vez. À medida que o projeto for crescendo, você
pode voltar nessa aba e adicionar o que precisar. O Android Studio geralmente avisa se
estiver faltando alguma ferramenta — então você não precisa decorar tudo agora.
Interface do Android
O primeiro módulo, podemos dar início ao primeiro aplicativo primeiro aplicativo. É
importante conhecer as janelas principais. Observe a imagem abaixo.
1- Barra de Ferramentas do Android Studio — Explicação para fins educacionais
A barra de ferramentas do Android Studio oferece acesso rápido a comandos
essenciais usados no desenvolvimento de aplicativos. Nela, é possível executar
e depurar projetos, iniciar emuladores, gerenciar dispositivos conectados e
acessar outras ferramentas importantes do Android SDK.
 Seu objetivo é facilitar o fluxo de trabalho do desenvolvedor, reunindo em um só
lugar as funções mais utilizadas durante o desenvolvimento.

2 - Barra de Navegação
A barra de navegação do Android Studio desempenha um papel fundamental na
organização e no acesso aos arquivos do projeto. Essa funcionalidade permite ao
usuário navegar entre os diretórios e localizar rapidamente arquivos para edição. Além
disso, proporciona uma visualização compacta da estrutura do projeto, funcionando
como um complemento à janela principal de gerenciamento de arquivos, o que
contribui para uma experiência de desenvolvimento mais eficiente e organizada.

3-Janela do Editor
A janela do editor é o ambiente central de desenvolvimento no Android Studio,
destinado à criação e modificação de código, conforme o tipo de arquivo selecionado.
Dependendo do conteúdo, o editor adapta sua interface para melhor atender às
necessidades do desenvolvedor. Por exemplo, ao abrir um arquivo de layout, o
ambiente exibe o editor visual específico para layouts, permitindo a edição tanto em
modo gráfico quanto em modo de código.

4 – Barra da Janela de Ferramentas

A barra da janela de ferramentas é um elemento externo à área principal do ambiente de
desenvolvimento integrado (IDE). Sua função primordial consiste em oferecer opções para
expandir, recolher ou ocultar as janelas correspondentes às diversas ferramentas disponíveis
no Android Studio. Dessa forma, essa barra facilita a organização do espaço de trabalho,
possibilitando que o desenvolvedor ajuste a interface conforme suas necessidades e otimize
seu fluxo de trabalho.

5- Janela de Ferramenta no Android Studio

As janelas de ferramenta no Android Studio possibilitam o acesso a tarefas específicas, como
pesquisa, controle de versões e gerenciamento de projetos. Essas janelas podem ser
facilmente recolhidas ou expandidas, oferecendo maior flexibilidade para a organização do
ambiente de desenvolvimento.

6- Barra de Status do Android Studio

A barra de status do Android Studio exibe informações sobre o estado atual do projeto e do
ambiente de desenvolvimento integrado (IDE), incluindo avisos, mensagens e notificações
relevantes para o desenvolvedor. Essa funcionalidade permite o acompanhamento contínuo
do progresso e eventuais problemas durante o desenvolvimento.

Agora vamos cria nosso primeiro projeto.

Passo 1:
Clique em New para abrir uma nova aba e, em seguida, selecione New Project.
CiquComforme a imagem a baixo clique em NEW ->

Após isso, aparecerá a seguinte tela com várias opções de templates para o seu projeto. Você
deverá escolher o template que melhor se adapta ao tipo de aplicativo que deseja criar. Por
exemplo, para um projeto básico, selecione Empty Activity. Depois, clique em Next para
continuar.
Na tela seguinte (como mostrado na imagem), você precisará preencher algumas
informações importantes:

• Name (Nome):
Digite o nome do seu aplicativo. No exemplo, foi usado MeuPrimeiroAPP. Esse
será o nome do projeto dentro do Android Studio e poderá aparecer como nome
do app no dispositivo.
• Package name (Nome do pacote):
Esse é o identificador único do seu app. Você pode manter o padrão sugerido
pelo Android Studio ([Link]) ou personalizar com o
nome da sua empresa ou provedor (exemplo: [Link]).
• Save location (Local de salvamento):
Indica onde o projeto será salvo em seu computador. Por padrão, o Android
Studio sugere uma pasta apropriada. Você pode manter como está, a menos
que queira mudar.
• Language (Linguagem):
Escolha entre Java e Kotlin. Neste exemplo, selecionamos Java, mas o Android
Studio recomenda Kotlin, pois é a linguagem oficial e mais moderna para
desenvolvimento Android.
• Minimum SDK (SDK Mínimo):
Define a versão mínima do Android em que seu aplicativo poderá ser instalado.
 Aqui, selecionamos API 24 (Nougat, Android 7.0), o que garante
compatibilidade com cerca de 98,6% dos dispositivos Android (como indicado
na mensagem abaixo da opção).
• Build configuration language (Linguagem de configuração do build):
Essa opção define o formato usado para os arquivos de configuração do
Gradle. Recomendamos manter a opção padrão: Kotlin DSL ([Link]),
pois é a mais atual e recomendada pelo Android Studio.

Clique em (FINISH )
Após o Android Studio ter criado o projeto ou o dispositivo virtual (Device), será
necessário testá-lo. Provavelmente, a versão do Android Studio que foi instalada já criou
um emulador automaticamente. Para testá-lo, basta clicar no botão "Run" (ícone de
play) na barra superior do Android Studio e selecionar o emulador disponível.

Botão "Run" (ícone de play) no Android Studio?

O botão Run é usado para compilar e executar seu aplicativo no emulador ou em um

dispositivo físico conectado.
Localização:
• Fica na barra superior do Android Studio.
• O ícone é um triângulo verde, semelhante ao botão "play" de um reprodutor de
mídia.
Visual:
• ![ ] ← É esse símbolo (um triângulo apontando para a direita).
• Normalmente está ao lado de outros botões como Debug (um inseto) e Build
(martelo).
Como usar:
1. Certifique-se de que seu projeto está aberto e compilado corretamente.
2. Clique no ícone Run ( ).
3. O Android Studio abrirá uma janela perguntando onde executar o app.
4. Selecione o emulador já criado (ou conecte um celular via USB).
5. Clique em OK, e o app será executado no dispositivo escolhido.

Então vamos seguir em frente! Agora que seu emulador está rodando e o "Hello World!"
apareceu direitinho, você já tem a base funcionando. A partir daqui, podemos começar
a deixar o app com a sua cara.
Próximos passos que você pode explorar:

1. Editar o texto "Hello World!"

Você pode mudar esse texto para algo mais personalizado.
Vá até o arquivo:
app > res > layout > activity_main.xml

Dentro desse arquivo, você verá algo como:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!" />

Troque "Hello World!" por qualquer mensagem que quiser, como:

android:text="Meu primeiro app Android!"

Durante o desenvolvimento de aplicativos Android, é comum definir textos diretamente

no layout XML, como no exemplo abaixo:
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Meu primeiro aplicativo!" />
Porém, essa prática não é recomendada. Segundo as diretrizes do Android, é melhor
definir esses textos em um arquivo de recursos para facilitar a manutenção, a
localização (tradução) e a organização do código.
✅ Solução recomendada: uso do arquivo [Link]
O Android Studio armazena strings reutilizáveis no arquivo [Link], localizado em:
app > src > main > res > values > [Link]

Passo a passo para aplicar boas práticas

🔹 Passo 1: Abrir o arquivo [Link]

1. No Android Studio, abra seu projeto.

2. Navegue até:
1. app > src > main > res > values > [Link]
Clique duas vezes para abrir o arquivo.

🔹 Passo 2: Adicionar a string personalizada

No arquivo [Link], adicione a seguinte linha dentro da tag <resources>:
<string name="meu_primeiro_app">Meu primeiro aplicativo!</string>

O arquivo ficará assim:

<resources>
<string name="app_name">MeuApp</string>
<string name="meu_primeiro_app">Meu primeiro aplicativo!</string>
</resources>

🔹 Passo 3: Referenciar a string no layout

Agora, vá até seu arquivo de layout XML (por exemplo: activity_main.xml) e substitua
o texto literal pela referência à string de recurso:

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/meu_primeiro_app" />

🎓 Conclusão
Ao seguir esse procedimento, você:
 • Mantém o código mais limpo e organizado;
• Facilita a tradução do aplicativo para vários idiomas;
• Segue as boas práticas recomendadas pelo Android SDK;
• Evita advertências ou sugestões do Android Studio (como o sublinhado amarelo).

2. Mudar a cor de fundo da tela

Isso já deixa seu app com um visual mais seu!
Vá até o arquivo:
app > res > values > themes > [Link]
E edite as cores principais do tema, como o colorPrimary ou colorBackground.

3. Adicionar um botão (Button)

Coloque um botão e crie uma interação simples!
Dentro do activity_main.xml, adicione:
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Clique aqui" />
🧠 Dica:
Se quiser ver as mudanças ao vivo, sempre clique no ícone "Run" ( ) novamente para
atualizar o app no emulador.

Agora obseve o codigo completo dendro do :

1- [Link]
<resources>
<string name="app_name">MeuPrimeiroAPP</string>
<string name="meu_nome">Carlos Antonio Professor!</string>
<string name="idade">Tenho 25 anos</string>
</resources>

O codigo dentro activity_main.xlm

<?xml version="1.0" encoding="utf-8"?>
<[Link]
xmlns:android="[Link]
xmlns:app="[Link]
xmlns:tools="[Link]
android:id="@+id/main"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
 <TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Meu primeiro aplicativo!"
app:layout_constraintBottom_toBottomOf"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />

<TextView
android:id="@+id/text_view_nome"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/meu_nome"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent" />

<!-- Segundo TextView abaixo do primeiro -->

<TextView
android:id="@+id/text_view_idade"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/idade"
app:layout_constraintTop_toBottomOf="@id/text_view_nome"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent" />
</[Link]>

Veja a saída:
Próximo exemplo acrescentamos:
01-Digite o Estado
02-Digite a cidade
03-Digite a escola
<?xml version="1.0" encoding="utf-8"?>
<[Link]
xmlns:android="[Link]
xmlns:app="[Link]
xmlns:tools="[Link]
android:id="@+id/main"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:id="@+id/text_view_nome"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
 android:text="@string/meu_nome"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent" />

<!-- Idade -->

<TextView
android:id="@+id/text_view_idade"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/idade"
app:layout_constraintTop_toBottomOf="@id/text_view_nome"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="8dp" />

<!-- Título do app -->

<TextView
android:id="@+id/text_title"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Meu primeiro aplicativo!"
andr
oid:textSize="18sp"
android:textStyle="bold"
app:layout_constraintTop_toBottomOf="@id/text_view_idade"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="24dp" />

<!-- EditText - Estado -->

<EditText
android:id="@+id/edit_estado"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="Digite o estado"
app:layout_constraintTop_toBottomOf="@id/text_title"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="24dp" />

<!-- EditText - Cidade -->

 <EditText
android:id="@+id/edit_cidade"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="Digite a cidade"
app:layout_constraintTop_toBottomOf="@id/edit_estado"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="12dp" />

<!-- EditText - Escola -->

<EditText
android:id="@+id/edit_escola"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="Digite o nome da escola"
app:layout_constraintTop_toBottomOf="@id/edit_cidade"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="12dp" />

<!-- Botão Enviar -->

<Button
android:id="@+id/btn_enviar"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:text="Enviar"
app:layout_constraintTop_toBottomOf="@id/edit_escola"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="24dp"
android:layout_marginBottom="32dp" />

</[Link]>
Saida:
Explicação do Código XML (Campo por Campo)

Este layout XML do Android define três campos de entrada de texto (EditText) e um
botão (Button), organizados verticalmente usando ConstraintLayout.
🔹 1. EditText – Estado
android:id="@+id/edit_estado"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="Digite o estado"
app:layout_constraintTop_toTopOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="32dp" />

Propriedade Significado
android:id="@+id/edit_estado ID usado para acessar 0 campo no
código
layoult_width="0dp" Largura será expandida entre as
constraints
layout_height="wrap_content" Altura ajustada ao conteudo
hint="digite o estado" Dica que aparece quando o campo
está vazio
contraintTop_toTopOf="parent" Colocando no topo do layout

layout_marginTop="32dp" Espaço superior para afastar a

borda superior

🔹 2. EditText – Cidade

<EditText
android:id="@+id/edit_cidade"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="Digite a cidade"
app:layout_constraintTop_toBottomOf="@id/edit_estado"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="12dp" />

Propriesdades Significado
constraintTop_toBottomOf="@id/ed Posicionamento logo abaixo do
it_estado" campo de estado
hint="Digite a cidade" Dica exibida para usuário
layout_marginTop="12dp" Espaço vertical entre o campo de
estado e o de cidade
🔹 3. EditText – Escola

<EditText
android:id="@+id/edit_escola"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="Digite o nome da escola"
app:layout_constraintTop_toBottomOf="@id/edit_cidade"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="12dp" />

Detalhes:

Propriedade Significado

constrainTop_toBottomOf="id/edit_cidade" Posicionado abaixo do campode

cidade
hint="Digite o nome da escola" Dica exibida ao usuário

🔹 4. Button – Enviar
android:id="@+id/btn_enviar"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:text="Enviar"
app:layout_constraintTop_toBottomOf="@id/edit_escola"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintEnd_toEndOf="parent"
android:layout_marginTop="24dp"
android:layout_marginBottom="32dp" />

Detalhes:

Propriedade

text="Eviar" Texto exibido no botão

constraintTop_toBottomOf="@id/edit_ Posicionamento do campo da escola
escola"
layout_marginTop="24dp" Espaço entre o campo e o botão
layout_marginBoottom=32dp" Espaço abaixo do botão
Visual Simplificado do Layout

+--------------------------------------------------+
| |
| [Digite o estado__________________________] | <- edit_estado
| |
| [Digite a cidade__________________________] | <- edit_cidade
| |
| [Digite o nome da escola__________________] | <- edit_escola
| |
| [ Enviar ] | <- btn_enviar
| |
+--------------------------------------------------+

Conclusão

• Este layout é simples e funcional.

• Os elementos são centralizados horizontalmente.
• A posição vertical é gerenciada com ConstraintLayout, que garante uma
hierarquia bem definida entre os elementos.