---
title: "Configurando Kotlin no Android Studio Tutorial em Português — Passo a Passo | Kotlin Brasil"
url: "https://kotlin.dev.br/tutoriais/kotlin-android-studio/"
markdown_url: "https://kotlin.dev.br/tutoriais/kotlin-android-studio.MD"
description: "Aprenda a configurar Kotlin no Android Studio do zero. Tutorial completo com instalação, SDK e primeiro projeto Android."
date: "2025-12-10"
author: "Karina Melo"
---

# Configurando Kotlin no Android Studio Tutorial em Português — Passo a Passo | Kotlin Brasil

Aprenda a configurar Kotlin no Android Studio do zero. Tutorial completo com instalação, SDK e primeiro projeto Android.


Configurar o ambiente de desenvolvimento é o primeiro passo para começar a programar em Kotlin para Android. Neste tutorial, vamos guiá-lo por todo o processo de instalação e configuração do Android Studio, desde o download até a criação do seu primeiro projeto. Se você é iniciante ou está migrando de outra linguagem, este guia completo vai ajudá-lo a começar com o pé direito.

## Pré-requisitos e Download do Android Studio

Antes de começar, verifique se seu computador atende aos requisitos mínimos para rodar o Android Studio. Você precisará de pelo menos 8 GB de RAM (16 GB recomendado), 8 GB de espaço em disco disponível é um processador moderno com suporte a virtualização para o emulador Android.

Acesse o site oficial do Android Studio em [developer.android.com/studio](https://developer.android.com/studio) e faça o download da versão mais recente. O Android Studio está disponível para Windows, macOS e Linux. A instalação é simples e guiada por um assistente que configura automaticamente o Android SDK, o build system Gradle e outras ferramentas necessárias.

Durante a instalação, o assistente perguntará sobre o tipo de instalação. Escolha "Standard" para que todas as configurações padrão sejam aplicadas automaticamente. Isso inclui o Android SDK, o emulador Android e as ferramentas de build necessárias. A instalação padrão costuma ocupar entre 4 e 8 GB de disco, dependendo dos componentes selecionados.

Após a instalação, abra o Android Studio e permita que ele faça o download de componentes adicionais. Isso pode levar alguns minutos, dependendo da velocidade da sua conexão de internet.

## Criando seu Primeiro Projeto Kotlin

Com o Android Studio instalado e configurado, vamos criar o primeiro projeto. Clique em "New Project" na tela inicial. Você verá uma lista de templates disponíveis. Para este tutorial, selecione "Empty Activity" e clique em "Next".

Na tela de configuração do projeto, preencha os seguintes campos:

- **Name**: o nome do seu aplicativo (ex: "MeuPrimeiroApp")
- **Package name**: o identificador único do app (ex: "com.exemplo.meuprimeiro")
- **Save location**: onde o projeto será salvo no disco
- **Language**: selecione **Kotlin**
- **Minimum SDK**: escolha API 24 (Android 7.0) para cobrir a maioria dos dispositivos

Clique em "Finish" e aguarde o Android Studio criar a estrutura do projeto e sincronizar o Gradle. Esse processo pode levar alguns minutos na primeira vez, pois o Gradle precisa baixar todas as dependências do projeto.

Ao final, você terá um projeto com a seguinte estrutura básica:

```kotlin
// app/src/main/java/com/exemplo/meuprimeiro/MainActivity.kt
package com.exemplo.meuprimeiro

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.Text

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Text(text = "Olá, Kotlin Brasil!")
        }
    }
}
```

Esse é o ponto de entrada da sua aplicação Android. A [class](/glossario/class/) `MainActivity` herda de `ComponentActivity` e sobrescreve o método `onCreate`, que é chamado quando a Activity é criada. O `setContent` define o conteúdo da tela usando Jetpack Compose.

## Configurando o Gradle com Kotlin

O Gradle é o sistema de build utilizado pelo Android Studio. Nos projetos modernos, o Gradle utiliza arquivos `.kts` (Kotlin Script) em vez dos tradicionais `.gradle` (Groovy). Vamos entender a estrutura dos arquivos de configuração.

O arquivo `build.gradle.kts` do módulo app contém as configurações específicas da aplicação, como versão mínima do SDK, dependências e plugins. Veja um exemplo típico:

```kotlin
// app/build.gradle.kts
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.android)
    alias(libs.plugins.kotlin.compose)
}

android {
    namespace = "com.exemplo.meuprimeiro"
    compileSdk = 35

    defaultConfig {
        applicationId = "com.exemplo.meuprimeiro"
        minSdk = 24
        targetSdk = 35
        versionCode = 1
        versionName = "1.0"
    }

    buildFeatures {
        compose = true
    }

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

    kotlinOptions {
        jvmTarget = "17"
    }
}

dependencies {
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
    implementation(libs.androidx.activity.compose)
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.ui)
    implementation(libs.androidx.material3)
}
```

O Version Catalog (`libs.versions.toml`) centraliza todas as versões de dependências em um único arquivo, facilitando a manutenção e atualização. Esse arquivo fica em `gradle/libs.versions.toml` e é referenciado nos scripts Gradle com `libs.`.

Sempre que fizer alterações nos arquivos Gradle, o Android Studio exibirá uma barra no topo pedindo para sincronizar. Clique em "Sync Now" para aplicar as mudanças. É importante manter as dependências atualizadas para receber correções de segurança e novos recursos.

## Configurando o Emulador Android

Para testar sua aplicação, você pode usar um dispositivo físico ou o emulador Android. O emulador é mais conveniente para desenvolvimento do dia a dia, pois permite testar em diferentes tamanhos de tela e versões do Android sem precisar de múltiplos dispositivos.

Para configurar o emulador, vá em "Tools > Device Manager" e clique em "Create Virtual Device". Selecione um modelo de dispositivo (ex: Pixel 7) e escolha uma imagem do sistema (system image) com Google Play APIs. Recomendamos usar a imagem mais recente disponível.

Nas configurações avançadas do emulador, ajuste a quantidade de RAM dedicada e ative a aceleração por hardware (HAXM no Windows/macOS ou KVM no Linux). Isso melhora significativamente a performance do emulador.

```kotlin
// Você pode verificar se está rodando no emulador com:
import android.os.Build

fun isEmulator(): Boolean {
    return Build.FINGERPRINT.startsWith("generic") ||
           Build.FINGERPRINT.startsWith("unknown") ||
           Build.MODEL.contains("Emulator") ||
           Build.MODEL.contains("Android SDK built for x86")
}
```

Para conectar um dispositivo físico, ative as "Opções do Desenvolvedor" nas configurações do aparelho (toque 7 vezes em "Número da versão") e habilite a "Depuração USB". Conecte o dispositivo via USB e o Android Studio o reconhecerá automaticamente.

## Atalhos e Produtividade no Android Studio

Dominar os atalhos do Android Studio aumenta significativamente sua produtividade. Aqui estão os mais importantes para desenvolvedores Kotlin:

- **Cmd/Ctrl + Shift + A**: buscar qualquer ação ou configuração
- **Cmd/Ctrl + B**: ir para a declaração de uma [fun](/glossario/fun/) ou [class](/glossario/class/)
- **Cmd/Ctrl + Shift + F**: buscar texto em todo o projeto
- **Alt + Enter**: mostrar sugestões e quick fixes
- **Cmd/Ctrl + N**: gerar código (constructors, getters, etc.)
- **Shift + Shift**: buscar qualquer coisa (arquivos, classes, símbolos)

O Android Studio também possui suporte nativo para refatoração de código Kotlin. Use "Shift + F6" para renomear variáveis, funções e classes com segurança. O "Cmd/Ctrl + Alt + M" extrai um trecho de código selecionado para uma nova função.

Outra funcionalidade poderosa é o Logcat, acessível na parte inferior da IDE. Ele exibe os logs da aplicação em tempo real, permitindo filtrar por tag, nível de log e processo. Use `Log.d("TAG", "mensagem")` no seu código para adicionar logs de debug.

## Dicas e Erros Comuns

1. **Gradle sync falhando**: se a sincronização do Gradle falhar, verifique sua conexão com a internet. O Gradle precisa baixar dependências de repositórios remotos. Também verifique se o proxy da empresa não está bloqueando o acesso.

2. **Emulador lento**: certifique-se de que a aceleração por hardware está habilitada. No Windows, instale o HAXM via SDK Manager. No Linux, verifique se o KVM está configurado corretamente.

3. **Versão do JDK incorreta**: o Android Studio inclui seu próprio JDK (JetBrains Runtime). Evite configurar um JDK externo a menos que tenha um motivo específico. Isso evita problemas de compatibilidade.

4. **Não atualizar o Android Studio**: mantenha a IDE e os plugins sempre atualizados. As atualizações incluem correções de bugs, melhorias de performance e novos recursos para Kotlin.

5. **Ignorar os warnings do Lint**: o Android Lint analisa seu código em busca de problemas potenciais. Preste atenção aos avisos e corrija-os antes de publicar seu app.

6. **Esquecer de configurar o `.gitignore`**: ao iniciar um projeto, certifique-se de que arquivos como `.idea/`, `build/` e `local.properties` estejam no `.gitignore` para evitar problemas no controle de versão.

## Conclusão e Próximos Passos

Neste tutorial, você aprendeu a instalar e configurar o Android Studio para desenvolvimento com Kotlin. Cobrimos desde o download e instalação da IDE até a criação de um projeto, configuração do Gradle, setup do emulador e dicas de produtividade.

Com o ambiente configurado, você está pronto para começar a desenvolver aplicações Android com Kotlin. O Android Studio é uma ferramenta poderosa que, quando bem configurada, torna o desenvolvimento muito mais produtivo e agradável.

Para continuar sua jornada, recomendamos os seguintes tutoriais:

- [Primeiro App Android com Kotlin](/tutoriais/primeiro-app-android/) para criar sua primeira aplicação completa
- [Jetpack Compose: Introdução](/tutoriais/jetpack-compose-básico/) para aprender UI declarativa moderna
- [Boas Práticas e Code Style](/tutoriais/boas-práticas-kotlin/) para escrever código Kotlin idiomático desde o início
