Composing Magic

MVI with Kotlin Flow & Jetpack Compose

Next -> Next -> Modern Android Architecture

Kotlin StateFlow

Kotlin StateFlow

MVI

Compose

Kotlin Flow

Suspend

ViewState

Coroutines

Suspend

Coil

Model View Intent http://hannesdorfmann.com/android/model-view-intent

RxJava

“Use RxJava scan() to apply reduce() to the previous state of app and return the new state.”

MVI http://hannesdorfmann.com/android/mosby3-mvi-1

MVVM

​

​

​

​

ViewModel

View

​

UI Event

​

UI Event

​

UI Event

​

State

Repo

Logic

​

Room DB

Data Binding to update UI

Full post here: https://danlowe.me/post/2019-08-15-mvi/

MVI

View/Activity

​

UI Event

​

UI Event

​

UI Event

​

​

​

​

New State

​

​

Reducer

Accumulator / Actor

Room DB

New ViewState to Update UI

​

​

​

​

ViewModel

Intents

Render

Listening (V)

Rendering (V)

Business Logic (M)

MVI_Lite Flow with LiveData https://proandroiddev.com/android-unidirectional-state-flow-without-rx-596f2f7637bb

Kotlin (State/Shared)Flow https://quickbirdstudios.com/blog/android-mvi-kotlin-coroutines-flow/

Kotlin Channels https://proandroiddev.com/kotlin-coroutines-channels-csp-android-db441400965f

You can think of a channel as a pipe between two coroutines. That pipe facilitates the transfer of information between those two coroutines. One coroutine can send information on that pipe. The other coroutine will wait to receive the information. This concept of communication between coroutines is different than threads.

Do not communicate by sharing memory; instead, share state by communicating.

​

​

Hot Steam vs Cold Stream

Data

Data

Data

Channel - HOT Streams

Flow - COLD Streams

Data Steam

Data Steam

1. Where is Data
2. How many receivers
3. Laziness

Hot Stream (Kotlin Channel) vs Cold Stream (Kotlin Flow) https://www.stefandouma.nl/reactor-hot-stream-vs-cold-stream/

A radio channel is a hot stream.

• One running channel for all listeners
• The stream continues to run if there are no listeners
• The data the subscriber receives depends on the moment the subscriber subscribes

​

A CD is a cold stream

• One new instance of a channel per listener
• Stream instance is stopped when user disconnects
• Data is initiated from the beginning for every subscribe

​

Flow - Cold Stream - No Synchronization

• The data source is inactive before and after being used.
• Don’t need concurrency or synchronization

Just like a sequence, a flow represents a cold stream of sequential values - ‘asynchronous data streams’.

​

Channels - Hot Stream - Needs Synchronization

• The data source always exists.
• Hot streams great synchronization

Channels are a great fit to model data sources that are intrinsically hot, data sources that exist without application’s requests for them: incoming network connections, event streams, etc.

Channels are not scoped to a specific lifecycle like Flow. A Channel survives across screens and lifecycles!

The (MV) Intent Channel

Kotlin StateFlow to ShardFlow

• Synchronous (rendezvous) flow-based event listeners (emit event, suspend until all listeners process it, see #1901).
• Replay & buffering of last events (important for non-suspend context, buffer cushions fast producers, see #1761).
• Advanced state sharing (custom conflation, no initial value, etc. see comments in #1973).
• Get access to “the current cache snapshot” which for non-live display purposes (confirmation dialog window), etc.
• Custom “upstream” connection logic by tracking the number of active collectors (see discussion in #1086).

Introduce SharedFlow #2034 https://github.com/Kotlin/kotlinx.coroutines/issues/2034

• There is a need to have a Flow implementation that is hot and shares emitted values among all collectors that subscribe to it.
• Its design generalizes StateFlow beyond the narrow set of use-case it supports (see #1973).
• It will replace all sorts of BroadcastChannel implementations and serves as a basis for the design of shareIn operator.
• The simplest version of sharing operator builds a combination of a SharedFlow that downstream collects from and an upstream flow that emits into this SharedFlow. See #2047 for details on sharing operators.

​

Transforming Android Arch Components

Review of App.

Activity/XML to Compose (MainComposeUI.kt)

UI Modifiers

Jetpack Compose

SwiftUI

UI Constraints (Motion Editor) (AddWordComposeUI.kt)

Nav is just Flipp’n Screens (MainActivity.kt)

Set Fun{} on Interactive UI

doSomething = f{}

LiveData to Kotlin Flow (WordDao.kt)

Dagger to Dagger Hilt (StateModule.kt)

Coil (MainComposeUI)

StateFlow/SharedFlow/?Flow (RxJava)

Android 11 and beyond https://www.youtube.com/watch?v=NMFGuy6TRqk

iOS & Combine Framework https://www.youtube.com/watch?v=4GjXq2Sr55Q&feature=youtu.be iOS CS 193P @ Stanford

Questions

-- @Biocodes --