Migrate Login to new architecture and make some adjustments

libraries/architecture/src/main/java/io/element/android/x/architecture/Async.kt

@@ -0,0 +1,31 @@
+package io.element.android.x.architecture
+
+import androidx.compose.runtime.MutableState
+
+sealed interface Async<out T> {
+    object Uninitialized : Async<Nothing>
+    data class Loading<out T>(val prevState: T? = null) : Async<T>
+    data class Failure<out T>(val error: Throwable) : Async<T>
+    data class Success<out T>(val state: T) : Async<T>
+}
+
+suspend fun <T> (suspend () -> T).execute(state: MutableState<Async<T>>) {
+    try {
+        state.value = Async.Loading()
+        state.value = Async.Success(this())
+    } catch (error: Throwable) {
+        state.value = Async.Failure(error)
+    }
+}
+
+suspend fun <T> (suspend () -> Result<T>).executeResult(state: MutableState<Async<T>>) {
+    state.value = Async.Loading()
+    this().fold(
+        onSuccess = {
+            state.value = Async.Success(it)
+        },
+        onFailure = {
+            state.value = Async.Failure(it)
+        }
+    )
+}

libraries/architecture/src/main/java/io/element/android/x/architecture/PresenterConnector.kt

@@ -8,21 +8,22 @@ import app.cash.molecule.launchMolecule
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
 
-inline fun <reified State, reified Event> LifecycleOwner.presenterConnector(presenter: Presenter<State, Event>): Lazy<LifecyclePresenterConnector<State, Event>> = lazy {
+inline fun <reified State, reified Event> LifecycleOwner.presenterConnector(presenter: Presenter<State, Event>): LifecyclePresenterConnector<State, Event> =
     LifecyclePresenterConnector(lifecycleOwner = this, presenter = presenter)
-}
+
 
 class LifecyclePresenterConnector<State, Event>(lifecycleOwner: LifecycleOwner, presenter: Presenter<State, Event>) {
 
     private val moleculeScope = CoroutineScope(lifecycleOwner.lifecycleScope.coroutineContext + AndroidUiDispatcher.Main)
-    private val eventFlow: MutableSharedFlow<Event> = MutableSharedFlow(extraBufferCapacity = 64)
+    private val mutableEventFlow: MutableSharedFlow<Event> = MutableSharedFlow(extraBufferCapacity = 64)
 
-    val stateFlow: StateFlow<State> = moleculeScope.launchMolecule(RecompositionClock.ContextClock) {
-        presenter.present(events = eventFlow)
+    val stateFlow: StateFlow<State> = moleculeScope.launchMolecule(RecompositionClock.Immediate) {
+        presenter.present(events = mutableEventFlow)
     }
 
     fun emitEvent(event: Event) {
-        eventFlow.tryEmit(event)
+        mutableEventFlow.tryEmit(event)
     }
 }