Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Kotlin 1.4.0-RC est disponible. Cette version permet de faire de la bibliothèque standard une dépendance par défaut
Et permet d'obtenir de meilleurs rapports d'erreurs

Le , par Stéphane le calme

7PARTAGES

10  0 
JetBrains a annoncé la disponibilité de Kotlin 1.4.0-RC, la Release Candidate de sa prochaine version majeure du langage de programmation.

Prise en charge EDI améliorée de *.gradle.kts

JetBrains a considérablement amélioré la prise en charge EDI des scripts Gradle Kotlin DSL (fichiers *.gradle.kts) dans Kotlin 1.3.70, et l'éditeur a continué sur cette lancée dans Kotlin 1.4.0-RC. Voici ce que cette nouvelle version apporte :

Chargement de la configuration du script explicitement pour de meilleures performances

Auparavant, lorsque vous ajoutiez un nouveau plugin au bloc buildscript ou plugins de votre build.gradle.kts, la nouvelle configuration de script était chargée automatiquement en arrière-plan. Ensuite, après son application, vous pouvez utiliser l'assistance de code pour le plugin nouvellement ajouté.

Pour améliorer les performances, l'éditeur a supprimé ce comportement automatique consistant à appliquer des modifications à la configuration du script lors de la saisie. À partir de Gradle 6.0 et des versions plus récentes, vous devez appliquer explicitement les modifications aux configurations en cliquant sur Charger les modifications Gradle ou en réimportant le projet Gradle.

Dans les versions antérieures de Gradle, vous devez charger manuellement la configuration du script en cliquant sur Charger la configuration dans l'éditeur.

JetBrains a ajouté une autre action dans IntelliJ IDEA 2020.1 avec Gradle 6.0+, Charger les configurations de script, qui charge les modifications des configurations de script sans mettre à jour l'ensemble du projet. Cela prend beaucoup moins de temps que de réimporter l'ensemble du projet.

Meilleurs rapports d'erreurs

Auparavant, vous ne pouviez voir les erreurs du Gradle Daemon (un processus qui s'exécute en arrière-plan et est responsable de toutes les tâches et activités liées à Gradle) que dans des fichiers journaux séparés. Désormais, à partir de Gradle 6.0 ou des versions plus récentes, Gradle Daemon renvoie directement toutes les informations sur les erreurs et les affiche dans la fenêtre de l'outil de création. Cela vous fait gagner du temps et des efforts.


Moins de boilerplate dans la configuration de votre projet

Avec les améliorations apportées au plugin Kotlin Gradle, vous pouvez écrire moins de code dans vos fichiers de construction Gradle : l'un des scénarios les plus courants est désormais activé par défaut.

Faire de la bibliothèque standard une dépendance par défaut

Une écrasante majorité de projets nécessitent la bibliothèque standard Kotlin. À partir de la version 1.4.0-RC, vous n'avez plus besoin de déclarer manuellement une dépendance sur stdlib dans chaque ensemble de sources - elle sera désormais ajoutée par défaut. La version ajoutée automatiquement de la bibliothèque standard sera la même que la version du plugin Kotlin Gradle, car ils ont le même contrôle de version.

Voici à quoi ressemblait une configuration de projet multiplateforme typique avec des cibles Android, iOS et JavaScript avant la version 1.4:

Code Kotlin : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
android()
ios()
js()
 
sourceSets {
    commonMain {
        dependencies {
            implementation("org.jetbrains.kotlin:kotlin-stdlib-common")
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-common:1.3.6")
        }
    }
 
    androidMain {
        dependencies {
            implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.6")
        }
    }
 
    jsMain {
        dependencies {
            implementation("org.jetbrains.kotlin:kotlin-stdlib-js")
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-js:1.3.6")
        }
    }
 
    iosMain {
        dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core-native:1.3.6")
        }
    }
}
Désormais, vous n'avez plus du tout besoin de déclarer explicitement une dépendance à la bibliothèque standard, et avec la prise en charge de la structure de projet hiérarchique, annoncée dans la version 1.4-M2, vous ne devez spécifier d'autres dépendances qu'une seule fois. Ainsi, votre fichier de construction Gradle deviendra beaucoup plus concis et facile à lire:

Code Kotlin : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
android()
ios()
js()
 
sourceSets {
    commonMain {
        dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.6")
        }
    }
}

Pour les ensembles de sources de plateforme et les ensembles de sources partagés en backend, la bibliothèque standard correspondante sera ajoutée, tandis qu'une bibliothèque standard commune sera ajoutée au reste. Le plugin Kotlin Gradle sélectionnera la bibliothèque standard JVM appropriée en fonction du paramètre kotlinOptions.jvmTarget.

Si vous déclarez explicitement une dépendance de bibliothèque standard (par exemple, si vous avez besoin d'une version différente), le plugin Kotlin Gradle ne la remplacera pas et n'ajoutera pas une deuxième bibliothèque standard. Et si vous n'avez pas du tout besoin d'une bibliothèque standard, vous pouvez ajouter l'indicateur de désactivation aux propriétés Gradle:

Code Kotlin : Sélectionner tout
kotlin.stdlib.default.dependency=false

Kotlin / Native

Gestion simplifiée des dépendances CocoaPods

Auparavant, une fois que vous intégriez votre projet avec le gestionnaire de dépendances CocoaPods, vous pouviez créer une partie iOS, macOS, watchOS ou tvOS de votre projet uniquement dans Xcode, distincte des autres parties de votre projet multiplateforme. Ces autres pièces pouvaient être générées dans IntelliJ IDEA.

De plus, chaque fois que vous ajoutiez une dépendance à une bibliothèque Objective-C stockée dans CocoaPods (bibliothèque Pod), vous deviez passer d'IntelliJ IDEA à Xcode, lancer la tâche pod install et y exécuter la build Xcode.

Vous pouvez désormais gérer les dépendances de pod directement dans IntelliJ IDEA tout en profitant des avantages qu'il offre pour travailler avec le code, tels que la mise en évidence et la complétion de code. Vous pouvez également créer l'ensemble du projet Kotlin avec Gradle, sans avoir à passer à Xcode. Cela signifie que vous ne devez accéder à Xcode que lorsque vous devez écrire du code Swift / Objective-C ou exécuter votre application sur un simulateur ou un appareil.

Vous pouvez désormais également travailler avec des bibliothèques de pods stockées localement.

Selon vos besoins, vous pouvez ajouter des dépendances entre:
  • Un projet Kotlin et des bibliothèques de pod du référentiel CocoaPods.
  • Un projet Kotlin et des bibliothèques Pod stockées localement.
  • Un Kotlin Pod (projet Kotlin utilisé comme dépendance CocoaPods) et un projet Xcode avec une ou plusieurs cibles.

Terminez la configuration initiale et lorsque vous ajoutez une nouvelle dépendance à CocoaPods, réimportez simplement le projet dans IntelliJ IDEA. La nouvelle dépendance sera ajoutée automatiquement. Aucune étape supplémentaire n'est requise.

Générer des fichiers .dSYM sur les cibles Apple par défaut

Le débogage d'un plantage d'application iOS implique parfois l'analyse des rapports d'incident, et les rapports d'incident nécessitent généralement une symbolisation pour devenir correctement lisibles. Pour symboliser les adresses dans Kotlin, le bundle .dSYM pour le code Kotlin est requis. À partir de la version 1.4-M3, le compilateur Kotlin / Native produit par défaut des .dSYM pour les binaires de version sur les plateformes Darwin. Cela peut être désactivé avec l'indicateur -Xadd-light-debug = disable du compilateur. Sur les autres plateformes, cette option est désactivée par défaut. Pour basculer cette option dans Gradle, utilisez:

Code Kotlin : Sélectionner tout
1
2
3
4
5
6
7
kotlin {
    targets.withType<org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget> {
        binaries.all {
            freeCompilerArgs += "-Xadd-light-debug={enable|disable}"
        }
    }
}

Kotlin 1.4.0-RC est également livré avec de nouvelles fonctionnalités pour déboguer les coroutines et définir des fonctions récursives profondes

Source : JetBrains

Une erreur dans cette actualité ? Signalez-le nous !