Introduction

Kotlin est un langage de programmation utilisé principalement comme une alternative au langage Java. Les applications écrites en Kotlin comme en Java ont besoin de la machine virtuelle Java (la JVM) pour être exécutées. Cependant, grâce à la technologie Kotlin Multiplatform ou KMP, une application ou une librairie écrite en Kotlin peut être compilée en ciblant d’autres plates-formes que la JVM.

Cette technologie de compilation a été créée par JetBrains en 2020. Son objectif principal était de pouvoir écrire en Kotlin une seule application mobile pour les deux systèmes d’exploitation Android et iOS. Le même code de l’application est réutilisé pour les deux systèmes. En pratique, la réutilisation du code concerne principalement la partie logique métier de l’application. Les interactions avec l’interface homme-machine restent spécifiques à chaque système d’exploitation. Une application mobile écrite totalement en Kotlin avec la technologie KMP contient trois modules de code principaux :

le code partagé implémentant la logique métier de l’application ;
le code de la gestion de l’interface utilisateur pour le système Android ;
le code de la gestion de l’interface utilisateur pour le système iOS.

Même si l’intégralité du code de l’application ne peut pas être réutilisée pour les différents systèmes d’exploitation, la technologie KMP permet d’accélérer le développement des applications multiplates-formes...

Structuration de code

1. Le plugin Gradle

JetBrains fournit le plugin Gradle org.jetbrains.kotlin.multiplatform pour créer et gérer un projet utilisant l’architecture de Kotlin Multiplatform.

Pour intégrer le plugin dans un projet Kotlin, il suffit d’appliquer le plugin comme suit :

plugins { 
    kotlin("multiplatform") version "1.9.22" 
}

Ce plugin Gradle définit le bloc de configuration kotlin :

kotlin { 
 
}

Ce bloc permet de configurer les plates-formes de compilation cibles, par exemple la plate-forme macOS pour les processeurs 64 bits :

kotlin { 
    macosX64() 
}

Le plugin permet de définir plusieurs plates-formes cibles et même de choisir la JVM en tant que plate-forme :

kotlin { 
    jvm() 
    macosX64() 
    linuxArm64() 
    linuxX64() 
}

Aujourd’hui, il n’existe pas encore un plugin Maven équivalent.

2. Structure du projet

Le plugin Gradle de Kotlin Multiplatform se base sur le nom des dossiers de code principaux pour différencier le code commun partagé du code spécifique à chaque plate-forme. Prenons l’exemple d’un projet KMP ciblant la plate-forme JVM ainsi que la plate-forme Linux 64 bits. Le dossier source src d’un module de ce projet est composé des dossiers suivants :

commonMain : ce dossier contient le code partagé entre les différentes plates-formes. Ce code peut utiliser la librairie standard Kotlin ainsi que toutes les autres librairies compatibles avec les plates-formes cibles du projet. Le code déclaré dans ce dossier ne peut pas utiliser d’API spécifiques à une seule plate-forme.
jvmMain : ce dossier contient le code spécifique à la JVM. Ce code peut utiliser la librairie standard Java et toutes les librairies de l’écosystème Java, comme Spring par exemple.
linuxX64Main : ce dossier contient le code spécifique à la plate-forme Linux pour les processeurs de l’architecture 64 bits.

En plus de la structure précédente, le plugin Gradle de KMP définit un mécanisme de hiérarchie entre les différents dossiers des codes sources. Le code défini dans le dossier commonMain est accessible directement par le code défini dans l’un des dossiers spécifiques à chaque plate-forme. Dans l’exemple précédent, le code inclus dans jvmMain peut accéder au code déclaré dans le dossier commonMain.

Il est possible d’utiliser un dossier parent pour regrouper le code commun à certaines plates-formes, par exemple :

nativeMain : ce dossier contient le code partagé entre toutes les plates-formes natives (iOS, Linux...). Android n’est pas inclus car il se base sur la JVM....

Développement frontend avec Kotlin/JS

Kotlin/JS se base sur le même principe que le langage TypeScript. Le compilateur transforme le code Kotlin en un code écrit en JavaScript. Cette opération est appelée une « compilation source à source » ou bien une « transcompilation ». Actuellement, le code JavaScript généré par le compilateur Kotlin/JS est compatible avec la version ES5 de la spécification du langage JavaScript.

Il existe plusieurs frameworks Kotlin permettant de développer les pages web en utilisant la technologie Kotlin/JS. Parmi ces frameworks, on trouve KVision, écrit complètement en Kotlin. Il est toutefois possible d’utiliser les frameworks classiques de l’écosystème JavaScript comme les frameworks React et Redux. Afin de simplifier cette intégration, JetBrains fournit une librairie de modules appelés wrappers pour une partie des frameworks JavaScript. Ces modules cachent la complexité liée à l’utilisation du code JavaScript directement depuis Kotlin.

1. Création et configuration d’un projet Kotlin/JS

La technologie Kotlin/JS est basée sur l’architecture Kotlin Multiplatform. La configuration d’un projet utilisant Kotlin/JS est similaire aux configurations ciblant les autres plates-formes et utilise le même plugin Gradle :

plugins { 
    kotlin("multiplatform") version "1.9.22" 
}

La configuration pour ajouter la plate-forme JavaScript est la suivante :

kotlin { 
    js { 
        binaries.executable() 
        browser() 
    } 
}

L’instruction binaries.executable demande au compilateur de générer le fichier JavaScript de l’application. Ce dernier n’est pas généré par défaut au moment de la compilation. La méthode browser permet de générer une application web JavaScript pouvant être exécutée par le navigateur. Kotlin/JS permet aussi de créer des applications JavaScript pour NodeJS.

Une fois le plugin configuré, il est nécessaire d’ajouter le fichier HTML qui représentera la page web au niveau des ressources de l’application (src/jsMain/resources) :

<!DOCTYPE html> 
<html lang="en"> 
<head> 
    <meta charset="UTF-8"> 
    <title>My Kotlin/JS App</title> 
</head> 
<body> 
<script src="kotlinBook.js"></script> 
</body> 
</html>

Dans l’exemple précédent, le code HTML référence le script JavaScript du projet. Ce dernier a un nom qui correspond au nom du projet Gradle suivi de l’extension .js :

<script src="kotlinBook.js"></script>

Le point d’entrée de l’application est la fonction main qui peut être déclarée dans un package de l’application. Par exemple :

package fr.eni.kotlinstack.js 
 
fun main() { 
    console.log("Hello from Kotlin/JS!") 
}

Le code précédent utilise la méthode log de l’objet console pour afficher un message dans la console visible depuis les outils de développement du navigateur web.

La structure du code source du projet est la suivante :

Comme pour le développement en JavaScript, Kotlin/JS permet de compiler le projet à la volée et de rendre visibles les changements du code directement après la sauvegarde des fichiers modifiés. Cette opération est possible grâce à la commande Gradle suivante :

gradlew jsRun --continuous

La commande précédente démarre un serveur web de développement et transpile le code Kotlin en JavaScript à chaque modification de code. L’application web est accessible par défaut via le port 8080 :

Kotlin/JS...