Initial impl

Author: omkar-tenkale

gradle/libs.versions.toml

@@ -11,24 +11,33 @@ kotlin = "1.9.0"
 ktor = "2.3.9"
 kamel = "0.9.4"
 voyager = "1.0.0"
+kotlin-coroutines = "1.6.4"
 nexus-publish = "2.0.0-rc-1"
+kotlinx-serialization = "1.6.3"
+kotlinx-atomicfu = "0.24.0"
 
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
 nexus-publish = { module = "io.github.gradle-nexus.publish-plugin:io.github.gradle-nexus.publish-plugin.gradle.plugin", version.ref = "nexus-publish" }
 compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "jetpack-compose-bom" }
 compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling" }
 compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" }
+androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version = "1.6.1" }
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activityCompose" }
 kamel = { module = "media.kamel:kamel-image", version.ref = "kamel" }
 koin-core = { module = "io.insert-koin:koin-core", version.ref = "koin" }
+koin-android = { module = "io.insert-koin:koin-android", version.ref = "koin" }
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
 ktor-client-okhttp = { module = "io.ktor:ktor-client-okhttp", version.ref = "ktor" }
 ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" }
 ktor-client-content-negotiation = { module = "io.ktor:ktor-client-content-negotiation", version.ref = "ktor" }
 ktor-serialization-kotlinx-json = { module = "io.ktor:ktor-serialization-kotlinx-json", version.ref = "ktor" }
 voyager-navigator = { module = "cafe.adriel.voyager:voyager-navigator", version.ref = "voyager" }
 voyager-koin = { module = "cafe.adriel.voyager:voyager-koin", version.ref = "voyager" }
+kotlin-coroutines =  { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
+kotlinx-serialization-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-core", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
+kotlinx-atomicfu = { group = "org.jetbrains.kotlinx", name = "atomicfu", version.ref = "kotlinx-atomicfu" }
 
 [plugins]
 androidLibrary = { id = "com.android.library", version.ref = "agp" }

nodal/build.gradle.kts

@@ -1,10 +1,17 @@
+import org.jetbrains.kotlin.gradle.dsl.ExplicitApiMode
+
 plugins {
     alias(libs.plugins.kotlinMultiplatform)
     alias(libs.plugins.androidLibrary)
+    alias(libs.plugins.jetbrainsCompose)
+    alias(libs.plugins.kotlinxSerialization)
     id("module.publication")
 }
 
 kotlin {
+    explicitApi()
+    explicitApi = ExplicitApiMode.Strict
+
     targetHierarchy.default()
     jvm()
     androidTarget {
@@ -18,12 +25,30 @@ kotlin {
     iosX64()
     iosArm64()
     iosSimulatorArm64()
-    linuxX64()
+//    linuxX64()
 
     sourceSets {
+        val androidMain by getting {
+            dependencies {
+                implementation(project.dependencies.platform(libs.compose.bom))
+                implementation(libs.androidx.activity.compose)
+                implementation(libs.androidx.appcompat)
+                implementation(libs.compose.ui.tooling.preview)
+            }
+        }
         val commonMain by getting {
             dependencies {
-                //put your multiplatform dependencies here
+                implementation(libs.koin.core)
+                implementation(libs.kotlin.coroutines)
+                implementation(libs.kotlinx.serialization.core)
+                implementation(libs.kotlinx.serialization.json)
+                implementation(libs.kotlinx.atomicfu)
+
+                implementation(compose.runtime)
+                implementation(compose.foundation)
+                implementation(compose.material)
+                implementation(compose.components.resources)
+
             }
         }
         val commonTest by getting {

nodal/src/androidMain/kotlin/dev.omkartenkale.nodal/NodalActivity.kt

@@ -0,0 +1,98 @@
+package dev.omkartenkale.nodal
+
+import android.widget.FrameLayout
+import androidx.activity.OnBackPressedDispatcher
+import androidx.activity.compose.setContent
+import androidx.annotation.CallSuper
+import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.ui.platform.ComposeView
+import androidx.lifecycle.lifecycleScope
+import dev.omkartenkale.nodal.Node.Companion.createRootNode
+import dev.omkartenkale.nodal.compose.UI
+import dev.omkartenkale.nodal.misc.RemovalRequest
+import kotlinx.coroutines.launch
+
+public abstract class NodalActivity : AppCompatActivity() {
+
+    public lateinit var ui: UI
+    public lateinit var contentNode: Node
+    protected inline fun <reified T : Node> setContentNode(
+        container: FrameLayout = findViewById(android.R.id.content),
+        noinline dependencyDeclaration: DependencyDeclaration = {},
+    ) {
+//        val finalNodeConfigBuilder: NodeConfigBuilder = {
+//            param<RemovalRequest>(RemovalRequest{ finish() })
+////            param(localsharedpref)
+////            param(savedinstancestate)
+////            param(Unit)
+//            apply(nodeConfigBuilder)
+//        }
+
+        contentNode = createRootNode<T>{
+//            provides<Timber> { Timber()  }
+//            provides<TreeVisualiser> { TreeVisualiser()  }
+//            provides<StringProvider> { StringProvider()  }
+//            provides<AnalyticsLogger> { AnalyticsLogger()  }
+//            provides<KoroutineDispatcher> { KoroutineDispatcher()  }
+//            provides<FileManager> { FileManager()  }
+//
+//            provides<SesionInfo> { SesionInfo()  }
+//            provides<RideInfo> { RideInfo()  }
+//            provides<SelectedCountry> { SelectedCountry()  }
+//            provides<DeeplinkResolver> { DeeplinkResolver()  }
+//            provides{ SystemNotificationManager()  }
+//            provides{ SystemEventListener()  }
+//            provides{ BuildVarient()  }
+//            provides{ NodalConfig()  }
+//
+//            //only to children and not subchildren
+//            provides<UIContainer> { UIContainer()  }
+//            provides<SomeDeeplink> { SomeDeeplink()  }
+//            provides { ProductDetails()  }
+//
+//            providesSelf<RemovalRequest>(RemovalRequest{ finish() })
+
+            provides<NodalConfig>{ NodalConfig(true) }
+            provides<OnBackPressedDispatcher>{ onBackPressedDispatcher }
+            provides<UI>{ UI().also {
+                ui = it
+                container.addView(ComposeView(this@NodalActivity).also { setContent { ui.drawLayers() } })
+            } }
+            providesSelf<RemovalRequest> {
+                RemovalRequest {
+                    finish()
+                }
+            }
+            include(dependencyDeclaration)
+        }.apply { dispatchAdded() }
+        container.addView(ComposeView(this).also { setContent { ui.drawLayers() } })
+    }
+
+    @CallSuper
+    override fun onResume() {
+        super.onResume()
+        if (::ui.isInitialized) {
+            lifecycleScope.launch {
+                ui.dispatchFocusChanged(isFocused = true)
+            }
+        }
+    }
+
+    @CallSuper
+    override fun onPause() {
+        super.onPause()
+        if (::ui.isInitialized) {
+            lifecycleScope.launch {
+                ui.dispatchFocusChanged(isFocused = false)
+            }
+        }
+    }
+
+    @CallSuper
+    override fun onDestroy() {
+        super.onDestroy()
+        if (::contentNode.isInitialized) {
+            contentNode.dispatchRemoved()
+        }
+    }
+}

nodal/src/androidMain/kotlin/dev.omkartenkale.nodal/misc/PlatformUtil.android.kt

@@ -0,0 +1,8 @@
+package dev.omkartenkale.nodal.misc
+
+import dev.omkartenkale.nodal.Node
+import kotlin.reflect.KClass
+
+public actual fun <T : Node> KClass<T>.instantiate(): T {
+    return java.newInstance()
+}

nodal/src/androidMain/kotlin/fibiprops.android.kt

@@ -0,0 +1,8 @@
+package dev.omkartenkale.nodal.misc
+
+import dev.omkartenkale.nodal.Node
+import kotlin.reflect.KClass
+
+public actual fun <T : Node> KClass<T>.instantiate(): T {
+    TODO("Not yet implemented")
+}

nodal/src/androidUnitTest/kotlin/AndroidFibiTest.kt

@@ -0,0 +1,3 @@
+package dev.omkartenkale.nodal
+
+public data class NodalConfig(val createEagerInstances: Boolean = false)

nodal/src/appleMain/kotlin/dev.omkartenkale.nodal/misc/PlatformUtil.apple.kt

@@ -0,0 +1,154 @@
+package dev.omkartenkale.nodal
+
+import dev.omkartenkale.nodal.exceptions.DisallowedNodeAdditionException
+import dev.omkartenkale.nodal.exceptions.NodeCreationException
+import dev.omkartenkale.nodal.lifecycle.ChildChangedEvent
+import dev.omkartenkale.nodal.misc.RemovalRequest
+import dev.omkartenkale.nodal.misc.instantiate
+import kotlinx.atomicfu.atomic
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import kotlin.reflect.KClass
+
+internal val nodeId = atomic(0)
+
+public open class Node {
+
+    private lateinit var _scope: Scope
+    public val dependencies: Scope
+        get() = if (::_scope.isInitialized) {
+            _scope
+        } else error("Accessing dependencies in init block is not supported")
+
+    public companion object {
+        private fun instantiateNode(
+            klass: KClass<out Node>,
+            parentScope: Scope,
+            dependencyDeclaration: DependencyDeclaration
+        ): Node = try {
+            val newNodeId = nodeId.getAndIncrement()
+            val nodeScope = Scope("${klass.simpleName}#$newNodeId", parentScope)
+            klass.instantiate().also {
+                it.init(nodeScope)
+                DependencyDeclarationDSL(nodeScope).apply(dependencyDeclaration)
+                    .apply(it.providesDependencies)
+            }
+        } catch (t: Throwable) {
+            throw NodeCreationException(klass, t)
+        }
+
+        public inline fun <reified T : Node> createRootNode(
+            noinline dependencyDeclaration: DependencyDeclaration
+        ): T = createRootNode(T::class, dependencyDeclaration) as T
+
+        public fun createRootNode(
+            klass: KClass<out Node>, dependencyDeclaration: DependencyDeclaration
+        ): Node = instantiateNode(klass, createRootScope(), dependencyDeclaration)
+    }
+
+    private fun init(scope: Scope) {
+        _scope = scope
+    }
+
+    private val removalRequest: RemovalRequest by dependencies<RemovalRequest>()
+
+    public open val providesDependencies: DependencyDeclaration = {}
+    public val stateChangedEvents: MutableStateFlow<NodeLifecycleState> =
+        MutableStateFlow(NodeLifecycleState.INITIALIZED)
+    public val childChangedEvents: MutableSharedFlow<ChildChangedEvent> = MutableSharedFlow()
+
+    protected var isAdded: Boolean = false
+        set(value) {
+            field = value
+            stateChangedEvents.value =
+                if (value) NodeLifecycleState.ADDED else NodeLifecycleState.REMOVED
+        }
+
+    protected inline fun <reified T : Any> dependencies(): Lazy<T> = lazy {
+        dependencies.get<T>()
+    }
+//        .also {
+//            if (dependencies.get<NodalConfig>().createEagerInstances) {
+//                it.value
+//            }
+//        }
+
+    private val _children = mutableListOf<Node>()
+    public val children: List<Node> = _children
+
+    protected var coroutineScope: CoroutineScope =
+        CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    public inline fun <reified T : Node> addChild(noinline dependencyDeclaration: DependencyDeclaration = {}): T =
+        addChild(T::class, dependencyDeclaration) as T
+
+    public fun addChild(
+        klass: KClass<out Node>, dependencyDeclaration: DependencyDeclaration
+    ): Node {
+        if (stateChangedEvents.value == NodeLifecycleState.REMOVED) {
+            throw DisallowedNodeAdditionException(this::class, klass)
+        }
+        val dependencyDeclaration: DependencyDeclaration = {
+            providesSelf<RemovalRequest> {
+                RemovalRequest {
+                    removeChild(children.first())
+                }
+            }
+            include(dependencyDeclaration)
+        }
+        val node = instantiateNode(klass, dependencies, dependencyDeclaration)
+        _children.add(node)
+        node.dispatchAdded()
+        coroutineScope.launch { childChangedEvents.emit(ChildChangedEvent.NodeAdded(node)) }
+        return node
+    }
+
+    public fun removeChild(node: Node) {
+        if (children.contains(node)) {
+            node.dispatchRemoved()
+            _children.remove(node)
+            coroutineScope.launch { childChangedEvents.emit(ChildChangedEvent.NodeRemoved(node)) }
+        } else error("Cant remove node as parent does not contain child. \n\tParent: ${this::class.simpleName} (${this::class.qualifiedName}), \n\tChild: ${node::class.simpleName} (${node::class.qualifiedName})")
+    }
+
+    public open fun handleDetachRequest(node: Node): Boolean {
+        removeChild(node)
+        return true
+    }
+
+    public fun dispatchAdded() {
+        onAdded()
+        isAdded = true
+    }
+
+    public open fun onAdded(): Unit = Unit
+
+    internal fun dispatchRemoved() {
+        children.forEach { it.dispatchRemoved() }
+        isAdded = false
+        onRemoved()
+        coroutineScope.cancel()
+        dependencies.close()
+    }
+
+    public open fun onRemoved(): Unit = Unit
+    protected fun removeSelf(): Unit = removalRequest.invoke()
+
+    public fun Node.onAdded(block: () -> Unit) {
+        stateChangedEvents.filter { it == NodeLifecycleState.ADDED }.onEach { block() }
+            .launchIn(coroutineScope)
+    }
+
+    public fun Node.onRemoved(block: () -> Unit) {
+        stateChangedEvents.filter { it == NodeLifecycleState.REMOVED }.onEach { block() }
+            .launchIn(coroutineScope)
+    }
+}