Created core stargate API

Author: chRyNaN

.idea/gradle.xml

@@ -53,6 +53,6 @@ Pod::Spec.new do |spec|
     spec.resources = ['build/compose/cocoapods/compose-resources']
     spec.info_plist = {
     "CFBundleShortVersionString": "1.0.0-beta10",
-    "CFBundleVersion": "712"
+    "CFBundleVersion": "714"
 }
 end

app-shared/app_shared.podspec

@@ -38,6 +38,20 @@ kotlin {
                 // Logging
                 // https://github.com/mooncloak/logpile
                 implementation("com.mooncloak.kodetools.logpile:logpile-core:_")
+
+                // Multiplatform I/O - kotlinx-io
+                // https://github.com/Kotlin/kotlinx-io
+                // Apache 2.0: https://github.com/Kotlin/kotlinx-io/blob/master/LICENSE
+                implementation("org.jetbrains.kotlinx:kotlinx-io-core:_")
+
+                // UI Components - Needed for content models
+                implementation(compose.runtime)
+                implementation(compose.ui)
+
+                // Jetpack Compose Serializers - compose-serialization
+                // https://github.com/mooncloak/compose-serialization
+                // Apache 2.0: https://github.com/mooncloak/compose-serialization
+                implementation("com.mooncloak.kodetools.compose.serialization:compose-serialization-core:_")
             }
         }
 

component-stargate/build.gradle.kts

@@ -0,0 +1,8 @@
+package com.mooncloak.vpn.component.stargate
+
+public interface ConnectionPoint {
+
+    public val name: String?
+
+    public companion object
+}

component-stargate/src/commonMain/kotlin/com/mooncloak/vpn/component/stargate/ConnectionPoint.kt

@@ -0,0 +1,13 @@
+package com.mooncloak.vpn.component.stargate
+
+import kotlinx.io.Sink
+import kotlinx.io.Source
+
+public interface ContentWrapper {
+
+    public suspend fun wrap(sink: Sink, block: suspend Sink.() -> Unit)
+
+    public suspend fun unwrap(source: Source, block: suspend Source.() -> Unit)
+
+    public companion object
+}

component-stargate/src/commonMain/kotlin/com/mooncloak/vpn/component/stargate/ContentWrapper.kt

@@ -0,0 +1,21 @@
+package com.mooncloak.vpn.component.stargate
+
+import kotlinx.datetime.Instant
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+public object SecondsSinceEpochSerializer : KSerializer<Instant> {
+
+    override val descriptor: SerialDescriptor = Long.serializer().descriptor
+
+
+    override fun serialize(encoder: Encoder, value: Instant) {
+        encoder.encodeLong(value.epochSeconds)
+    }
+
+    override fun deserialize(decoder: Decoder): Instant =
+        Instant.fromEpochSeconds(decoder.decodeLong())
+}

component-stargate/src/commonMain/kotlin/com/mooncloak/vpn/component/stargate/SecondsSinceEpochSerializer.kt

@@ -0,0 +1,139 @@
+package com.mooncloak.vpn.component.stargate
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import kotlinx.io.IOException
+import kotlinx.io.Sink
+import kotlinx.io.Source
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerialFormat
+import kotlin.coroutines.cancellation.CancellationException
+import kotlin.reflect.KClass
+
+public interface Tunnel : AutoCloseable {
+
+    public val isConnected: Boolean
+
+    public val connectionPoints: List<ConnectionPoint>
+
+    public override fun close()
+
+    public companion object
+}
+
+public interface RawTunnel : Tunnel {
+
+    @Throws(IllegalStateException::class, IOException::class, CancellationException::class)
+    public suspend fun source(): Source
+
+    @Throws(IllegalStateException::class, IOException::class, CancellationException::class)
+    public suspend fun sink(): Sink
+
+    @Throws(IllegalStateException::class, IOException::class, CancellationException::class)
+    public suspend fun send(block: suspend Sink.() -> Unit) {
+        val sink = sink()
+
+        block.invoke(sink)
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, CancellationException::class)
+    public suspend fun receive(block: suspend Source.() -> Unit) {
+        val source = source()
+
+        block.invoke(source)
+    }
+
+    public companion object
+}
+
+public interface SerialTunnel<T : Any> : Tunnel {
+
+    public val format: SerialFormat
+
+    public val serializer: KSerializer<T>
+
+    public val kClass: KClass<T>
+
+    @Throws(IllegalStateException::class, IOException::class, CancellationException::class)
+    public suspend fun send(value: T?)
+
+    @Throws(IllegalStateException::class, IOException::class, CancellationException::class)
+    public suspend fun receive(): T?
+
+    public fun receiveAll(): Flow<T?>
+
+    public companion object
+}
+
+public abstract class BaseSerialTunnel<T : Any> public constructor(
+    private val dispatcher: CoroutineDispatcher
+) : SerialTunnel<T> {
+
+    protected abstract val contentWrapper: ContentWrapper
+
+    protected abstract suspend fun source(): Source
+
+    protected abstract suspend fun sink(): Sink
+
+    protected abstract suspend fun Sink.encode(value: T?)
+
+    protected abstract suspend fun Source.decode(): T?
+
+    private val mutex = Mutex(locked = false)
+
+    private val stateFlow = MutableStateFlow<ReceivedContent<T>?>(null)
+
+    final override suspend fun send(value: T?) {
+        withContext(dispatcher) {
+            mutex.withLock {
+                if (!isConnected) {
+                    error("Cannot send data. Tunnel is not connected.")
+                }
+
+                val sink = sink()
+
+                contentWrapper.wrap(sink) {
+                    this.encode(value)
+                }
+            }
+        }
+    }
+
+    final override suspend fun receive(): T? =
+        withContext(dispatcher) {
+            mutex.withLock {
+                if (!isConnected){
+                    error("Cannot receive data. Tunnel is not connected.")
+                }
+
+                var value: T? = null
+
+                val source = source()
+
+                contentWrapper.unwrap(source) {
+                    value = this.decode()
+                }
+
+                stateFlow.emit(ReceivedContent(value = value))
+
+                return@withContext value
+            }
+        }
+
+    final override fun receiveAll(): Flow<T?> =
+        stateFlow.filterNotNull()
+            .map { content -> content.value }
+
+    override fun close() {
+    }
+}
+
+private data class ReceivedContent<T : Any>(
+    val value: T?
+)

component-stargate/src/commonMain/kotlin/com/mooncloak/vpn/component/stargate/Tunnel.kt

@@ -0,0 +1,18 @@
+package com.mooncloak.vpn.component.stargate.message.model
+
+import kotlinx.serialization.Serializable
+import kotlin.jvm.JvmInline
+
+/**
+ * Represents a compacted image placeholder.
+ *
+ * @property [value] The actual blur hash value.
+ *
+ * @see [blurha.sh Website](https://blurha.sh/)
+ * @see [blurhash Repository](https://github.com/woltapp/blurhash)
+ */
+@JvmInline
+@Serializable
+public value class BlurHash public constructor(
+    public val value: String
+)