Aller au contenu
Encyclopédie informatique Édition 2026

Le langage Kotlin

Partie 4 sur 4

Niveau de lecture :

9Kotlin sur Android, et au-delà

9.1Android et Jetpack Compose

Sur Android, Kotlin est partout : la documentation, les exemples et les nouvelles bibliothèques de Google sont écrits pour lui (figure 2). Avec Jetpack Compose, les écrans ne sont plus décrits dans des fichiers XML séparés, mais par des fonctions Kotlin qui décrivent l’interface en fonction de l’état ; quand l’état change, Compose redessine automatiquement les parties concernées :

@Composable
fun Compteur() {
    var clics by remember { mutableStateOf(0) }
    Column {
        Text("Clics : $clics")
        Button(onClick = { clics++ }) { Text("Ajouter") }
    }
}

Cette approche, dite déclarative, est la même que celle de SwiftUI chez Apple et de React sur le Web (voir Swift et les cadriciels Web).

2008 Android en Java 2011 Kotlin annoncé 2016 Kotlin 1.0 2017 Google : support officiel 2019 « Kotlin d’abord » 2021 Jetpack Compose 1.0 2023 Multiplatform stable 2024 Kotlin 2.0 2025 Compose sur iPhone De Java à Kotlin : l’évolution du langage des applications Android.
Figure 2. L’évolution du langage des applications Android.

9.2Kotlin Multiplatform

Une entreprise qui publie une application pour Android et pour iPhone doit habituellement l’écrire deux fois, en Kotlin et en Swift. Kotlin Multiplatform propose de partager le code commun, règles métier, accès au réseau, stockage, en le compilant pour chaque cible : en bytecode pour la JVM et Android, en code machine natif pour l’iPhone, le Mac ou Linux, en JavaScript ou en WebAssembly pour le navigateur (figure 3). Chaque plateforme garde, si on le souhaite, son interface propre ; Compose Multiplatform permet aussi de partager les écrans. Les mots-clés expect et actual déclarent une fonction commune et ses réalisations propres à chaque plateforme, par exemple pour accéder au trousseau de clés du système.

code Kotlin commun règles métier, réseau Kotlin/JVM bytecode Java Android, serveurs Kotlin/Native code machine iPhone, Mac, Linux Kotlin/Wasm et JS pour le navigateur applications Web Compose Multiplatform une même interface graphique pour Android, iPhone, ordinateur et navigateur Kotlin Multiplatform : partager le code commun, garder le reste propre à chaque plateforme.
Figure 3. Une base de code Kotlin, plusieurs plateformes.

9.3Côté serveur

Sur les serveurs, Kotlin est utilisé avec le cadriciel Spring, très répandu dans les entreprises qui travaillaient déjà en Java, ou avec Ktor, un cadriciel léger créé par JetBrains et fondé sur les coroutines. Les équipes y apprécient de pouvoir garder leurs bibliothèques et leur savoir-faire Java, tout en écrivant un code plus court et plus sûr (voir les API).

Kotlin sert aussi d’outil d’écriture de scripts, notamment pour les fichiers de construction de Gradle, devenus en Kotlin par défaut en 2023, et pour l’analyse de données dans des carnets interactifs, à la manière de Python. Ces usages restent toutefois secondaires : Kotlin doit l’essentiel de son succès à Android et à la JVM.

10Un exemple complet : un écran de météo

Voici, simplifié, un écran d’application Android qui affiche la météo d’une ville. Il réunit les notions de l’article : classe scellée pour l’état, coroutine pour le chargement, gestion des erreurs, et Jetpack Compose pour l’affichage. Le modèle de vue (en anglais ViewModel) contient la logique et survit aux rotations de l’écran ; l’interface se contente d’afficher son état.

sealed interface EtatMeteo {
    object Chargement : EtatMeteo
    data class Pret(val ville: String, val temp: Int) : EtatMeteo
    data class Erreur(val message: String) : EtatMeteo
}

class MeteoViewModel(private val api: MeteoApi) : ViewModel() {
    private val _etat = MutableStateFlow<EtatMeteo>(EtatMeteo.Chargement)
    val etat: StateFlow<EtatMeteo> = _etat

    fun charger(ville: String) {
        viewModelScope.launch {
            _etat.value = EtatMeteo.Chargement
            _etat.value = try {
                EtatMeteo.Pret(ville, api.temperature(ville))
            } catch (e: IOException) {
                EtatMeteo.Erreur("Réseau indisponible")
            }
        }
    }
}

@Composable
fun EcranMeteo(vm: MeteoViewModel) {
    val etat by vm.etat.collectAsState()
    when (val e = etat) {
        EtatMeteo.Chargement -> CircularProgressIndicator()
        is EtatMeteo.Pret -> Text("${e.ville} : ${e.temp} °C")
        is EtatMeteo.Erreur -> Text(e.message)
    }
}

Le modèle de vue expose un flux d’état, StateFlow, en lecture seule ; seule sa propre logique peut le modifier, à travers la version privée _etat. La fonction charger lance une coroutine dans viewModelScope : si l’utilisateur quitte l’écran pendant le chargement, la requête est annulée. L’écran observe l’état avec collectAsState et se redessine à chaque changement ; le when exhaustif garantit que les trois cas sont affichés. L’erreur réseau, transformée en état, s’affiche proprement au lieu de faire planter l’application. Dans une vraie application, on ajouterait un bouton pour réessayer, et le détail technique de l’erreur serait journalisé sans être montré à l’utilisateur.

Pour s’exercer

Exercice 8 : la clé dans l’application

Une développeuse place la clé d’accès d’un service de cartographie payant dans une constante de son application Android, compilée et « obscurcie » par l’outil R8. Un utilisateur peut-il la retrouver ? Que faire ?

Voir la réponse

Oui. Le fichier d’installation d’une application Android, l’APK, se télécharge et se décompile avec des outils gratuits ; l’obscurcissement rend les noms de fonctions illisibles, mais les chaînes de caractères, comme une clé, restent présentes, et l’on peut aussi observer les requêtes de l’application. Toute clé intégrée à une application doit donc être considérée comme publique. Les solutions : restreindre la clé côté fournisseur, à l’application signée et à des quotas faibles, quand le service le permet ; ou mieux, ne pas mettre la clé dans l’application, mais faire passer les appels par un serveur de l’entreprise, qui détient la clé, authentifie l’utilisateur et limite le nombre de requêtes (voir les API).

11Forces et limites

Forces

  • Code concis et lisible, sans perdre le typage statique.
  • Protection intégrée contre les valeurs nulles.
  • Interopérabilité totale avec Java et son immense écosystème.
  • Coroutines simples et sûres ; langage de référence d’Android.

Limites

  • Compilation longtemps plus lente que celle de Java, améliorée par Kotlin 2.0.
  • Risque de code trop « astucieux » : extensions et syntaxes abrégées peuvent nuire à la lisibilité.
  • Protection contre null incomplète à la frontière avec Java.
  • Hors d’Android et de la JVM, écosystème plus jeune, même s’il progresse vite.

Pour une personne qui veut développer des applications mobiles, Kotlin est un excellent point d’entrée, avec Swift pour l’iPhone (voir Swift). Pour qui connaît déjà Java, le passage à Kotlin est rapide et souvent apprécié.

Sécurité de l’information

Le coin cyber

Kotlin est un langage sûr pour la mémoire, comme Java, et sa gestion des valeurs nulles supprime une grande cause de plantages. Mais la sécurité d’une application Android dépend surtout de ce qu’elle stocke, de ce qu’elle expose et de la confiance qu’elle accorde. Les attaques sont décrites ici dans leur principe seulement.

C.1Une application se lit

Une application Android est distribuée sous la forme d’un fichier, l’APK, que n’importe qui peut récupérer et décompiler avec des outils gratuits, pour en lire le code et les ressources. L’obscurcissement du code, réalisé par l’outil R8, complique cette lecture sans l’empêcher. Il en découle une règle simple : aucun secret dans l’application. Ni clé d’accès à un service, ni mot de passe, ni logique de sécurité qui ne serait pas aussi vérifiée par le serveur (exercice 7). Les contrôles d’accès, les vérifications de paiement, les limites d’usage doivent toujours être appliqués côté serveur.

C.2Stocker et communiquer prudemment

  • Le stockage : les données sensibles, comme les jetons d’authentification, se protègent avec le magasin de clés d’Android (Android Keystore), qui conserve les clés de chiffrement dans une zone matérielle protégée quand le téléphone en possède une, plutôt qu’en clair dans les préférences de l’application ou sur la carte mémoire.
  • Le réseau : depuis Android 9, les connexions non chiffrées sont refusées par défaut ; il ne faut pas réactiver cette possibilité. Une application très sensible, comme une application bancaire, peut ajouter l’épinglage de certificat, qui n’accepte que le certificat attendu du serveur (voir TLS).
  • Les échanges entre applications : les composants qu’une application rend accessibles aux autres doivent être limités au strict nécessaire, et les données reçues d’autres applications vérifiées comme toute donnée extérieure.
  • Les journaux : on n’écrit jamais de données personnelles ni de jetons dans les journaux de l’application, que d’autres outils peuvent lire.

C.3Les dépendances et la construction

Une application Kotlin s’appuie sur de nombreuses bibliothèques, téléchargées par Gradle depuis des dépôts comme Maven Central, et sur des modules d’extension de Gradle qui s’exécutent pendant la construction. Une bibliothèque piégée, en particulier un kit de publicité ou de statistiques intégré sans examen, peut collecter des données à l’insu de l’utilisateur et de l’éditeur. Gradle sait vérifier les empreintes des bibliothèques téléchargées ; il faut l’activer, limiter les dépôts autorisés, et examiner ce que fait chaque kit tiers avant de l’intégrer.

C.4Idée reçue

« Mon application est compilée et obscurcie : personne ne peut lire ma clé d’API. » Faux. Le contenu d’une application installée sur un téléphone appartient, de fait, à son utilisateur : il peut le décompiler, l’analyser, observer son trafic réseau. Tout ce qui doit rester secret doit rester sur le serveur.

C.5Bonnes pratiques

Développeur

  • Éviter l’opérateur !! ; traiter explicitement les valeurs absentes et les erreurs.
  • Ne stocker aucun secret dans l’application ; protéger les jetons avec le magasin de clés d’Android.
  • Valider toutes les données reçues, du réseau comme des autres applications.

Organisation

  • Faire vérifier l’application selon le référentiel MASVS de l’OWASP avant publication.
  • Activer la vérification des dépendances dans Gradle et examiner les kits tiers.
  • Appliquer tous les contrôles de sécurité côté serveur, quelle que soit l’application cliente.

Référentiels : OWASP (Open Worldwide Application Security Project), Mobile Application Security Verification Standard (MASVS) et son guide de test, le MASTG · Google, Android Security Best Practices.

Références

  1. S. Aigner, R. Elizarov, S. Isakova, D. Jemerov, Kotlin in Action, 2e éd., Manning, 2024.
  2. JetBrains, Kotlin Language Specification et documentation officielle.
  3. R. Elizarov, M. Belyaev, M. Akhin, I. Usmanov, « Kotlin Coroutines: Design and Implementation », Onward!, 2021.
  4. Google, Android Developers : guides Kotlin, Jetpack Compose et sécurité.
  5. OWASP, MASVS et MASTG, versions 2024-2025.

Voir aussi

Citer cet article

« Le langage Kotlin », Encyclopédie informatique, révision du 26 octobre 2026.