Verificação / Instalação do OpenJDK
Para verificar ou instalar o OpenJDK, acesse os links disponibilizados a seguir:
-
OPENJDK. How to download and install prebuilt OpenJDK packages. Disponível em: https://openjdk.java.net/install/. Acesso em: 08 de jul. 2025.
-
ORACLE. Como posso definir ou alterar a variável do sistema PATH? Disponível em: https://www.java.com/pt_BR/download/help/path.xml. Acesso em: 08 de jul. 2025.
Instalação da IDE
Antes de instalar a IDE, por favor, verifique se o OpenJDK foi devidamente instalado, pois o Android Studio necessita do JDK para funcionar. Para a instalação do Android Studio, acesse o seguinte link:
-
GOOGLE DEVELOPERS. Instalar o Android Studio. Disponível em: https://developer.android.com/studio/install?hl=pt-br. Acesso em: 08 de jul. 2025.
Para maiores informações sobre as novidades no Android Studio, acesse: o canal Android Developers. Disponível em: https://www.youtube.com/watch?v=bVt14IBv4NA&list=RDCMUCVHFbqXqoYvEWM1Ddxl0QDg&index=2. Acesso em: 08 de jul. 2025.
Arquitetura do Sistema Android
O Android é um sistema operacional criado em camadas bem definidas e com funcionalidades específicas. As camadas são denominadas em:
-
Kernel do linux: segurança, sólidez, ampla documentação. Os fabricantes dos aparelhos podem criar drives para um sistema amplamente conhecido. São aproveitados o gerenciamento de memória e processos do Linux;
-
Gerenciamento de hardware: drivers para CPU, memória, GPU, etc.
-
Gerenciamento de processos: escalonamento de processos e multithreading.
-
Gerenciamento de memória: alocação de memória física e virtual.
-
Sistema de arquivos.
-
Segurança: cada aplicativo roda com um UID único.
-
-
Camada de abstração de hardware: conjunto de bibliotecas que abstrai os detalhes específicos do hardware. Dessa forma, as capacidades do hardware podem ser acessadas pela API do Java. Quando um app precisa acessar uma câmera, o módulo específico da biblioteca para o hardware é carregado.
-
Android Runtime: máquina virtual executa o arquivo DEX (bytecodes);
-
Bibliotecas nativas: alguns componentes usam bibliotecas nativas, como a SQLite. Através do Android NDK, é possível desenvolver apps em C/C mais mais;
-
Framework Java API: fornecem os recursos que possibilitam a criação dos aplicativos. Activity, Service, Content Provider, Broadcast Receiver são exemplos desses recursos; Gerenciadores de Sistema:
-
Activity Manager: Controla o ciclo de vida das atividades.
-
Window Manager: Gerencia janelas e layouts de UI.
-
Package Manager: Instala e gerencia APKs.
-
Location Manager: Acesso a GPS e localização por rede.
-
Content Providers: Permitem o compartilhamento de dados entre aplicativos.
-
Notifications: Sistema de notificações para o usuário.
-
Telephony: Gerenciamento de chamadas e SMS.
-
Segurança: O framework impõe o modelo de sandbox, onde cada aplicativo roda em uma instância da VM separada com um UID único, limitando o acesso a recursos sem permissões explícitas.
-
-
Aplicativos do sistema: Gmail, contatos, navegadores e outros. É a parte acessível aos usuários finais. Os aplicativos podem ser desenvolvidos em Java, Kotlin e C/C mais mais.
-
Referência: GOOGLE DEVELOPERS. Arquitetura da Plataforma. Disponível em: https://developer.android.com/guide/platform?hl=pt-br. Acesso em: 08 de jul. 2025.
-
Uso do Emulador
Após desenvolver um aplicativo, você pode testá-lo em seu próprio celular, mas caso não tenha um celular com sistema Android, você pode usar um emulador. Para criar um emulador na IDE, acesse o link disponibilizado:
-
GOOGLE DEVELOPERS. Criar e gerenciar dispositivos virtuais. Disponível em: https://developer.android.com/studio/run/managing-avds?hl=pt-br. Acesso em: 08 de jul. 2025.
Estrutura do Projeto na IDE
Quando cria-se um novo projeto através da IDE, muitos arquivos e diretórios são criados. Existem arquivos como:
-
.java;
-
.xml;
-
de imagem;
-
diretório src;
-
diretório libs;
-
diretório gradle;
-
e outros.
É importante entender esses arquivos e diretórios criados. Por exemplo, o arquivo AndroidManifest.xml contém informações relevantes para o aplicativo, neste são definidos o nome totalmente qualificado do projeto, a definição da atividade principal e as secundárias, permissões que serão usadas, definição do tema e outras configurações. Já no arquivo build.gradle são definidos a versão do Android (mínima e a alvo), adição de outras bibliotecas providas de terceiros e outras configurações.
Do Desenvolvimento até a Execução
-
Desenvolvimento: O programador escreve o código-fonte em Java (ou Kotlin), criando a lógica do aplicativo.
-
Compilação: O código-fonte é compilado para o formato
.class
e, em seguida, convertido para o formato.dex
(Dalvik Executable), otimizado para dispositivos Android. -
Empacotamento: Para distribuir o aplicativo, é gerado um arquivo APK (Android Package), que reúne o arquivo
.dex
, layouts (XML), imagens, sons e metadados, como informações do aplicativo. -
Execução: Quando o usuário abre o app, o Android cria um processo dedicado para ele. Cada aplicativo roda em sua própria instância de máquina virtual, e o arquivo
.dex
é carregado na memória principal. O ART (Android Runtime) gerencia a memória e a execução do código. -
Ciclo de Vida e Gerenciamento: O Android controla o ciclo de vida dos componentes do app, como as Activities (telas do aplicativo). Ele também gerencia permissões e segurança, garantindo que cada app opere em um ambiente isolado (sandbox). Esse isolamento é implementado por:
-
Permissões: O app declara quais recursos (como hardware ou armazenamento) deseja acessar.
-
UID: Um ID único que define os privilégios de acesso ao sistema de arquivos e ao kernel.
-
SELinux: Políticas de segurança em nível de kernel para reforçar o isolamento.
-
-
Compartilhamento de Recursos: Todos os aplicativos Android compartilham o mesmo kernel Linux e bibliotecas do sistema, mas o isolamento ocorre no nível do processo, não da máquina virtual.
-
Chamadas ao Sistema: O app pode solicitar funções do sistema (via APIs do kernel) para interagir com recursos do dispositivo, como gravar arquivos ou acessar hardware.
Referência: GOOGLE DEVELOPERS. Fundamentos de aplicativos. Disponível em: https://developer.android.com/guide/components/fundamentals?hl=pt-br. Acesso em: 08 de jul. 2025.
Versões do Android
Atualmente o sistema Android encontra-se na versão 16. Para mais detalhes sobre a API e novidades, acessem os links: https://developer.android.com/about/versions/16?hl=pt-br.
Versões anteriores à versão 16:
-
Android 1.0: API Level 1
-
Android 1.1 (Petit Four): API Level 2
-
Android 1.5 (Cupcake): API Level 3
-
Android 1.6 (Donut): API Level 4
-
Android 2.0 (Eclair): API Level 5
-
Android 2.1 (Eclair): API Level 7
-
Android 2.2 (Froyo): API Level 8
-
Android 2.3 (Gingerbread): API Level 9
-
Android 2.3.3 (Gingerbread): API Level 10
-
Android 3.0 (Honeycomb): API Level 11
-
Android 3.1 (Honeycomb): API Level 12
-
Android 3.2 (Honeycomb): API Level 13
-
Android 4.0 (Ice Cream Sandwich): API Level 14
-
Android 4.0.3 (Ice Cream Sandwich): API Level 15
-
Android 4.1 (Jelly Bean): API Level 16
-
Android 4.2 (Jelly Bean): API Level 17
-
Android 4.3 (Jelly Bean): API Level 18
-
Android 4.4 (KitKat): API Level 19
-
Android 4.4W (KitKat Wear): API Level 20
-
Android 5.0 (Lollipop): API Level 21
-
Android 5.1 (Lollipop): API Level 22
-
Android 6.0 (Marshmallow): API Level 23
-
Android 7.0 (Nougat): API Level 24
-
Android 7.1 (Nougat): API Level 25
-
Android 8.0 (Oreo): API Level 26
-
Android 8.1 (Oreo): API Level 27
-
Android 9 (Pie): API Level 28
-
Android 10: API Level 29
-
Android 11: API Level 30
-
Android 12: API Level 31
-
Android 12L: API Level 32
-
Android 13: API Level 33
-
Android 14: API Level 34
-
Android 15: API Level 35
Referência: WIKIPEDIA, Android version history. Disponível em: https://en.wikipedia.org/wiki/Android_version_history. Acessado em 9 de jul. de 2025.
Componentes Relevantes Usados na Implementação de Aplicativos
Os componentes são os blocos de construção relevantes para o desenvolvimento de um app. Os componentes são pontos de entrada sendo acessados pelos usuários, por outros apps e pelo próprio sistema. Cada componente tem um ciclo de vida e função definida. No Android tem-se 4 componentes:
-
Activity: ponto de entrada que permite a interação do usuário com o app. (Interface independente).
-
Service: componente cujo objetivo é manter aexecução em segundo plano (Sem interface).
-
Broadcast Receiver: componente que possibilita o sistema enviar eventos fora do fluxo normal de um app sendo manuseado por um usuário.
-
Content Provoder: componente que permite o compartilhamento de dados privados de um app com outros apps.
Referência: GOOGLE DEVELOPERS. Fundamentos de aplicativos. Disponível em: https://developer.android.com/guide/components/fundamentals?hl=pt-br. Acesso em: 08 de jul. 2025.
Activity
A activity é um componente disponível no SDK do Android responsável em apresentar a parte visual (interface gráfica) do aplicativo. A activity possui métodos que são invocados automaticamente pelo sistema. O entendimento desses métodos é fundamental para o funcionamento adequado do aplicativo. A figura 2 mostra os métodos envolvidos no ciclo de vida.
Figura 2

-
Referência da figura 2: GOOGLE DEVELOPERS. Entenda o ciclo de vida da atividade. Disponível em: https://developer.android.com/guide/components/activities/activity-lifecycle?hl=pt-br. Acesso em: 26 de jul. 2024.
Métodos dos ciclos de vida:
-
onCreate
@Override protected void onCreate(Bundle savedInstanceState) { //único método cuja a implementação é obrigatória; //executado apenas uma única vez durante todo o ciclo da atividade; //usado para configurações iniciais da atividade como os componentes visuais e também para restaurar dados salvos (use o Bundle). super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Toast.makeText(getApplicationContext(), "OnCreate", Toast.LENGTH_SHORT).show(); }
-
onStart
@Override protected void onStart() { //a atividade está visível, porém não esta apta para atender as solicitações do usuário. //estado de preparação da Activity super.onStart(); Toast.makeText(getApplicationContext(), "OnStart", Toast.LENGTH_SHORT).show(); }
-
onResume
@Override protected void onResume() { //a atividade está apta para atender as solicitações do usuário. //coloque aqui recursos que consomem processamento. super.onResume(); Toast.makeText(getApplicationContext(), "OnResume", Toast.LENGTH_SHORT).show(); }
-
onPause
@Override protected void onPause() { //método chamado quando activity não tem mais foco, mas ainda é visível. //a atividade não está mais em primeiro plano, mas ainda existe uma referência dela. super.onPause(); Toast.makeText(getApplicationContext(), "OnPause", Toast.LENGTH_SHORT).show(); }
-
onStop
@Override protected void onStop() { //a atividade não é mais visível ao usuário; //nesta fase, na falta de recursos o sistema pode destruir a atividade. Portanto, é um bom lugar para realizar a persistência de dados. super.onStop(); Toast.makeText(getApplicationContext(), "OnStop", Toast.LENGTH_SHORT).show(); }
-
onDestroy
@Override //depois da execução deste método, a atividade é destruída. //libere todos os recursos usados!! protected void onDestroy() { super.onDestroy(); Toast.makeText(getApplicationContext(), "OnDestroy", Toast.LENGTH_SHORT).show(); }
Exemplo prático:
-
MainActivity.java
import android.content.Intent; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.TextView; import androidx.activity.EdgeToEdge; import androidx.appcompat.app.AppCompatActivity; import androidx.core.graphics.Insets; import androidx.core.view.ViewCompat; import androidx.core.view.WindowInsetsCompat; public class MainActivity extends AppCompatActivity { private TextView textView1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); Log.i("onCreate","atividade criada"); textView1 = findViewById(R.id.textView1); textView1.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Intent i = new Intent(MainActivity.this, Activity2.class); startActivity(i); } }); }// @Override protected void onStart() { super.onStart(); Log.i("onStart","atividade iniciada "); } @Override protected void onResume() { super.onResume(); Log.i("onResume","atividade pronta "); } @Override protected void onPause() { super.onPause(); Log.i("onPause","atividade pausada "); } @Override protected void onStop() { super.onStop(); Log.i("onStop","atividade paralizada "); } @Override protected void onDestroy() { super.onDestroy(); Log.i("onDestroy","atividade destruída "); } }//class
-
activity_main.xml
<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" 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="Primeira tela" android:id="@+id/textView1" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" /> </androidx.constraintlayout.widget.ConstraintLayout>
-
Activity2.java
import android.os.Bundle; import androidx.activity.EdgeToEdge; import androidx.appcompat.app.AppCompatActivity; import androidx.core.graphics.Insets; import androidx.core.view.ViewCompat; import androidx.core.view.WindowInsetsCompat; public class Activity2 extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_2); } }
-
activity_2.xml
<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/tela2" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".Activity2"> <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Segunda tela" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" /> </androidx.constraintlayout.widget.ConstraintLayout>
Bundle
Bundle funciona como um Map no Java. Trata-se de uma estrutura de dados usada para passar informações entre componentes, como Activities, Fragments e Services. Serve também para armazenar o estado de uma Activity quando ocorre mudanças de configuração (por exemplo, rotação de tela). Quando ocorre a rotação de tela, a atividade é destruída e construída novamente. Dessa forma, o Bundle pode ser usado para salvar e recuperar alguma informação importante.
-
Salvar o estado da Atividade
protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putString("key_data", "value"); }
-
Recuperar o estado da Atividade
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); if (savedInstanceState != null) { String data = savedInstanceState.getString("key_data"); } }
-
Passar dados de uma atividade para outra
Intent intent = new Intent(this, SecondActivity.class); Bundle bundle = new Bundle(); bundle.putString("key", "value"); intent.putExtras(bundle); startActivity(intent);
Exemplo prático
-
activity_main.xml
<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/main" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity"> <EditText android:id="@+id/editTextWord" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginTop="60dp" android:ems="10" android:inputType="text" android:hint="Word" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintHorizontal_bias="0.497" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" /> <Button android:id="@+id/buttonClick" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_marginBottom="388dp" android:text="Click" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintHorizontal_bias="0.498" app:layout_constraintStart_toStartOf="parent" /> </androidx.constraintlayout.widget.ConstraintLayout>
-
MainActivity.java
import android.content.Intent; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.EditText; import androidx.activity.EdgeToEdge; import androidx.appcompat.app.AppCompatActivity; import androidx.core.graphics.Insets; import androidx.core.view.ViewCompat; import androidx.core.view.WindowInsetsCompat; public class MainActivity extends AppCompatActivity { private static final String TAG = "MainActivity"; private static final String KEY = "key_word"; private EditText editTextWord; private Button buttonClick; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); editTextWord = findViewById(R.id.editTextWord); buttonClick= findViewById(R.id.buttonClick); // Restaurar estado if (savedInstanceState != null) { String word = savedInstanceState.getString(KEY); editTextWord.setText(word); Log.d(TAG, editTextWord.toString()); } buttonClick.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { String word = editTextWord.getText().toString(); Intent intent = new Intent(MainActivity.this, SecondActivity.class); intent.putExtra("data", word); startActivity(intent); } }); } @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); // Salvar a palavra no Bundle outState.putString(KEY, editTextWord.getText().toString()); } }
-
activity_second.xml
<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:id="@+id/main" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".SecondActivity"> <TextView android:id="@+id/textViewWord" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="TextView" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" /> </androidx.constraintlayout.widget.ConstraintLayout>
-
SecondActivity.java
import android.os.Bundle; import android.widget.TextView; import androidx.appcompat.app.AppCompatActivity; public class SecondActivity extends AppCompatActivity { private TextView textViewPalavra; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); textViewPalavra = findViewById(R.id.textViewWord); // Recuperar a palavra enviada pela MainActivity String word = getIntent().getStringExtra("data"); if (word != null) { textViewPalavra.setText("word: " + word); } else { textViewPalavra.setText("nothing"); } } }