Binder implementation

Author: ShikaSD

mvicore-base/src/commonMain/kotlin/com/badoo/mvicore/common/binder/Binder.kt

@@ -4,16 +4,26 @@ import com.badoo.mvicore.common.Cancellable
 import com.badoo.mvicore.common.Sink
 import com.badoo.mvicore.common.Source
 import com.badoo.mvicore.common.lifecycle.Lifecycle
+import com.badoo.mvicore.common.lifecycle.Lifecycle.Event.BEGIN
+import com.badoo.mvicore.common.lifecycle.Lifecycle.Event.END
 
-class Binder(private val lifecycle: Lifecycle? = null): Cancellable {
+interface Binder : Cancellable {
+    fun <T> bind(connection: Pair<Source<T>, Sink<T>>)
+    fun <Out, In> bind(connection: Connection<Out, In>)
+}
+
+fun Binder(): Binder = SimpleBinder()
+fun Binder(lifecycle: Lifecycle): Binder = LifecycleBinder(lifecycle)
+
+internal class SimpleBinder : Binder {
     private val cancellables = mutableListOf<Cancellable>()
 
-    fun <T> bind(connection: Pair<Source<T>, Sink<T>>) {
+    override fun <T> bind(connection: Pair<Source<T>, Sink<T>>) {
         val (from, to) = connection
         bind(Connection(from = from, to = to))
     }
 
-    fun <Out, In> bind(connection: Connection<Out, In>) {
+    override fun <Out, In> bind(connection: Connection<Out, In>) {
         val out = connection.connector?.let { it(connection.from!!) } ?: (connection.from as Source<In>)
         cancellables += out.connect(connection.to)
     }
@@ -23,3 +33,52 @@ class Binder(private val lifecycle: Lifecycle? = null): Cancellable {
         cancellables.clear()
     }
 }
+
+internal class LifecycleBinder(private val lifecycle: Lifecycle) : Binder {
+    private var lifecycleActive = false
+    private val cancellables = mutableListOf<Cancellable>()
+    private val innerBinder = SimpleBinder()
+    private val connections = mutableListOf<Connection<*, *>>()
+
+    init {
+        cancellables += lifecycle.connect {
+            when (it) {
+                BEGIN -> connect()
+                END -> disconnect()
+            }
+        }
+        cancellables += innerBinder
+    }
+
+    override fun <T> bind(connection: Pair<Source<T>, Sink<T>>) {
+        val (from, to) = connection
+        bind(Connection(from = from, to = to))
+    }
+
+    override fun <Out, In> bind(connection: Connection<Out, In>) {
+        connections += connection
+        if (lifecycleActive) {
+            innerBinder.bind(connection)
+        }
+    }
+
+    private fun connect() {
+        if (lifecycleActive) return
+
+        lifecycleActive = true
+        connections.forEach { innerBinder.bind(it) }
+    }
+
+    private fun disconnect() {
+        if (!lifecycleActive) return
+
+        lifecycleActive = false
+        innerBinder.cancel()
+    }
+
+    override fun cancel() {
+        cancellables.forEach { it.cancel() }
+        connections.clear()
+    }
+
+}

mvicore-base/src/commonMain/kotlin/com/badoo/mvicore/common/element/ActorReducerFeature.kt

@@ -1,7 +1,6 @@
 package com.badoo.mvicore.common.element
 
 import com.badoo.mvicore.common.Cancellable
-import com.badoo.mvicore.common.Sink
 import com.badoo.mvicore.common.Source
 
 typealias Bootstrapper<Action> = () -> Source<out Action>
@@ -10,8 +9,10 @@ typealias Actor<State, Wish, Effect> = (state: State, wish: Wish) -> Source<out
 
 typealias Reducer<State, Effect> = (state: State, effect: Effect) -> State
 
-typealias NewsPublisher<Wish, State, Effect, News> = (old: State, wish: Wish, effect: Effect, new: State) -> News?
+typealias NewsPublisher<Action, Effect, State, News> = (old: State, action: Action, effect: Effect, new: State) -> News?
 
-interface Feature<Wish, State, News>: Sink<Wish>, Source<State>, Cancellable {
+typealias PostProcessor<Action, Effect, State> = (old: State, action: Action, effect: Effect, new: State) -> Action?
+
+interface Feature<Wish, State, News>: (Wish) -> Unit, Source<State>, Cancellable {
     val news: Source<News>
 }

mvicore-base/src/commonMain/kotlin/com/badoo/mvicore/common/element/BaseFeature.kt

@@ -0,0 +1,21 @@
+package com.badoo.mvicore.common.feature
+
+import com.badoo.mvicore.common.element.Actor
+import com.badoo.mvicore.common.element.Bootstrapper
+import com.badoo.mvicore.common.element.NewsPublisher
+import com.badoo.mvicore.common.element.Reducer
+
+open class ActorReducerFeature<Wish : Any, Effect : Any, State : Any, News : Any>(
+    initialState: State,
+    bootstrapper: Bootstrapper<Wish>? = null,
+    actor: Actor<State, Wish, Effect>,
+    reducer: Reducer<State, Effect>,
+    newsPublisher: NewsPublisher<Wish, Effect, State, News>? = null
+) : BaseFeature<Wish, Wish, Effect, State, News>(
+    initialState = initialState,
+    bootstrapper = bootstrapper,
+    wishToAction = { it },
+    actor = actor,
+    reducer = reducer,
+    newsPublisher = newsPublisher
+)

mvicore-base/src/commonMain/kotlin/com/badoo/mvicore/common/element/ReducerFeature.kt

@@ -0,0 +1,59 @@
+package com.badoo.mvicore.common.feature
+
+import com.badoo.mvicore.common.Sink
+import com.badoo.mvicore.common.Source
+import com.badoo.mvicore.common.element.Actor
+import com.badoo.mvicore.common.element.Bootstrapper
+import com.badoo.mvicore.common.element.Feature
+import com.badoo.mvicore.common.element.NewsPublisher
+import com.badoo.mvicore.common.element.PostProcessor
+import com.badoo.mvicore.common.element.Reducer
+import com.badoo.mvicore.common.source
+
+open class BaseFeature<Action : Any, Wish : Any, Effect : Any, State : Any, News : Any> (
+    initialState: State,
+    private val bootstrapper: Bootstrapper<Action>? = null,
+    private val wishToAction: (Wish) -> Action,
+    private val actor: Actor<State, Action, Effect>,
+    private val reducer: Reducer<State, Effect>,
+    private val newsPublisher: NewsPublisher<Action, Effect, State, News>? = null,
+    private val postProcessor: PostProcessor<Action, Effect, State>? = null
+): Feature<Wish, State, News> {
+    private val actionSource = source<Action>()
+    internal val effectSource = source<Effect>()
+    private val stateSource = source(initialState)
+    private val newsSource = source<News>()
+
+    init {
+        bootstrapper?.invoke()?.connect(actionSource)
+        actionSource.connect { action ->
+            val oldState = state
+            actor.invoke(oldState, action)
+                .connect { effect ->
+                    val newState = reducer(this.state, effect)
+                    stateSource(newState)
+                    newsPublisher?.invoke(oldState, action, effect, newState)?.let {
+                        newsSource(it)
+                    }
+                    postProcessor?.invoke(oldState, action, effect, newState)?.let(actionSource::invoke)
+                }
+        }
+    }
+
+    override fun invoke(wish: Wish) {
+        val action = wishToAction(wish)
+        actionSource.invoke(action)
+    }
+
+    override fun connect(sink: Sink<State>) = stateSource.connect(sink)
+
+    override fun cancel() {
+        // TODO
+    }
+
+    val state: State
+        get() = stateSource.value!!
+
+    override val news: Source<News>
+        get() = newsSource
+}

mvicore-base/src/commonMain/kotlin/com/badoo/mvicore/common/element/elements.kt

@@ -0,0 +1,12 @@
+package com.badoo.mvicore.common.feature
+
+//open class ReducerFeature<Wish : Any, State : Any, News : Any>(
+//    initialState: State,
+//    bootstrapper: Bootstrapper<Wish>? = null,
+//    private val reducer: Reducer<State, Wish>,
+//    private val newsPublisher: SimpleNewsPublisher<State, Wish, News>? = null
+//) : ActorReducerFeature<Wish, Wish, State, News>(
+//    actor = {  }
+//)
+
+typealias SimpleNewsPublisher<State, Wish, News> = (old: State, wish: Wish, state: State) -> News?

mvicore-base/src/commonMain/kotlin/com/badoo/mvicore/common/feature/ActorReducerFeature.kt

@@ -4,17 +4,20 @@ import com.badoo.mvicore.common.SimpleSource
 import com.badoo.mvicore.common.Source
 import com.badoo.mvicore.common.lifecycle.Lifecycle.Event.BEGIN
 import com.badoo.mvicore.common.lifecycle.Lifecycle.Event.END
-import com.badoo.mvicore.common.source
 
 interface Lifecycle : Source<Lifecycle.Event> {
     enum class Event {
         BEGIN, END
     }
 
-    fun manual() = ManualLifecycle()
+    companion object {
+        fun manual() = ManualLifecycle()
+    }
 }
 
-class ManualLifecycle(private val source: SimpleSource<Lifecycle.Event> = source()) : Lifecycle, Source<Lifecycle.Event> by source {
+class ManualLifecycle(
+    private val source: SimpleSource<Lifecycle.Event> = SimpleSource(initialValue = null, emitOnConnect = true)
+) : Lifecycle, Source<Lifecycle.Event> by source {
     fun begin() {
         source(BEGIN)
     }