Android: o que é, arquitetura do sistema e desenvolvimento em Kotlin

O que é Android?

Android é um sistema operacional móvel baseado no kernel Linux, desenvolvido pelo Google desde 2007. O código-fonte é aberto sob licença Apache 2.0 como parte do Android Open Source Project (AOSP). Cada fabricante pode modificar o sistema e instalá-lo em seus dispositivos.

De acordo com StatCounter (2026), o Android detém cerca de 72% do mercado global de SO móveis. Os maiores fabricantes são Samsung, Xiaomi, Oppo, Vivo, Google Pixel. A fragmentação é um problema chave da plataforma: milhares de modelos com diferentes versões do SO são usados simultaneamente.

A arquitetura do Android é construída no princípio de permissões (permissions): cada aplicativo executa sob um UID Linux separado e tem acesso apenas aos seus próprios dados. O acesso a recursos do sistema (câmera, microfone, contatos) é solicitado via Android Permissions em tempo de execução, a partir do Android 6 (API 23).

Histórico de versões do Android

Android 1.0 foi lançado em 2008 no HTC Dream. Marcos principais: Android 4.0 Ice Cream Sandwich (UI unificada para telefones e tablets), Android 5.0 Lollipop (Material Design), Android 6.0 (permissões em tempo de execução), Android 10 (tema escuro, gestos), Android 12 (Material You). Desde 2023, o Google passou a lançamentos anuais sem nomes de sobremesas.

Arquitetura do Android: quatro camadas principais

A arquitetura do Android consiste em quatro camadas principais que isolam o hardware dos aplicativos do usuário. Cada camada usa os serviços da camada inferior através de interfaces estritamente definidas.

Kernel Linux e HAL

A camada inferior é um kernel Linux modificado (LTS, versão 6.x no Android 15). Ele gerencia memória, processos, pilha de rede e drivers. A Hardware Abstraction Layer (HAL) fornece uma API unificada para interagir com o hardware: câmera, Bluetooth, Wi-Fi, sensores. Os fabricantes implementam módulos HAL sem afetar as camadas superiores.

Android Runtime (ART)

O ART executa o bytecode DEX dos aplicativos. A partir do Android 5.0, o ART substituiu o Dalvik e usa compilação Ahead-of-Time (AOT) para melhor desempenho. Cada aplicativo tem seu próprio processo com uma instância ART separada. A coleta de lixo (GC) funciona com pausas mínimas — uma pausa típica de GC é de 2–4 ms.

Application Framework

O Framework é a camada com a qual o desenvolvedor trabalha diretamente. Inclui Activity Manager (pilha de telas), Content Providers (acesso a dados), Resource Manager (localização, recursos), Notification Manager, Location Manager. Todos os serviços do sistema são chamados via Binder IPC — o mecanismo de comunicação entre processos do Android.

// Exemplo de trabalho com Binder via interface AIDL
interface IDataService : android.os.IInterface {
    fun getData(): List<DataItem>
    fun saveData(item: DataItem): Boolean
}

// Implementação do serviço
class DataService : Service() {
    private val binder = object : IDataService.Stub() {
        override fun getData(): List<DataItem> = repository.getAll()
        override fun saveData(item: DataItem): Boolean = repository.save(item)
    }

    override fun onBind(intent: Intent?): IBinder = binder
}

Apps do sistema

A camada superior consiste em aplicativos padrão do sistema: Telefone, Contatos, Câmera, Configurações, Navegador. Eles não têm privilégios maiores que os aplicativos do usuário, mas podem ser substituídos por aplicativos de terceiros. No Android 15, os aplicativos do sistema são atualizados via Google Play System Updates independentemente das atualizações OTA do fabricante.

Kotlin — linguagem principal de desenvolvimento Android

Kotlin é uma linguagem de programação estaticamente tipada da JetBrains que roda na JVM. O Google anunciou Kotlin como linguagem oficial do Android em 2017 no Google I/O. Kotlin é totalmente compatível com Java, mas elimina suas deficiências: null-safety, classes de dados, funções de extensão e corrotinas.

Null Safety e tipos

A principal característica do Kotlin é a proteção embutida contra NullPointerException. Os tipos são divididos em nullable (String?) e non-null (String). O compilador verifica o acesso nullable em tempo de compilação. O operador safe call (?.) e o operador Elvis (?:) simplificam o trabalho com valores opcionais sem verificações aninhadas.

// Exemplo de código Kotlin com corrotinas e Flow
data class User(
    val id: Long,
    val name: String,
    val email: String
)

class UserRepository(
    private val api: UserApi,
    private val dao: UserDao
) {
    suspend fun getUser(id: Long): Result<User> {
        return try {
            val cached = dao.getUser(id)
            if (cached != null) {
                return Result.success(cached)
            }
            val remote = api.fetchUser(id)
            dao.insertUser(remote)
            Result.success(remote)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun observeUsers(): Flow<List<User>> {
        return dao.observeAll()
            .map { list -> list.sortedBy { it.name } }
            .flowOn(Dispatchers.Default)
    }
}

O exemplo demonstra corrotinas (função suspend) para acesso assíncrono a rede e banco de dados, Flow para observação reativa de mudanças de dados e Result para tratamento seguro de erros. As corrotinas substituem callbacks e RxJava sem sobrecarga de threads.

Corrotinas Kotlin e Flow

As corrotinas Kotlin são threads leves executadas em um pool de threads compartilhado. Dispatchers.IO para rede e disco, Dispatchers.Main para UI, Dispatchers.Default para tarefas intensivas de CPU. viewModelScope e lifecycleScope cancelam automaticamente as corrotinas quando o componente é destruído.

// ViewModel com corrotinas e StateFlow
class UserViewModel(
    private val repository: UserRepository
) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    private val _loading = MutableStateFlow(false)
    val loading: StateFlow<Boolean> = _loading.asStateFlow()

    init {
        viewModelScope.launch {
            repository.observeUsers().collect { userList ->
                _users.value = userList
            }
        }
    }

    fun refresh() {
        viewModelScope.launch {
            _loading.value = true
            repository.getUser(42).onSuccess { user ->
                _users.value = listOf(user)
            }
            _loading.value = false
        }
    }
}

Android Studio e ferramentas de desenvolvimento

Android Studio é a IDE oficial baseada no IntelliJ IDEA, desenvolvida pelo Google. Inclui editor de código, Layout Inspector, emulador de dispositivos, APK Analyzer, Profiler (CPU, Memória, Rede, Energia) e integração com Firebase. Android Studio 2024 (Ladybug) suporta Kotlin 2.0 com modo multiplataforma KMP.

Emulador Android

O Emulador Android usa KVM (Linux) ou Hyper-V (Windows) para aceleração de hardware. Suporta simulação de GPS, sensores, câmera, chamadas e SMS. Google Pixel 9 Pro é a configuração recomendada para testes com API 35 e 8 GB de RAM do emulador.

Android Profiler e depuração

O Profiler exibe em tempo real a carga da CPU, alocação de memória, requisições de rede e consumo de energia. O Memory Profiler permite despejo de heap e análise de vazamentos através da árvore de referências. O Network Inspector grava todas as requisições HTTP/HTTPS com corpo e cabeçalhos. Para análise aprofundada, usa-se o Android Studio Canary.

Componentes de um app Android

Um app Android consiste em quatro tipos de componentes, cada um com seu próprio ponto de entrada e ciclo de vida. Os componentes são registrados no arquivo AndroidManifest.xml.

Activity e Intent

Activity é o componente básico da interface do usuário. Cada tela é uma Activity separada ou um Fragment dentro de uma Activity. A navegação entre telas é feita via Intent — um objeto contendo uma ação (ACTION_VIEW, ACTION_SEND) e dados (URI). No Jetpack Navigation Graph, a navegação é descrita em XML.

Service e WorkManager

Service executa tarefas em segundo plano, mas a partir do Android 8, os serviços em segundo plano são restritos. WorkManager é a biblioteca recomendada para tarefas em segundo plano adiadas e garantidas com suporte a cadeias, restrições (por exemplo, apenas durante o carregamento) e reinicialização após falha.

Jetpack Compose vs XML Layouts

A escolha entre Jetpack Compose e layouts XML tradicionais é a principal decisão arquitetural ao iniciar um projeto Android. XML Layouts (RecyclerView, ConstraintLayout, FrameLayout) são o padrão desde 2008. Jetpack Compose foi introduzido em 2021 como uma alternativa declarativa.

O Google recomenda Jetpack Compose para todos os projetos novos. XML Layouts permanecem relevantes para suporte a projetos legados e para casos onde é necessária máxima customização de View (Canvas, SurfaceView). O código Compose é em média 40% mais curto que o XML + ViewBinding equivalente.

// Jetpack Compose — tela de perfil do usuário
@Composable
fun ProfileScreen(
    user: User,
    onEditClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Column(
        modifier = modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        AsyncImage(
            model = user.avatarUrl,
            contentDescription = "Avatar do usuário",
            modifier = Modifier
                .size(120.dp)
                .clip(CircleShape)
        )

        Spacer(modifier = Modifier.height(16.dp))

        Text(
            text = user.name,
            style = MaterialTheme.typography.headlineMedium
        )

        Text(
            text = user.email,
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )

        Spacer(modifier = Modifier.height(24.dp))

        Button(onClick = onEditClick) {
            Icon(Icons.Default.Edit, contentDescription = null)
            Spacer(modifier = Modifier.width(8.dp))
            Text("Editar perfil")
        }
    }
}

@Preview(showBackground = true, showSystemUi = true)
@Composable
fun ProfileScreenPreview() {
    MaterialTheme {
        ProfileScreen(
            user = User(1, "Ana Petrova", "anna@example.com"),
            onEditClick = {}
        )
    }
}

A função ProfileScreen é declarada como @Composable — ela descreve a UI declarativamente sem criar instâncias de View. O Compose atualiza automaticamente a tela quando user muda. @Preview mostra o resultado diretamente na IDE sem compilar e executar no emulador.

Ciclo de vida de Activity e Fragment

Cada Activity no Android passa por seis estados do ciclo de vida: onCreate, onStart, onResume, onPause, onStop, onDestroy. Fragment adiciona onAttach, onCreateView, onViewCreated. Compreender o ciclo de vida é crítico para gerenciamento de memória e prevenção de vazamentos.

Estados principais da Activity

onCreate — chamado uma vez quando a Activity é criada. A inicialização é feita aqui: setContentView, configuração de adaptadores, assinatura de LiveData. onResume — a Activity está em primeiro plano e interagindo com o usuário. onPause — a Activity perde o foco (diálogo, outra Activity). onStop — a Activity não está visível. onDestroy — a Activity é destruída.

// Activity com gerenciamento de ciclo de vida via LifecycleScope
class MainActivity : ComponentActivity() {
    private val viewModel: UserViewModel by viewModels()

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

        setContent {
            MaterialTheme {
                lifecycleScope.launch {
                    repeatOnLifecycle(Lifecycle.State.STARTED) {
                        viewModel.users.collect { users ->
                            updateUi(users)
                        }
                    }
                }
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("last_search", searchQuery)
    }

    override fun onRestoreInstanceState(savedInstanceState: Bundle) {
        super.onRestoreInstanceState(savedInstanceState)
        searchQuery = savedInstanceState.getString("last_search", "")
    }
}

O uso de repeatOnLifecycle garante que a coleta de dados pausa quando a Activity vai para segundo plano e retoma quando volta ao primeiro plano. Isso evita vazamentos e requisições de rede desnecessárias. onSaveInstanceState salva o estado temporário na rotação da tela.

Google Play: publicação e requisitos

Google Play é a loja oficial de aplicativos Android. O registro de conta de desenvolvedor custa $25 único. Cada aplicativo passa por uma verificação automática do Google Play Integrity para detectar código malicioso, violações de políticas e uso incorreto de permissões.

Requisitos de publicação

O Google exige assinatura do aplicativo via Android App Bundle (AAB) ou APK. AAB é o formato recomendado, que permite gerar APKs otimizados para cada configuração de dispositivo. O aplicativo deve ser assinado com uma chave (keystore) com certificado válido. Google Play App Signing é criptografia opcional da chave pelo Google.

Política de privacidade

Todos os aplicativos que solicitam acesso a dados pessoais devem fornecer uma Política de privacidade. Desde 2024, o Google exige uma declaração Data Safety — um formulário especificando os tipos de dados coletados e finalidades de processamento. Aplicativos para Android 14+ devem usar a Declarations API para declarar permissões.