Merge pull request #2 from GSM-MSG/feature/1_change_logic_to_observe_…

…local

🔀 :: (#1) - change logic to observe local

src/main/kotlin/Macaroni.kt

@@ -4,7 +4,7 @@ class Macaroni<T>(
     onRemoteObservable: suspend () -> Flow<T>,
     getLocalData: suspend () -> T,
     onUpdateLocal: suspend (T) -> Unit,
-    onRemoteFailure: (Throwable) -> Unit
+    onRemoteFailure: (Throwable) -> Unit = {}
 ) {
     // remote
     //  'onRemoteObservable' should pass the logic

src/main/kotlin/MacaroniFlow.kt

@@ -0,0 +1,47 @@
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.first
+
+class MacaroniFlow<T> constructor(
+    onRemoteObservable: suspend () -> Flow<T>,
+    onUpdateLocal: suspend (T) -> Unit,
+    onLocalObservable: suspend () -> Flow<T>,
+) {
+
+    private var onRemoteObservable: suspend () -> Flow<T>
+    private var onUpdateLocal: suspend (T) -> Unit
+    private var onLocalObservable: suspend () -> Flow<T>
+
+    init {
+        this.onRemoteObservable = onRemoteObservable
+        this.onUpdateLocal = onUpdateLocal
+        this.onLocalObservable = onLocalObservable
+    }
+
+    suspend fun fetch(onNext: (MacaroniStatus, T) -> Unit) {
+        val localData = onLocalObservable().first()
+        onLocalObservable()
+            .drop(1)
+            .collect { data ->
+                onNext(Success, data)
+            }
+        try {
+            runCatching {
+                onNext(Loading, localData)
+                onRemoteObservable()
+            }.onSuccess {
+                it.collect { data ->
+                    if (localData != data) {
+                        onUpdateLocal(data)
+                    } else {
+                        onNext(Success, data)
+                    }
+                }
+            }.onFailure {
+                onNext(Error, localData)
+            }
+        } catch (e: Exception) {
+            onNext(Error, localData)
+        }
+    }
+}

src/test/kotlin/MacaroniFlowTest.kt

@@ -0,0 +1,28 @@
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.flow
+
+private suspend fun main() {
+    val macaroni = MacaroniFlow(
+        onRemoteObservable = {
+            flow {
+                delay(100)
+                emit(TestStatus("onRemoteObservable", "test"))
+            }
+        },
+        onUpdateLocal = {
+            delay(100)
+            println("onUpdateLocal")
+        },
+        onLocalObservable = {
+            flow {
+                emit(TestStatus("getLocalData", "first"))
+                delay(200)
+                emit(TestStatus("changeLocal", "nice"))
+            }
+        }
+    )
+
+    macaroni.fetch { status, result ->
+        println("status: $status, result: $result")
+    }
+}