Kotlin para Android: como começar com Jetpack Compose em 2026

Este guia de Kotlin Android mostra um caminho prático do primeiro projeto até uma arquitetura moderna. Os exemplos usam Compose para interface, StateFlow para estado e coroutines para tarefas assíncronas — a combinação mais comum em aplicações Android novas.

Se você prefere um percurso mais extenso, use também o guia completo de desenvolvimento Android com Kotlin. Para configurar IDE, SDK, emulador e o primeiro projeto com mais detalhes, siga o tutorial de Kotlin no Android Studio.

Por que Kotlin para Android?

Não é exagero dizer que Kotlin revolucionou o desenvolvimento Android. Antes, a gente escrevia toneladas de boilerplate em Java, lidava com NullPointerException a todo momento e sofria com callbacks aninhados. Kotlin resolveu tudo isso de uma vez.

Os principais benefícios para Android:

• Jetpack Compose: o toolkit moderno de UI do Android é escrito em Kotlin
• Coroutines: substituem AsyncTask e callbacks complexos
• Null Safety: menos crashes em produção
• Código conciso: menos linhas, menos bugs, mais clareza
• Interop com Java: seu código legado continua funcionando

Para fluxos que usam hardware, também vale estudar CameraX com Jetpack Compose e Kotlin, porque câmera combina permissão, lifecycle, performance e estado de UI no mesmo recurso.

Kotlin ou Java para Android?

Para um app Android novo, comece com Kotlin. Java ainda é relevante para manter sistemas legados e entender bibliotecas antigas, mas Kotlin oferece null safety, coroutines, código mais conciso e integração direta com Jetpack Compose. A interoperabilidade permite chamar Java a partir de Kotlin e migrar arquivo por arquivo, sem reescrever o projeto inteiro.

A escolha não precisa ser definitiva: módulos e arquivos Kotlin convivem com Java no mesmo projeto. Veja a análise completa em Kotlin vs Java para Android.

Aplicações Kotlin: quem usa a linguagem na prática

Se a dúvida é quais aplicações Kotlin existem de verdade, a resposta curta é: a maioria dos apps mais baixados da Play Store já inclui código Kotlin. Desde que o Google tornou Kotlin a linguagem preferida do Android, em 2019, praticamente todo app Android novo nasce em Kotlin — e boa parte dos legados foi migrada gradualmente.

Além do Android, Kotlin roda em produção em aplicações backend com Ktor e Spring Boot, em apps desktop com Compose Multiplatform e em lógica compartilhada entre plataformas com Kotlin Multiplatform. Para um panorama completo de todas as frentes — web, desktop, scripting, ciência de dados — leia Kotlin serve para quê?.

O ponto prático para quem está começando: aprender Kotlin para Android abre caminho para esses outros cenários depois, porque a linguagem e as coroutines são as mesmas. O post sobre o futuro do Kotlin Multiplatform mostra como esse movimento tem evoluído.

Configurando o ambiente

Para começar, instale a versão estável do Android Studio e os componentes sugeridos pelo SDK Manager. Na criação do projeto, escolha um template com Compose, mantenha Kotlin como linguagem e execute a tela inicial em um emulador antes de adicionar bibliotecas.

No build.gradle.kts do módulo app, uma base com Compose fica assim. As versões evoluem; confirme a plataforma estável no guia do Compose BOM antes de copiar para produção:

plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
    id("org.jetbrains.kotlin.plugin.compose")
}

android {
    namespace = "br.dev.kotlin.meuapp"
    compileSdk = 36

    defaultConfig {
        applicationId = "br.dev.kotlin.meuapp"
        minSdk = 24
        targetSdk = 36
    }
}

val composeBom = platform("androidx.compose:compose-bom:2026.08.00")

dependencies {
    implementation(composeBom)
    androidTestImplementation(composeBom)

    implementation("androidx.activity:activity-compose:1.11.0")
    implementation("androidx.compose.ui:ui")
    implementation("androidx.compose.material3:material3")
    implementation("androidx.compose.ui:ui-tooling-preview")
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.9.3")
    debugImplementation("androidx.compose.ui:ui-tooling")
}

Trate os números acima como uma combinação de referência da data de atualização, não como versões eternas. Verifique as release notes oficiais e teste a atualização no seu projeto.

Depois, valide três coisas: o Gradle sincroniza sem erro, o emulador abre e a MainActivity renderiza um composable. Resolver essa base primeiro evita confundir falhas de ambiente com problemas no código.

Jetpack Compose: UI moderna com Kotlin

Jetpack Compose mudou completamente a forma de construir interfaces no Android. Esqueça XML — agora tudo é código Kotlin declarativo.

@Composable
fun TelaDeBoasVindas(nome: String) {
    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(24.dp),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "Fala, $nome!",
            style = MaterialTheme.typography.headlineLarge
        )

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

        Text(
            text = "Bem-vindo ao app Kotlin Brasil",
            style = MaterialTheme.typography.bodyLarge,
            color = MaterialTheme.colorScheme.onSurfaceVariant
        )

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

        Button(onClick = { /* ação aqui */ }) {
            Text("Começar")
        }
    }
}

Repare como é intuitivo: você compõe a tela usando funções. Cada @Composable é um bloco de construção reutilizável.

Gerenciamento de estado

No Compose, estado é tudo. Quando o estado muda, a UI recompõe automaticamente:

@Composable
fun ContadorSimples() {
    var contagem by remember { mutableIntStateOf(0) }

    Column(
        horizontalAlignment = Alignment.CenterHorizontally,
        modifier = Modifier.padding(16.dp)
    ) {
        Text(
            text = "Contagem: $contagem",
            style = MaterialTheme.typography.displayMedium
        )

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

        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
            Button(onClick = { contagem-- }) {
                Text("-")
            }
            Button(onClick = { contagem++ }) {
                Text("+")
            }
        }
    }
}

ViewModel com Kotlin

Para estado mais complexo, usamos ViewModel com StateFlow:

data class ListaDeTarefasUiState(
    val tarefas: List<String> = emptyList(),
    val carregando: Boolean = false
)

class TarefasViewModel : ViewModel() {
    private val _uiState = MutableStateFlow(ListaDeTarefasUiState())
    val uiState: StateFlow<ListaDeTarefasUiState> = _uiState.asStateFlow()

    fun adicionarTarefa(tarefa: String) {
        _uiState.update { estadoAtual ->
            estadoAtual.copy(
                tarefas = estadoAtual.tarefas + tarefa
            )
        }
    }

    fun carregarTarefas() {
        viewModelScope.launch {
            _uiState.update { it.copy(carregando = true) }

            val tarefas = repositorio.buscarTarefas() // suspend function
            _uiState.update {
                it.copy(tarefas = tarefas, carregando = false)
            }
        }
    }
}

@Composable
fun TelaDeTarefas(viewModel: TarefasViewModel = viewModel()) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    if (uiState.carregando) {
        CircularProgressIndicator()
    } else {
        LazyColumn {
            items(uiState.tarefas) { tarefa ->
                Text(text = tarefa, modifier = Modifier.padding(16.dp))
            }
        }
    }
}

Navegação com Compose

A navegação entre telas em Compose ficou bem mais simples:

@Composable
fun AppNavigation() {
    val navController = rememberNavController()

    NavHost(navController = navController, startDestination = "home") {
        composable("home") {
            TelaInicial(
                onNavigateToDetalhes = { id ->
                    navController.navigate("detalhes/$id")
                }
            )
        }
        composable("detalhes/{id}") { backStackEntry ->
            val id = backStackEntry.arguments?.getString("id")
            TelaDetalhes(id = id)
        }
    }
}

Quando essa navegação precisa ser aberta por notificações, e-mails ou páginas web, trate o contrato de URL como parte da arquitetura. O guia de App Links e deep links no Android com Kotlin mostra como validar rotas externas, integrar com Navigation Compose e testar links críticos. Para o caminho completo a partir do clique na notificação push, use também FCM com NotificationChannel e PendingIntent.

Chamadas de rede com Coroutines

Aqui é onde Kotlin brilha no Android. Nada de callbacks ou AsyncTask:

class UsuarioRepository(private val api: ApiService) {

    suspend fun buscarUsuarios(): Result<List<Usuario>> {
        return try {
            val response = api.getUsuarios()
            Result.success(response)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

A palavra-chave suspend indica que essa função pode ser pausada sem bloquear a thread. Combinada com viewModelScope.launch, ela roda fora da main thread automaticamente.

Boas práticas para Android com Kotlin

1. Use StateFlow em vez de LiveData em projetos novos — é mais idiomático em Kotlin e se integra melhor com coroutines
2. Prefira val sobre var — imutabilidade previne bugs e facilita o raciocínio sobre o código
3. Aplique a arquitetura recomendada: UI Layer > Domain Layer > Data Layer. Separar responsabilidades facilita a manutenção e os testes
4. Escreva testes de Compose com createComposeRule() — testes de UI garantem que mudanças não quebrem a experiência do usuário
5. Use Hilt ou Koin para injeção de dependências — evite instanciar dependências manualmente nos Composables e ViewModels
6. Evite lógica de negócio em Composables — delegue pro ViewModel para manter as funções @Composable focadas apenas na renderização da UI
7. Modularize seu projeto — conforme o app cresce, separar features em módulos Gradle melhora o tempo de build e a organização do código. Para uma estratégia completa, veja modularização Android com Kotlin e Compose
8. Use collectAsStateWithLifecycle() em vez de collectAsState() — ele respeita o ciclo de vida e para de coletar quando o app vai para background, economizando recursos

Testes de UI com Compose

Testar telas em Compose é simples e intuitivo. Usando createComposeRule(), você consegue verificar se os elementos estão visíveis e se as interações funcionam corretamente:

@get:Rule
val composeTestRule = createComposeRule()

@Test
fun telaDeBoasVindas_exibeNomeDoUsuario() {
    composeTestRule.setContent {
        TelaDeBoasVindas(nome = "Karina")
    }

    composeTestRule
        .onNodeWithText("Fala, Karina!")
        .assertIsDisplayed()

    composeTestRule
        .onNodeWithText("Começar")
        .assertIsDisplayed()
        .performClick()
}

Você pode buscar elementos por texto, por testTag ou por semântica. O importante é cobrir os fluxos principais do app para garantir que regressões sejam detectadas rapidamente.

Roteiro para criar seu primeiro app Android com Kotlin

Em vez de estudar cada API isoladamente, construa um app pequeno — por exemplo, uma lista de tarefas — em etapas:

1. crie duas telas em Compose;
2. modele o estado com uma data class;
3. mova ações e estado para um ViewModel;
4. use StateFlow e collectAsStateWithLifecycle();
5. adicione navegação entre lista e detalhes;
6. persista itens com Room ou consuma uma API com Retrofit;
7. trate loading, sucesso, vazio e erro;
8. escreva ao menos um teste de ViewModel e um teste de UI;
9. execute o Profiler e teste acessibilidade antes da release.

Esse projeto reúne as habilidades que aparecem juntas no trabalho real. Depois da base, avance para MVVM com Kotlin, coroutines para iniciantes e permissões no Android.

Perguntas frequentes sobre Kotlin Android

Preciso aprender Java antes de Kotlin para Android?

Não. Você pode começar diretamente com Kotlin e consultar Java quando encontrar código legado. Conhecer conceitos da JVM ajuda, mas não é pré-requisito para criar seu primeiro app Android.

Kotlin serve apenas para Android?

Não. Kotlin também é usado em backend com Ktor ou Spring Boot, aplicações desktop, Kotlin Multiplatform, JavaScript e WebAssembly. Android é um dos seus ecossistemas mais maduros, não o único.

Jetpack Compose substitui XML?

Em projetos novos, Compose pode ser usado para toda a interface. Em apps existentes, Compose e Views XML podem coexistir durante uma migração gradual. A escolha depende do legado, da equipe e das bibliotecas usadas.

Quais aplicações famosas foram feitas com Kotlin?

Apps Android do Google, Pinterest, Cash App, HEY e do iFood usam Kotlin, e empresas como Netflix e Uber aplicam a linguagem em apps e serviços de backend. A maioria dos apps mais baixados da Play Store já contém código Kotlin.

Quanto tempo leva para aprender Kotlin Android?

Quem já programa pode construir um app simples em poucas semanas de prática consistente. Para trabalhar profissionalmente, além da sintaxe, é necessário dominar lifecycle, arquitetura, dados, testes, debugging, performance e publicação.

Kotlin Multiplatform é igual a desenvolvimento Android?

Não. No Android nativo, Kotlin é usado com as APIs do Android e Jetpack. No Kotlin Multiplatform, parte da lógica — e, em alguns projetos, da UI — pode ser compartilhada com iOS, desktop e web.

Conclusão

Para começar com Kotlin Android, não tente dominar todo o ecossistema de uma vez. Configure o Android Studio, construa uma tela com Compose, mova o estado para um ViewModel e evolua o mesmo app com navegação, dados e testes. Essa sequência cria uma base mais sólida do que colecionar exemplos desconectados.

Kotlin e Java podem conviver, mas Kotlin é a escolha mais direta para um projeto Android novo. Quando o app precisar de backend, você pode continuar no ecossistema Kotlin com Spring Boot ou Ktor, ou avaliar Go e Python conforme a equipe e o caso de uso.