Adicionar o Kotlin a um app atual

O Android Studio oferece suporte total ao Kotlin, permitindo que você adicione arquivos Kotlin ao seu projeto e converta o código da linguagem Java para Kotlin. Depois, você poderá usar todas as ferramentas atuais do Android Studio com o código Kotlin, como preenchimento automático, verificador de lint, refatoração, depuração, entre outras.

Se você estiver iniciando um projeto e quiser usar o Kotlin, consulte Criar um projeto.

Confira também nossos exemplos de código Kotlin.

Adicionar Kotlin a um projeto existente

Para adicionar código Kotlin ao seu projeto, faça o seguinte:

1. Clique em File > New e escolha um dos vários modelos do Android, como um novo Fragment em branco, como mostrado na figura 1. Se a lista de modelos não for exibida no menu, abra antes a janela Project e selecione o módulo do app.

   

   Figura 1. Escolha entre os modelos disponíveis, como fragmento ou atividade.

2. No assistente exibido, escolha Kotlin para Source Language. A Figura 2 mostra a caixa de diálogo New Android Activity para quando você quiser criar uma nova atividade.

   

   Figura 2. Uma caixa de diálogo New Android Activity, em que você pode escolher Kotlin como Source Language.

3. Continue o fluxo do assistente.

Como alternativa, você pode clicar em File > New > Kotlin File/Class para criar um arquivo Kotlin básico. Se essa opção não for exibida, abra a janela Project e selecione o diretório java. A janela New Kotlin File/Class permite que você defina o nome do arquivo e forneça várias opções para o tipo de arquivo: FileClass, Interface, Enum Class ou Object. A escolha feita determina a estrutura básica criada para você no novo arquivo Kotlin. Se você escolher Class, o Android Studio criará um novo arquivo fonte Kotlin com o nome fornecido e uma definição de classe correspondente. Se você escolher Interface, uma interface será declarada no arquivo e assim por diante.

Se esta for a primeira vez que você adiciona uma nova classe ou arquivo Kotlin diretamente ao projeto, sem usar os modelos Android, o Android Studio vai mostrar um aviso de que seu projeto não está configurado para Kotlin, como mostrado na figura 3. Faça essa configuração clicando em Configure no canto superior direito do editor ou no event log alert que aparece no canto inferior direito.

Figura 3. O Android Studio mostra uma caixa de alerta quando o projeto não está configurado para Kotlin.

Escolha a opção para configurar o Kotlin para All modules containing Kotlin files quando solicitado, conforme mostrado na figura 4:

Figura 4. Escolha configurar Kotlin para todos os módulos que contenham código Kotlin.

Depois que você clicar em OK, o Android Studio vai adicionar Kotlin ao caminho de classe do seu projeto e aplicar o plug-in do Android para essa linguagem a cada módulo que contiver arquivos Kotlin. Seus arquivos build.gradle precisam ser semelhantes aos exemplos abaixo:

Groovy

// Project build.gradle file.
buildscript {
    ext.kotlin_version = '1.4.10'
    ...
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

Kotlin

// Project build.gradle.kts file.
buildscript {
    extra["kotlin_version"] = "1.4.10"
    ...
    dependencies {
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
    }
}

Groovy

// Inside each module using kotlin
plugins {
    ...
    id 'kotlin-android'
}

...

dependencies {
    implementation 'androidx.core:core-ktx:1.3.2'
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
}

Kotlin

// Inside each module using kotlin
plugins {
    ...
    kotlin("android")
}

...

val kotlin_version: String by rootProject.extra

dependencies {
    implementation("androidx.core:core-ktx:1.3.2")
    implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version")
}

Organização de origem

Por padrão, os novos arquivos Kotlin são salvos em src/main/java/, o que facilita a visualização dos arquivos Kotlin e Java em um único local. Se preferir separar os arquivos Kotlin dos arquivos Java, coloque os arquivos Kotlin em src/main/kotlin/. Se fizer isso, você também precisará incluir esse diretório na configuração sourceSets, conforme mostrado abaixo:

Groovy

android {
    sourceSets {
        main.java.srcDirs += 'src/main/kotlin'
    }
}

Kotlin

android {
    sourceSets {
        getByName("main") {
            java.srcDir("src/main/kotlin")
        }
    }
}

Converter código Java existente em código Kotlin

Para converter o código Java em Kotlin, abra o arquivo Java no Android Studio e selecione Code > Convert Java File to Kotlin File. Como alternativa, crie um novo arquivo Kotlin (File > New > Kotlin File/Class) e cole o código Java nesse arquivo. Em seguida, o Android Studio exibirá uma solicitação e se oferecerá para converter seu código em Kotlin, como mostrado na figura 5. Clique em Yes para converter. Opcionalmente, marque Don't show this dialog next time, o que torna as conversões futuras automáticas.

Figura 5. O Android Studio pode converter o código Java em Kotlin.

Conversão e nulidade de código

O processo de conversão do Android Studio produz código Kotlin funcionalmente equivalente para compilação e execução. No entanto, é provável que você precise fazer outras otimizações no código convertido. Por exemplo, é interessante refinar a forma como o código convertido processa tipos anuláveis.

No Android, é comum atrasar a inicialização de objetos View e outros componentes até que o fragmento ou a atividade à qual eles estão anexados atinja o estado apropriado do ciclo de vida. Por exemplo, você pode ter uma referência a um botão em um dos seus fragmentos, como demonstrado no snippet a seguir:

public class JavaFragment extends Fragment {

    // Null until onCreateView.
    private Button button;

    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.fragment_content, container,false);

        // Get a reference to the button in the view, only after the root view is inflated.
        button = root.findViewById(R.id.button);

        return root;
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);

        // Not null at this point of time when onViewCreated runs
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ...
            }
        });
    }
}

Mesmo que a variável de botão seja anulável, para todos os fins práticos, ela nunca será nula quando usada neste exemplo. No entanto, como seu valor não é atribuído no ponto de construção, o código Kotlin gerado trata Button como um tipo anulável e usa o operador de declaração não nula para separar o botão adicionando um listener de clique, conforme mostrado abaixo:

class JavaFragment : Fragment() {

    // Null until onCreateView.
    private var button: Button? = null

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
            savedInstanceState: Bundle?): View? {
        ...
        // Get a reference to the button in the view, only after the root view is inflated.
        button = root.findViewById(R.id.button)
        ...
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        // Not null at the point of time when onViewCreated fires 
        // but force unwrapped nonetheless
        button!!.setOnClickListener { }
    }
}

Essa conversão é menos ideal do que usar lateinit para este caso, porque você é forçado a separar a referência do botão com um operador de declaração não nula ou safe-call em cada local em que a referência for acessada.

Observação: este exemplo não significa que você precisa sempre evitar tipos anuláveis. Geralmente, esse padrão de uso de lateinit se aplica a variáveis que nunca se espera que sejam null, mas não podem ser inicializadas onde estão definidas, como ocorre com referências de View dentro do fragmento ou da atividade em que residem.

Em outros casos, quando null é uma atribuição de variável válida com base no caso de uso do seu aplicativo, o uso de um operador safe-call (?.) com um operador final elvis (?:) pode ser uma maneira mais adequada de separar o objeto anulável ou forçar um valor padrão sensível não nulo. O Android Studio não tem informações suficientes para determinar isso durante o processo de conversão. Embora o padrão seja a declaração não nula, acompanhe e ajuste o código convertido conforme necessário.

Mais informações

Para mais informações sobre como usar o código Kotlin e Java no seu projeto, consulte Como chamar código Java do Kotlin (link em inglês).

Para mais informações sobre como usar Kotlin em cenários corporativos, consulte Adotar o Kotlin para equipes grandes.

Para mais informações sobre wrappers idiomáticos do Kotlin para APIs existentes do Android, consulte Android KTX.