ReactiveState Kotlin

Reactivestate para Kotlin Multiplatform e Android

Gerenciamento de estado reativo fácil e modelos de visualização para multiplataforma de Kotlin. Sem caldeira. Compatível com Android.

Reactivestate-Kotlin fornece essas fundações para a construção de modelos de visualização multiplataforma e lógica de nível inferior:

• Programação reativa: tudo é recalculado/atualizado automaticamente com base no código direto
• Programação orientada à demanda: cálculos e valores que consomem recursos são alocados sob demanda e descartados quando não é necessário
• Multiplataforma: Compartilhe seus modelos ViewModels e Reactive State Location entre todas as plataformas
• Manuseio de eventos: eventos simples baseados em interfaces (mais composáveis ​​e menos caldeiras do que as classes seladas)
• Erro automático Catching: Não há mais esquecimento de try-capath ou copiar erros de manuseio lógica em todo o lugar
• Testes de unidade baseados em coroutine: não se preocupe mais em passar por contornar CoroutineDispatcher s em todos os lugares
• Manuseio do ciclo de vida
• Restauração do Estado

Consulte a documentação do ReAciVestate para obter mais detalhes.

Plataformas suportadas

Android, JVM, iOS, TvOS, WatchOS, Macosarm64, Macosx64, Mingwx64, Linuxx64

Instalação

Adicione o pacote às suas dependências 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
}

Além disso, verifique se você integrou o repositório central do Maven, por exemplo, em sua build.gradle de raiz.gradle:

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

Introdução rápida

Os dois princípios a seguir estão aqui para dar uma idéia rápida do aspecto de programação reativo apenas. A seção "Guia" na documentação descreve como trabalhar com os aspectos mais avançados, como vistas multiplataformas, manuseio do ciclo de vida, etc.

Nota: Embora a discussão seja sobre StateFlow , você também pode usar LiveData ou até mesmo implementar extensões para outros valores observáveis.

Observando o fluxo de estado

Imagine que você tem um formulário de entrada com o primeiro e o sobrenome e deseja observar dois valores StateFlow ao mesmo tempo:

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

É assim que você faria isso usando a função autoRun :

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

Com get(isFirstNameValid) você recupera isFirstNameValid.value e, ao mesmo tempo, diz autoRun para reexecionar o bloco sempre que o valor for alterado. Esse código é semelhante a escrever isto:

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)
            }
        }
}

Fluxo de Estado reativo / dados reativos

O mesmo princípio pode ser usado para criar um StateFlow reativo e derived :

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

Agora você pode usar autoRun { submitButton.isEnabled = get(isFormValid) } no restante do seu código.

Indo ainda mais longe, o próprio isFirstNameValid geralmente também seria o resultado de um cálculo derived . Portanto, você pode ter várias camadas de StateFlow derived reativo.

Relação com Jetpack Compor / Flutter / React

Estruturas de interface reativa de interface do usuário como o JetPack Compõe a reconstrução automaticamente a interface do usuário sempre que um StateFlow muda. Portanto, na camada da interface do usuário, autoRun geralmente pode ser substituído por um Composable .

No entanto, abaixo da interface do usuário, seus dados ainda precisam ser reativos também. Aqui o ReactiveState fornece derived para recomputar automaticamente um StateFlow com base em outros fluxos StateFlow . Esse padrão é muito útil na prática e fornece a base perfeita para estruturas como o JetPack Compõe, que se concentram principalmente no aspecto da interface do usuário. derived e autoRun do ReativeState fornecem a mesma reatividade para seus dados e lógica de negócios.

No Jetpack, você compõe derivedStateOf o que é muito semelhante ao derived . Portanto, você pode escolher se deseja construir sua lógica de negócios com base na biblioteca oficial do Coroutines ( StateFlow / derived ) ou na composição do JetPack ( State / derivedStateOf ). No entanto, a Biblioteca Coroutines tem a vantagem de estar disponível para mais plataformas e é totalmente independente de qualquer estrutura de interface do usuário. Finalmente, a maioria das bibliotecas não de código aberto provavelmente será baseado em coroutinas, portanto, o código baseado em StateFlow também pode ser melhor para a compatibilidade/interoperabilidade.

Em outras palavras, a combinação de ambas as soluções usadas juntas resulta em uma base de código multiplataforma totalmente reativa - o que melhora a simplicidade do código e evita muitos bugs.

Além disso, o JetPack Compose atualmente não fornece suporte para ViewModel multiplataforma ou qualquer arquitetura em larga escala. Portanto, esta biblioteca resolve isso, fornecendo BaseReactiveState para o ViewModels. Ele também vem com um sistema de eventos com reconhecimento de ciclo de vida ( eventNotifier ) ​​e um manuseio de estado de carregamento (para que você possa rastrear um ou vários indicadores de carregamento diferentes com base nas coroutinas que você inicia).

Veja também

Esta biblioteca é baseada no Reacativo_state para Flutter e adaptada aos padrões multiplataforma e Android Kotlin.

Licença

 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.