Verificação / Instalação do OpenJDK

Para verificar ou instalar o OpenJDK, acesse os links disponibilizados a seguir:

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:

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:

  1. 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.

  2. 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.

  3. Android Runtime: máquina virtual executa o arquivo DEX (bytecodes);

  4. Bibliotecas nativas: alguns componentes usam bibliotecas nativas, como a SQLite. Através do Android NDK, é possível desenvolver apps em C/C mais mais;

  5. 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.

  6. 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.

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:

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

  1. Desenvolvimento: O programador escreve o código-fonte em Java (ou Kotlin), criando a lógica do aplicativo.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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

ciclo vida

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");
            }
        }
    }