O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

Adicionar o Kotlin a um app existente

O Android Studio oferece compatibilidade total com o Kotlin. Assim, você pode adicionar arquivos Kotlin ao seu projeto e converter o código da linguagem Java em Kotlin. Em seguida, 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 novo projeto e quiser usar o Kotlin, consulte Criar um projeto.

Para amostras, confira nossas amostras de código Kotlin.

Adicionar Kotlin a um projeto existente

Para adicionar o 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.

    criar um novo fragmento em branco
    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.

    caixa de diálogo que permite escolher o Kotlin para sua linguagem fonte
    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 fornece 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 exibirá um aviso de que o Kotlin não está configurado no projeto, como mostrado na figura 3. Configure o Kotlin clicando em Configure no canto superior direito do editor ou no event log alert que aparece no canto inferior direito.

caixa de diálogo de alerta que solicita que você configure o Kotlin para o projeto
Figura 3. O Android Studio exibe uma caixa de diálogo de alerta quando o Kotlin não está configurado para o projeto.

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

opte por configurar o Kotlin para todos os módulos que contenham o código Kotlin
Figura 4. Opte por configurar o Kotlin para todos os módulos que contenham o código do Kotlin.

Depois de clicar em OK, o Android Studio adicionará o Kotlin ao caminho de classe do seu projeto e aplicará os plug-ins e extensões do Kotlin para Android em cada módulo que contiver arquivos Kotlin. Seus arquivos build.gradle precisam ser semelhantes aos exemplos abaixo:

// Project build.gradle file.
buildscript {
    ext.kotlin_version = '1.3.30'
    ...
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}
// Inside each module using kotlin
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'

...

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

Organização de fonte

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:

android {
   sourceSets {
       main.java.srcDirs += '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.

opte por configurar o Kotlin para todos os módulos que contenham o código Kotlin
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.

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 o 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.