Improve deeplink

FloconAndroid/datastores-no-op/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     alias(libs.plugins.android.library)
     alias(libs.plugins.kotlin.android)
@@ -29,8 +31,11 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
-    kotlinOptions {
-        jvmTarget = "11"
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
     }
 }
 

FloconAndroid/datastores/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     alias(libs.plugins.android.library)
     alias(libs.plugins.kotlin.android)
@@ -29,8 +31,11 @@ android {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11
     }
-    kotlinOptions {
-        jvmTarget = "11"
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
     }
 }
 

FloconAndroid/flocon-base/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.android.library)
@@ -6,10 +8,8 @@ plugins {
 
 kotlin {
     androidTarget {
-        compilations.all {
-            kotlinOptions {
-                jvmTarget = "11"
-            }
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_11)
         }
     }
 
@@ -68,6 +68,7 @@ android {
             )
         }
     }
+
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_11
         targetCompatibility = JavaVersion.VERSION_11

FloconAndroid/flocon-base/src/commonMain/kotlin/io/github/openflocon/flocon/FloconApp.kt

@@ -35,7 +35,7 @@ abstract class FloconApp {
         val crashReporterPlugin: FloconCrashReporterPlugin
     }
 
-    open val client: FloconApp.Client? = null
+    open val client: Client? = null
 
     abstract val isInitialized : StateFlow<Boolean>
 

FloconAndroid/flocon-base/src/commonMain/kotlin/io/github/openflocon/flocon/plugins/deeplinks/FloconDeeplinksPlugin.kt

@@ -3,48 +3,110 @@ package io.github.openflocon.flocon.plugins.deeplinks
 import io.github.openflocon.flocon.FloconApp
 import io.github.openflocon.flocon.plugins.deeplinks.model.DeeplinkModel
 
-class ParameterBuilder {
-    val parameters: MutableMap<String, DeeplinkModel.Parameter> = mutableMapOf()
+class DeeplinkLinkBuilder internal constructor(
+    private val link: String
+) {
+    private val parameters: MutableMap<String, DeeplinkModel.Parameter> = mutableMapOf()
+
+    var label: String? = null
+    var description: String? = null
 
     infix fun String.withAutoComplete(suggestions: List<String>) {
-        parameters[this] = DeeplinkModel.Parameter(paramName = this, suggestions.distinct())
+        parameters[this] = DeeplinkModel.Parameter.AutoComplete(
+            paramName = this,
+            suggestions.distinct()
+        )
+    }
+
+    infix fun String.withVariable(variableName: String) {
+        parameters[this] = DeeplinkModel.Parameter.Variable(
+            paramName = this,
+            variableName = variableName
+        )
+    }
+
+    fun build() = DeeplinkModel(
+        link = link,
+        label = label,
+        description = description,
+        parameters = parameters.values
+            .toList()
+    )
+
+}
+
+class DeeplinkVariableBuilder internal constructor(
+    private val name: String
+) {
+    private var mode: DeeplinkVariable.Mode = DeeplinkVariable.Mode.Input
+
+    var description: String? = null
+
+    fun autoComplete(suggestions: List<String>) {
+        mode = DeeplinkVariable.Mode.AutoComplete(suggestions)
     }
 
-    fun build() : List<DeeplinkModel.Parameter> {
-        return parameters.values.toList()
+    internal fun build(): DeeplinkVariable {
+        return DeeplinkVariable(
+            name = name,
+            mode = mode,
+            description = description
+        )
     }
+
+}
+
+data class DeeplinkVariable(
+    val name: String,
+    val mode: Mode = Mode.Input,
+    val description: String? = null
+) {
+
+    sealed interface Mode {
+        object Input : Mode
+        data class AutoComplete(val suggestions: List<String>) : Mode
+    }
+
 }
 
 class DeeplinkBuilder {
+    private val variables = mutableListOf<DeeplinkVariable>()
     private val deeplinks = mutableListOf<DeeplinkModel>()
 
-    fun deeplink(
-        link: String,
-        label: String? = null,
-        description: String? = null,
-        parameters: (ParameterBuilder.() -> Unit)? = null,
-    ) {
-        deeplinks.add(
-            DeeplinkModel(
-                link = link,
-                label = label,
-                description = description,
-                parameters = parameters?.let { ParameterBuilder().apply(parameters).build() } ?: emptyList()
-            )
-        )
+    fun variable(name: String, block: DeeplinkVariableBuilder.() -> Unit = {}) {
+        val variable = DeeplinkVariableBuilder(name).apply(block)
+            .build()
+
+        variables.add(variable)
     }
 
-    fun build(): List<DeeplinkModel> {
-        return deeplinks.toList()
+    fun deeplink(link: String, block: DeeplinkLinkBuilder.() -> Unit = {}) {
+        val deeplink = DeeplinkLinkBuilder(link).apply(block)
+            .build()
+
+        deeplinks.add(deeplink)
     }
+
+    internal fun deeplinks(): List<DeeplinkModel> = deeplinks.toList()
+    internal fun variables(): List<DeeplinkVariable> = variables.toList()
 }
 
 fun FloconApp.deeplinks(deeplinksBlock: DeeplinkBuilder.() -> Unit) {
     this.client?.deeplinksPlugin?.let {
-        it.registerDeeplinks(DeeplinkBuilder().apply(deeplinksBlock).build())
+        val builder = DeeplinkBuilder().apply(deeplinksBlock)
+
+        it.registerDeeplinks(
+            deeplinks = builder.deeplinks(),
+            variables = builder.variables()
+        )
     }
 }
 
 interface FloconDeeplinksPlugin {
-    fun registerDeeplinks(deeplinks: List<DeeplinkModel>)
+
+    fun registerDeeplinks(
+        deeplinks: List<DeeplinkModel>,
+        variables: List<DeeplinkVariable>
+    )
+
 }

FloconAndroid/flocon-base/src/commonMain/kotlin/io/github/openflocon/flocon/plugins/deeplinks/model/DeeplinkModel.kt

@@ -6,8 +6,19 @@ data class DeeplinkModel(
     val description: String? = null,
     val parameters: List<Parameter>,
 ) {
-    data class Parameter(
-        val paramName: String,
-        val autoComplete: List<String>,
-    )
+
+    sealed interface Parameter {
+        val paramName: String
+
+        data class AutoComplete(
+            override val paramName: String,
+            val autoComplete: List<String>
+        ) : Parameter
+
+        data class Variable(
+            override val paramName: String,
+            val variableName: String
+        ) : Parameter
+
+    }
 }

FloconAndroid/flocon-no-op/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.android.library)
@@ -6,10 +8,8 @@ plugins {
 
 kotlin {
     androidTarget {
-        compilations.all {
-            kotlinOptions {
-                jvmTarget = "11"
-            }
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_11)
         }
     }
 

FloconAndroid/flocon/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.android.library)
@@ -8,10 +10,8 @@ plugins {
 
 kotlin {
     androidTarget {
-        compilations.all {
-            kotlinOptions {
-                jvmTarget = "11"
-            }
+        compilerOptions {
+            jvmTarget.set(JvmTarget.JVM_11)
         }
     }
 
@@ -77,14 +77,12 @@ kotlin {
     }
 }
 
-
 buildConfig {
     packageName("io.github.openflocon.flocondesktop")
 
     buildConfigField("APP_VERSION", System.getenv("PROJECT_VERSION_NAME") ?: project.property("floconVersion") as String)
 }
 
-
 android {
     namespace = "io.github.openflocon.flocon"
     compileSdk = 36

FloconAndroid/flocon/src/commonMain/kotlin/io/github/openflocon/flocon/core/FloconEncoder.kt

@@ -1,11 +1,22 @@
 package io.github.openflocon.flocon.core
 
+import io.github.openflocon.flocon.plugins.deeplinks.model.DeeplinkParameterRemote
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.modules.SerializersModule
+import kotlinx.serialization.modules.polymorphic
+import kotlinx.serialization.modules.subclass
 
 internal object FloconEncoder {
     val json = Json {
         ignoreUnknownKeys = true
         isLenient = true
         encodeDefaults = false
+
+        serializersModule = SerializersModule {
+            polymorphic(DeeplinkParameterRemote::class) {
+                subclass(DeeplinkParameterRemote.AutoComplete::class)
+                subclass(DeeplinkParameterRemote.Variable::class)
+            }
+        }
     }
 }

FloconAndroid/flocon/src/commonMain/kotlin/io/github/openflocon/flocon/plugins/deeplinks/FloconDeeplinksPlugin.kt

@@ -14,6 +14,7 @@ internal class FloconDeeplinksPluginImpl(
 ) : FloconPlugin, FloconDeeplinksPlugin {
 
     private val deeplinks = MutableStateFlow<List<DeeplinkModel>?>(null)
+    private val variables = MutableStateFlow<List<DeeplinkVariable>?>(null)
 
     override fun onMessageReceived(
         messageFromServer: FloconMessageFromServer,
@@ -24,20 +25,25 @@ internal class FloconDeeplinksPluginImpl(
     override fun onConnectedToServer() {
         // on connected, send known dashboard
         deeplinks.value?.let {
-            registerDeeplinks(it)
+            registerDeeplinks(it, variables.value.orEmpty())
         }
     }
 
-    override fun registerDeeplinks(deeplinks: List<DeeplinkModel>) {
-        this.deeplinks.update {
-            deeplinks
-        }
+    override fun registerDeeplinks(
+        deeplinks: List<DeeplinkModel>,
+        variables: List<DeeplinkVariable>
+    ) {
+        this.deeplinks.update { deeplinks }
+        this.variables.update { variables }
 
         try {
             sender.send(
                 plugin = Protocol.FromDevice.Deeplink.Plugin,
                 method = Protocol.FromDevice.Deeplink.Method.GetDeeplinks,
-                body = toDeeplinksJson(deeplinks)
+                body = toDeeplinksJson(
+                    deeplinks = deeplinks,
+                    variables = variables
+                )
             )
         } catch (t: Throwable) {
             FloconLogger.logError("deeplink mapping error", t)