ReactiveState Kotlin

ReactiveState pour Kotlin Multiplateform et Android

Gestion réactive de l'état facile et ViewModels pour Kotlin Multiplateform. Pas de passe-partout. Compatible avec Android.

ReactiveState-Kotlin fournit ces fondations pour construire des modélins de vue multiplateforme et une logique de niveau inférieur:

• Programmation réactive: tout est récomputé / mis à jour automatiquement en fonction d'un code simple
• Programmation axée sur la demande: les calculs et les valeurs consommateurs de ressources sont alloués à la demande et disposés lorsqu'ils ne sont pas nécessaires
• MultipLaTform: partagez vos anciens de vue et la logique de gestion de l'état réactif entre toutes les plates-formes
• Gestion des événements: événements simples basés sur les interfaces (plus composables et moins chauffants que les classes scellées)
• Catche d'erreur automatique: plus de logique de traitement des erreurs d'erreur ou plus oubliée
• Tests unitaires basés sur Coroutine: ne vous inquiétez pas de faire le passage de CoroutineDispatcher S partout
• Gestion du cycle de vie
• Restauration de l'État

Voir la documentation ReactiveState pour plus de détails.

Plates-formes prises en charge

Android, JVM, iOS, TVOS, Watchos, MacOsarm64, MacOSX64, MingWX64, Linuxx64

Installation

Ajoutez le package à vos dépendances de build.gradle dependencies {} :

dependencies {
    // Add the BOM using the desired ReactiveState version
    api platform( " com.ensody.reactivestate:reactivestate-bom:VERSION " )

    // Leave out the version number from now on:
    implementation " com.ensody.reactivestate:reactivestate "

    // Utils for unit tests that want to use coroutines
    implementation " com.ensody.reactivestate:reactivestate-test "
    // Note: kotlin-coroutines-test only supports the "jvm" target,
    // so reactivestate-test has the same limitation
}

Assurez-vous également que vous avez intégré le Maven Central Repo, par exemple dans votre root build.gradle :

subprojects {
    repositories {
        // ...
        mavenCentral()
        // ...
    }
}

Intro rapide

Les deux principes suivants sont là pour vous donner une idée rapide de l'aspect de programmation réactive uniquement. La section "Guide" de la documentation décrit comment travailler avec les aspects les plus avancés comme les modéliers de vue multiplateforme, la gestion du cycle de vie, etc.

Remarque: Bien que la discussion porte sur StateFlow , vous pouvez également utiliser LiveData ou même implémenter des extensions pour d'autres valeurs observables.

Observer le flux d'État

Imaginez que vous avez un formulaire d'entrée avec le premier et le nom de famille et que vous souhaitez observer deux valeurs StateFlow en même temps:

• isFirstNameValid: StateFlow<Boolean>
• isLastNameValid: StateFlow<Boolean>

C'est ainsi que vous le feriez en utilisant la fonction autoRun :

autoRun {
    submitButton.isEnabled = get(isFirstNameValid) && get(isLastNameValid)
}

Avec get(isFirstNameValid) vous récupérez isFirstNameValid.value et en même temps, dites à autoRun de réexécuter le bloc chaque fois que la valeur est modifiée. Ce code est similaire à l'écriture ceci:

lifecycleScope.launchWhenStarted {
    isFirstNameValid
        .combine(isLastNameValid) { firstNameValid, lastNameValid ->
            firstNameValid to lastNameValid
        }
        .conflate()
        .collect { (firstNameValid, lastNameValid) ->
            try {
                submitButton.isEnabled = firstNameValid && lastNameValid
            } catch (e : CancellationException ) {
                throw e
            } catch (e : Throwable ) {
                onError(e)
            }
        }
}

Données réactives du flux d'état / réactive

Le même principe peut être utilisé pour créer un StateFlow derived :

 val isFormValid : StateFlow < Boolean > = derived {
    get(isFirstNameValid) && get(isLastNameValid)
}

Vous pouvez maintenant utiliser autoRun { submitButton.isEnabled = get(isFormValid) } dans le reste de votre code.

En allant encore plus loin, isFirstNameValid lui-même serait généralement le résultat d'un calcul derived . Ainsi, vous pouvez avoir plusieurs couches de StateFlow derived réactifs.

Relation avec Jetpack Compose / Flutter / React

Les cadres d'interface utilisateur réactifs comme Jetpack Compose reconstruisent automatiquement l'interface utilisateur chaque fois qu'un StateFlow change. Ainsi, dans la couche d'interface utilisateur, autoRun peut généralement être remplacé par un Composable .

Cependant, en dessous de l'interface utilisateur, vos données doivent également être réactives. Ici, ReactiveState fournit derived pour recomputer automatiquement un StateFlow basé sur d'autres StateFlow . Ce modèle est très utile dans la pratique et fournit le fondement parfait pour les cadres comme Jetpack Compose qui se concentrent principalement sur l'aspect interface utilisateur. derived et autoRun de ReactiveState offrent la même réactivité pour vos données et votre logique métier.

Dans Jetpack, vous avez même derivedStateOf qui est très similaire à derived . Ainsi, vous pouvez choisir si vous souhaitez créer votre logique commerciale en fonction de la bibliothèque Coroutines officielle ( StateFlow / derived ) ou Jetpack Compose ( State / derivedStateOf ). Cependant, la bibliothèque Coroutines a l'avantage qu'elle est disponible pour plus de plates-formes et qu'elle est entièrement indépendante de tous les cadres d'interface utilisateur. Enfin, la plupart des bibliothèques non-UI open source seront probablement basées sur les coroutines, de sorte que le code basé sur StateFlow pourrait également être meilleur pour la compatibilité / interopérabilité.

En d'autres termes, la combinaison des deux solutions utilisées ensemble se traduit par une base de code multiplateforme entièrement réactive - qui améliore la simplicité du code et évite de nombreux bogues.

De plus, Jetpack Compose ne fournit actuellement aucun support ViewModel multiplateforme ni toute architecture à grande échelle. Ainsi, cette bibliothèque résout cela en fournissant BaseReactiveState pour ViewModels. Il est également livré avec un système d'événements de LifeCycle-Aware ( eventNotifier ) ​​et une manipulation d'état de chargement (afin que vous puissiez suivre un ou plusieurs indicateurs de chargement différents en fonction des coroutines que vous lancez).

Voir aussi

Cette bibliothèque est basée sur Reactive_State pour Flutter et adapté aux modèles Kotlin Multiplateform et Android.

Licence

 Copyright 2024 Ensody GmbH, Waldemar Kornewald

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.