Ajouter Kotlin à une application existante

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Android Studio est entièrement compatible avec Kotlin. Ainsi, vous pouvez ajouter des fichiers Kotlin à votre projet existant et convertir le code Java en Kotlin. Vous pouvez ensuite utiliser tous les outils Android Studio existants avec votre code Kotlin, y compris la saisie semi-automatique, la vérification lint, la refactorisation et le débogage.

Si vous démarrez un nouveau projet et souhaitez utiliser Kotlin, consultez la page Créer un projet.

Pour des exemples, consultez nos exemples de code Kotlin.

Ajouter Kotlin à un projet existant

Pour ajouter Kotlin à votre projet, procédez comme suit :

  1. Cliquez sur File > New (Fichier > Nouveau) et choisissez l'un des différents modèles Android, par exemple un nouveau Fragment vide, comme illustré dans la figure 1. Si vous ne voyez pas la liste des modèles dans ce menu, ouvrez d'abord la fenêtre Project (Projet), puis sélectionnez votre module d'application.

    créer un fragment vide
    Figure 1. Choisissez l'un des modèles disponibles tels que Fragment ou Activité.
  2. Dans l'assistant qui s'affiche, choisissez Kotlin en tant que Langage source. La figure 2 montre la boîte de dialogue New Android Activity (Nouvelle activité Android) pour laquelle vous souhaitez créer une activité.

    boîte de dialogue permettant de choisir Kotlin comme langage source
    Figure 2. Une boîte de dialogue New Android Activity dans laquelle vous pouvez choisir Kotlin en tant que Source Language (Langage source).
  3. Suivez les instructions de l'assistant.

Vous pouvez également cliquer sur File > New > Kotlin File/Class (Fichier > Nouveau > Fichier/Classe Kotlin) pour créer un fichier Kotlin de base. Si cette option ne s'affiche pas, ouvrez la fenêtre Projet et sélectionnez le répertoire java. La fenêtre New Kotlin File/Class (Nouveau fichier/Classe Kotlin) vous permet de définir le nom du fichier et offre plusieurs choix pour le type de fichier : File (Fichier),Class (Classe), Interface, Enum Class (Classe d'énumération) ou Object (Objet). Votre choix détermine l'échafaudage (scaffolding) de base créé pour vous dans le nouveau fichier Kotlin. Si vous sélectionnez Class, Android Studio crée un fichier source Kotlin avec le nom donné et une définition de classe correspondante. Si vous sélectionnez Interface, une interface est déclarée dans le fichier, et ainsi de suite.

Si vous ajoutez directement une classe ou un fichier Kotlin à votre projet pour la première fois (sans utiliser les modèles Android), Android Studio affiche un avertissement indiquant que Kotlin n'est pas configuré dans le projet, comme le montre la figure 3. Configurez Kotlin en cliquant sur Configure (Configurer) en haut à droite de l'éditeur ou dans l'alerte du journal des événements qui s'affiche en bas à droite.

boîte de dialogue d'avertissement qui vous invite à configurer Kotlin pour votre projet
Figure 3. Android Studio affiche une boîte de dialogue d'avertissement lorsque Kotlin n'est pas configuré pour votre projet.

Lorsque vous y êtes invité, sélectionnez l'option permettant de configurer Kotlin pour tous les modules contenant des fichiers Kotlin, comme illustré dans la figure 4 :

sélectionnez l'option permettant de configurer Kotlin pour tous les modules contenant du code Kotlin
Figure 4. Configurez Kotlin pour tous les modules contenant du code Kotlin.

Une fois que vous avez cliqué sur OK, Android Studio ajoute Kotlin au chemin de classe du projet et applique le plug-in Android Kotlin à chaque module contenant des fichiers Kotlin. Vos fichiers build.gradle devraient ressembler aux exemples ci-dessous :

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")
}

Organisation de la source

Par défaut, les nouveaux fichiers Kotlin sont enregistrés dans src/main/java/, ce qui permet de voir facilement les fichiers Kotlin et Java au même endroit. Si vous préférez séparer vos fichiers Kotlin de vos fichiers Java, vous pouvez les placer sous src/main/kotlin/. Dans ce cas, vous devez également inclure ce répertoire dans votre configuration sourceSets, comme illustré ci-dessous :

Groovy

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

Kotlin

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

Convertir du code Java en Kotlin

Pour convertir du code Java en Kotlin, ouvrez le fichier Java dans Android Studio et sélectionnez Code > Convert Java File to Kotlin File (Code > Convertir le fichier Java en fichier Kotlin). Vous pouvez également créer un fichier Kotlin en sélectionnant File > New > Kotlin File/Class (Fichier > Nouveau > Fichier/Classe Kotlin), puis coller votre code Java dans celui-ci. Android Studio affiche ensuite une invite et propose de convertir votre code en Kotlin, comme le montre la figure 5. Cliquez sur Yes (Oui) pour effectuer la conversion. Vous pouvez également cocher la case Don't show this dialog next time (Ne pas afficher cette boîte de dialogue la prochaine fois) pour que les futures conversions soient automatiques.

sélectionnez l'option permettant de configurer Kotlin pour tous les modules contenant du code Kotlin
Figure 5. Android Studio peut convertir du code Java en Kotlin.

Conversion de code et possibilité de valeur nulle

Le processus de conversion d'Android Studio génère un code Kotlin fonctionnellement identique qui peut être compilé et exécuté. Toutefois, vous devrez probablement apporter d'autres améliorations au code converti. Par exemple, vous pouvez affiner la façon dont le code converti gère les types nullable.

Dans Android, il est courant de retarder l'initialisation des objets View et d'autres composants jusqu'à ce que le fragment ou l'activité auxquels ils sont associés atteigne l'état de cycle de vie approprié. Par exemple, vous pouvez faire référence à un bouton dans l'un de vos fragments, comme illustré dans l'extrait suivant :

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) {
                ...
            }
        });
    }
}

Bien que la variable Button soit nullable, elle ne doit jamais avoir une valeur nulle dans cet exemple. Cependant, comme sa valeur n'est pas attribuée au moment de la construction, le code Kotlin généré traite Button comme un type nullable et utilise l'opérateur d'assertion "non nul" pour désencapsuler le bouton lors de l'ajout d'un écouteur de clics, comme illustré ci-dessous :

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 { }
    }
}

Dans ce cas, cette conversion est moins idéale que l'utilisation de lateinit, car vous devez désencapsuler la référence au bouton avec une assertion non nulle ou un opérateur d'appel sécurisé dans tous les endroits auxquels elle est accessible.

Dans d'autres cas, où null est une attribution de variable valide en fonction du cas d'utilisation de votre application, l'utilisation d'un opérateur d'appel sécurisé (?.) avec un opérateur Elvis de fin (?:) peut être un moyen plus approprié de désencapsuler de façon sécurisée l'objet nullable ou de le contraindre à une valeur par défaut non nulle. Android Studio ne dispose pas de suffisamment d'informations pour déterminer cela lors du processus de conversion. Bien qu'il utilise par défaut l'assertion non nulle, vous devez vérifier et ajuster le code converti si nécessaire.

Plus d'informations

Pour en savoir plus sur l'utilisation du code Kotlin et du code Java dans votre projet, consultez la page Appeler du code Java à partir de Kotlin.

Pour en savoir plus sur l'utilisation de Kotlin dans des scénarios d'entreprise, consultez la page Adopter Kotlin pour les grandes équipes.

Pour en savoir plus sur les wrappers Kotlin idiomatiques pour les API Android existantes, consultez la page Android KTX.