Résumé des bons points et des précautions lors de la conversion de l'application Java Android vers Kotlin

introduction

Effectuez une conversion régulière pendant les 10 jours fériés consécutifs J'ai créé ma propre application Java Android (environ 300 fichiers) en Kotlin complet.

↓ Diagramme Kotlin 100%

Kolin First a été annoncé lors de Google I / O 2019, qui s'est tenu juste après le 10e jour férié consécutif. Je vais avoir plus d'opportunités de convertir de Java à Kotlin, je vais donc résumer ce sur quoi je suis tombé et comment l'éviter.

L'environnement est Android Studio 3.4.

Méthode de conversion

Je suis sûr que vous ferez tout cela à la main, mais Android Studio fournit des commandes de conversion. "Menu> Code> Convertir un fichier Java en fichier Kotlin" Le raccourci est "Maj + Option + Commande + k".

Remarques sur la commande de conversion Kotlin

commentaire

Les commentaires ont parfois gêné la conversion. La partie commentée reste Java après la conversion Kotlin. Kotlin exige également que vous ayez le même nombre de / * pour ouvrir les commentaires et * / pour fermer les commentaires.

[Échantillon avant conversion]

[Échantillon après conversion]

--La partie commentaire reste Java

• Erreur de construction du nombre insuffisant de commentaires fermés

Nullable / NonNull est ambigu

Kotlin est une spécification de langage NullSafe, donc si Nullable / NonNull est ambigu du côté Java, Il est traité comme un type de plate-forme (un type qui peut être Nullable ou NonNull). Il est plus sûr de le traiter comme Nullable sauf si NonNull est déterministe.

Le code qui a réellement causé une erreur d'exécution est ci-dessous. Ceux avec ! Après la variable sont de type plateforme et peuvent être traités comme NonNull dans le code. Au moment de l'exécution, Null peut arriver et une erreur peut se produire.

Une fois qu'il est traité comme Nullable et early return etc., il peut être traité comme NonNull à partir de la ligne suivante.

Lors de la définition d'une sous-classe d'une classe définie en Java dans Kotlin

Pour Nullable / NonNull, lors de l'utilisation de la commande de conversion Kotlin, En particulier, les exceptions suivantes étaient susceptibles de se produire.

Caused by: java.lang.IllegalArgumentException: Parameter specified as non-null is null: 

Il s'agit d'une exception qui se produit lorsque la superclasse est Java et la sous-classe est Kotlin et que les valeurs non nulles et nulles sont mal gérées. Par exemple, une exception se produira dans les cas suivants qui héritent d'AppCompatActivity. Il s'agit d'une erreur d'exécution, le code peut donc être généré avec succès.

class MainActivity : AppCompatActivity() {
:
    override fun onCreate(savedInstanceState: Bundle) {
        super.onCreate(savedInstanceState)
        :

Le code correct doit avoir Bundle? Comme type d'argument, comme indiqué ci-dessous.

class MainActivity : AppCompatActivity() {
:
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        :

C'est difficile à trouver sans lire le code du côté des superclasses. Quand je lis le code réel, le Bundle a l'annotation @ Nullable. Vous pouvez voir que Bundle? Est correct au lieu de Bundle.

androidx-appcompat:[email protected]

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        final AppCompatDelegate delegate = getDelegate();
        delegate.installViewFactory();
        delegate.onCreate(savedInstanceState);

Bons points à faire avant la conversion de Kotlin

Sur la base des précautions ci-dessus, voici certaines choses que vous devez faire avant la conversion.

Lisez la documentation sur la conversion Kotlin

Les officiels de Kotlin et d'Android ont tous deux une documentation sur l'interopérabilité avec Java.

• https://kotlinlang.org/docs/reference/java-interop.html
• https://developer.android.com/kotlin/interop

Tirer parti des annotations NonNull

Il vaut mieux distinguer NonNull autant que possible au moment de Java. Selon la documentation Kotlin, les annotations suivantes sont prises en charge.

https://kotlinlang.org/docs/reference/java-interop.html

JetBrains (@Nullable and @NotNull from the org.jetbrains.annotations package) Android (com.android.annotations and android.support.annotations) JSR-305 (javax.annotation, more details below) FindBugs (edu.umd.cs.findbugs.annotations) Eclipse (org.eclipse.jdt.annotation) Lombok (lombok.NonNull).

Compatible avec Android X

Si vous utilisez l'ancienne bibliothèque de support, il est préférable de convertir après la migration vers Android X. Android X a moins de risque de conversion vers Kotlin car NonNull et Nullable sont clairement discriminés. Vous trouverez ci-dessous une comparaison du code Java pour RecyclerView.

Ancienne bibliothèque de support RecyclerView https://android.googlesource.com/platform/frameworks/support/+/121ba96/v7/recyclerview/src/android/support/v7/widget/RecyclerView.java#5143

        public abstract VH onCreateViewHolder(ViewGroup parent, int viewType);

RecyclerView dans la bibliothèque AndroidX https://android.googlesource.com/platform/frameworks/support/+/refs/heads/androidx-master-dev/recyclerview/recyclerview/src/main/java/androidx/recyclerview/widget/RecyclerView.java#6888

        @NonNull
        public abstract VH onCreateViewHolder(@NonNull ViewGroup parent, int viewType);

Fonctionnement garanti par test unitaire

Si vous ajoutez un test unitaire au moment de Java, il est facile de vérifier le fonctionnement après la conversion Kotlin. Il est recommandé d'ajouter un test unitaire car c'est le minimum.

Profitez de Lint

Si vous recherchez "interopérabilité" dans Editer> Inspection, la charpie du système interopérable qui peut être utilisé pour la conversion Kotlin sera affichée. Si coché, le code dangereux sera averti avant et après la conversion.

https://developer.android.com/kotlin/interop#lint_checks https://developer.android.com/studio/write/lint?hl=ja

Évitez les noms de variables de mots réservés Kotlin

Les mots réservés Kotlin tels que is, object, when, et get, set, etc. utilisés dans le code Java interne doivent être renommés à l'avance. Même Kotlin peut être utilisé en le mettant entre guillemets, mais il vaut mieux l'éviter.

Bons points à faire après la conversion de Kotlin

Le code Kotlin généré par la commande de conversion Kotlin est difficile à dire qu'il utilise Kotlin. À tout le moins, voici comment le rendre sûr dans une certaine mesure sans avertissement.

Considérez une méthode de dépliage de type Nullable

Le code après la commande de conversion utilise essentiellement !! pour le dérouler en NonNull. Demandez-vous si vous pouvez déballer en toute sécurité avec ? . etc.

Exemple de code immédiatement après la conversion Kotlin

    var webView: WebView? = null

    fun load() {
        if (webView != null) {
            webView!!.load()
        }
        :

Exemple d'utilisation de «?.»

    var webView: WebView? = null

    fun load() {
        webView?.load()
        :

Déterminez si la gestion de var est appropriée

Déterminez si les propriétés Nullable peuvent être utilisées, telles que «lateinit» et «by lazy». Si vous voulez initialiser autrement que ʻinit comme ʻActivity # onCreate lié à View, vous pouvez utiliser lateinit pour le gérer comme une propriété de NonNull.

    private var mRecyclerView: RecyclerView? = null

    override fun onCreate(savedInstanceState: Bundle?) {
    :
        mRecyclerView = findViewById(R.id.recycler_view)

    private lateinit var mRecyclerView: RecyclerView

    override fun onCreate(savedInstanceState: Bundle?) {
    :
        mRecyclerView = findViewById(R.id.recycler_view)

Considérez si la constante val peut être une const val

En Java, les constantes finales statiques sont traitées comme val dans le code après la commande de conversion Kotlin. Considérez si cela peut être un const val (généralement, si vous suivez Lint, vous ajouterez const)

    companion object {
        private val TAG = "MainActivity"

    companion object {
        private const val TAG = "MainActivity"

Utilisez Firebase Robo Test pour la finition

Après la conversion, même si vous pensez avoir écrit le code de test correctement, il peut y avoir des bogues qui dépassent vos attentes. Vous pouvez éviter cela en demandant à un tiers ou à Robo de le tester. Il existe plus de types tels que Nullable / NonNull / Platform, et d'autres états tels que lateinit avant l'initialisation. Nous vous recommandons d'utiliser le test Firebase Robo pour éviter les «erreurs involontaires».

Impressions de 100% Kotlin

Kotlin lui-même est rafraîchissant, mais des erreurs ont tendance à se produire lors du pontage de Kotlin ⇔ Java. C'est une route assez épineuse, il est donc préférable d'en faire un code Java sûr à l'avance. Une fois converti, vous pouvez utiliser des fonctions utiles telles que Coroutine et des fonctions d'extension pour changer votre vie.