Como funciona um aplicativo Android por dentro?

O que acontece quando você abre um aplicativo Android?

Quando você toca no ícone de um aplicativo Android, uma série de processos acontece em poucos instantes. O sistema operacional precisa localizar o aplicativo, preparar um processo para sua execução, carregar os componentes necessários e então iniciar a tela que será apresentada ao usuário.

Para quem está começando no desenvolvimento mobile, entender esse processo ajuda a compreender conceitos como Activities, ciclo de vida, processos, recursos, AndroidManifest.xml e Jetpack Compose.

Neste artigo, vamos entender de forma simples como funciona um aplicativo Android por dentro e quais são as principais partes envolvidas.

O aplicativo Android começa com código

Um aplicativo Android é formado por código, recursos e configurações. Atualmente, Kotlin é uma das principais linguagens utilizadas no desenvolvimento Android, embora Java também seja suportado.

O código define o comportamento do aplicativo. É nele que o desenvolvedor determina o que acontece quando o usuário toca em um botão, abre uma tela, envia um formulário ou realiza qualquer outra ação.

Além do código, o projeto pode conter imagens, textos, ícones, layouts, arquivos de configuração e outros recursos utilizados pela aplicação.

O AndroidManifest.xml

Um dos arquivos fundamentais de um aplicativo Android é o AndroidManifest.xml. Ele funciona como uma declaração do aplicativo para o sistema operacional.

Nele podem ser declarados componentes da aplicação, permissões necessárias e outras informações importantes para que o Android saiba como lidar com o aplicativo.

Por exemplo, uma Activity precisa ser declarada para que o sistema possa reconhecê-la como parte da aplicação.

Exemplo de AndroidManifest.xml

Uma declaração básica de Activity pode ser encontrada no manifesto do aplicativo:

<manifest ...>

    <application
        android:theme="@style/Theme.App">

        <activity
            android:name=".MainActivity"
            android:exported="true">

            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

        </activity>

    </application>

</manifest>

Nesse exemplo, MainActivity é declarada como um componente do aplicativo. O intent-filter indica que ela pode ser utilizada como ponto de entrada principal quando o usuário abre o aplicativo.

O que é uma Activity no Android?

Uma Activity é um dos componentes responsáveis por fornecer uma entrada para a interação do usuário com o aplicativo. Em projetos Android tradicionais, cada tela podia ser representada por uma Activity diferente.

Porém, no desenvolvimento Android moderno, é muito comum utilizar a abordagem Single-Activity. Nesse modelo, o aplicativo possui uma Activity principal e várias telas são construídas dentro dela, utilizando tecnologias como o Jetpack Compose e componentes de navegação.

Isso significa que conceitos antigos como "uma Activity para cada tela" ainda podem ser encontrados em projetos Android, mas não representam necessariamente a arquitetura utilizada em aplicações modernas.

Independentemente da arquitetura utilizada, uma Activity possui um ciclo de vida. O Android controla esses estados conforme o usuário abre, abandona ou retorna ao aplicativo.

Entre os métodos mais conhecidos estão onCreate(), onStart(), onResume(), onPause(), onStop() e onDestroy().

Exemplo de onCreate() em Kotlin

O método onCreate() é executado durante a criação de uma Activity. Ele costuma ser utilizado para realizar configurações iniciais e preparar os componentes necessários para o funcionamento da tela.

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        setContent {
            Text("Olá, Android!")
        }
    }
}

Nesse exemplo, a Activity utiliza o Jetpack Compose para construir sua interface. O método setContent() define o conteúdo visual que será apresentado ao usuário.

O ciclo de vida de uma Activity

Uma das características importantes do Android é que o sistema operacional controla o ciclo de vida dos componentes do aplicativo. A Activity pode passar por diferentes estados conforme o usuário interage com ela.

Imagine que você abriu um aplicativo e depois recebeu uma ligação. O aplicativo pode deixar de estar em primeiro plano enquanto outra atividade ocupa a tela. Dependendo da situação e dos recursos disponíveis no dispositivo, o Android também pode encerrar processos que não são mais necessários.

Por isso, aplicativos Android precisam ser desenvolvidos considerando que podem passar por diferentes estados durante sua execução.

Processo e inicialização do aplicativo

Quando um aplicativo precisa ser executado, o Android prepara um processo para ele. Nos dispositivos modernos, novos processos de aplicativos normalmente são criados a partir do processo especial chamado Zygote, utilizando uma operação conhecida como fork.

Depois que o processo é criado e o ambiente necessário para o aplicativo é preparado, o Android pode instanciar a Activity solicitada. A partir daí, o ciclo de vida da Activity começa, incluindo a chamada ao método onCreate().

De forma simplificada, o fluxo pode ser representado assim:

1. O usuário solicita a abertura do aplicativo.
2. O Android verifica se o processo necessário já existe.
3. Caso seja necessário, o sistema cria um novo processo a partir do Zygote.
4. O ambiente do aplicativo é inicializado.
5. A Activity solicitada é instanciada.
6. O ciclo de vida da Activity começa.
7. A interface é apresentada ao usuário.

Esse processo acontece rapidamente e normalmente é invisível para quem está utilizando o celular.

Como o Android executa o código?

O código de um aplicativo precisa ser executado pelo ambiente do Android. Nos dispositivos modernos, essa função está relacionada ao Android Runtime (ART).

O ART fornece o ambiente necessário para executar o código dos aplicativos e utiliza técnicas de compilação para transformar o código em instruções que podem ser executadas pelo dispositivo.

Você não precisa dominar todos esses detalhes para começar a desenvolver Android, mas entender que existe uma camada entre o código que você escreve e a execução no dispositivo ajuda a compreender melhor o funcionamento da plataforma.

Interface e Jetpack Compose

A interface de um aplicativo Android pode ser construída de diferentes maneiras. Em projetos tradicionais, é comum encontrar layouts baseados em arquivos XML. Atualmente, o Jetpack Compose permite criar interfaces utilizando Kotlin de forma declarativa.

No Compose, em vez de definir cada elemento visual separadamente em um arquivo XML, o desenvolvedor descreve como a interface deve ser utilizando funções composable.

Essa abordagem também combina muito bem com a arquitetura Single-Activity, na qual uma Activity pode hospedar diferentes telas e estados da aplicação.

Tratamento de eventos e interação

Quando o usuário interage com o aplicativo, essas ações precisam ser tratadas pelo código. Um toque em um botão, por exemplo, pode alterar uma informação, abrir uma nova tela ou iniciar uma requisição para uma API.

Em um aplicativo conectado à internet, o fluxo pode ser parecido com este:

• O usuário toca no botão.
• O aplicativo executa o código associado ao evento.
• Uma requisição é enviada para uma API.
• O servidor processa a solicitação.
• O aplicativo recebe a resposta.
• A interface é atualizada com os novos dados.

Como o aplicativo conversa com a internet?

Aplicativos Android podem se comunicar com servidores utilizando protocolos de rede, principalmente HTTP e HTTPS. Isso permite que um aplicativo consulte APIs, envie informações e receba dados de um backend.

Bibliotecas como Retrofit são bastante utilizadas em projetos Android para facilitar o consumo de APIs REST.

Por exemplo, um aplicativo de notícias pode solicitar ao backend uma lista de artigos. O servidor retorna os dados, normalmente em JSON, e o aplicativo transforma essas informações em elementos visuais para o usuário.

Onde os dados ficam armazenados?

Um aplicativo Android pode armazenar diferentes tipos de informações localmente no dispositivo. Preferências simples podem ser armazenadas utilizando mecanismos apropriados do Android, enquanto dados estruturados podem ser armazenados em um banco de dados local.

O Room, por exemplo, fornece uma camada de abstração sobre o SQLite e facilita o trabalho com bancos de dados locais em aplicativos Android.

Isso permite que determinadas informações continuem disponíveis mesmo quando o dispositivo estiver sem conexão com a internet.

APK e Android App Bundle

Durante o processo de desenvolvimento e distribuição, o projeto Android é compilado e empacotado para ser instalado ou distribuído.

O APK é o formato tradicional de pacote instalável do Android. Já o Android App Bundle (AAB) é um formato utilizado para publicação na Google Play, permitindo que a loja gere pacotes otimizados para diferentes dispositivos.

Antes de chegar ao celular do usuário, o código do projeto passa por processos de compilação e transformação necessários para que possa ser executado no ambiente Android.

Como o Android gerencia os recursos?

O Android precisa administrar memória, bateria, processamento e outros recursos do dispositivo. Por isso, aplicativos não possuem liberdade total para executar qualquer operação indefinidamente.

Esse gerenciamento permite que vários aplicativos coexistam no mesmo dispositivo sem que um deles consuma todos os recursos disponíveis.

É também por isso que conceitos como ciclo de vida, execução em segundo plano e gerenciamento de memória são tão importantes no desenvolvimento Android.

O caminho completo de um aplicativo Android

Podemos resumir o funcionamento de um aplicativo Android em algumas etapas:

1. O desenvolvedor escreve o código e cria os recursos do aplicativo.
2. O projeto é compilado e empacotado.
3. O aplicativo é instalado no dispositivo.
4. O usuário solicita a abertura do aplicativo.
5. O Android cria ou reutiliza o processo necessário.
6. Quando um novo processo é necessário, ele pode ser criado a partir do Zygote.
7. A Activity solicitada é instanciada.
8. O ciclo de vida da Activity começa.
9. A interface é apresentada ao usuário.
10. As interações do usuário acionam o código da aplicação.
11. O aplicativo pode acessar armazenamento local, sensores, rede e outros recursos permitidos.
12. O Android continua administrando o ciclo de vida e os recursos utilizados pelo aplicativo.

De Usuário a Desenvolvedor Android

Entender como funciona um aplicativo Android por dentro torna muito mais fácil compreender os conceitos encontrados durante o desenvolvimento mobile.

Por trás de uma simples tela existem diversos componentes trabalhando juntos: código Kotlin ou Java, Activities, ciclo de vida, processos, recursos, armazenamento, APIs, Android Runtime e o próprio sistema Android.

Você não precisa dominar tudo isso de uma vez. O melhor caminho é começar pelos fundamentos e, conforme evoluir, estudar cada componente com mais profundidade.

Se você está começando agora, entender esses conceitos é um excelente primeiro passo para deixar de apenas usar aplicativos Android e começar a criar seus próprios aplicativos.