@momo-kits/native-kits 0.300.4 → 0.300.5-debug

package/compose/src/iosMain/kotlin/vn/momo/kits/platform/Platform.ios.kt

@@ -0,0 +1,217 @@
+package vn.momo.kits.platform
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.InternalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.backhandler.LocalCompatNavigationEventDispatcherOwner
+import androidx.compose.ui.backhandler.BackHandler as ComposeBackHandler
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.NativePaint
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.UIKitInteropProperties
+import androidx.compose.ui.viewinterop.UIKitView
+import cocoapods.lottie_ios.CompatibleAnimation
+import cocoapods.lottie_ios.CompatibleAnimationKeypath
+import cocoapods.lottie_ios.CompatibleAnimationView
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.get
+import kotlinx.cinterop.memScoped
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventDispatcherOwner
+import org.jetbrains.skia.FilterBlurMode
+import org.jetbrains.skia.MaskFilter
+import platform.Foundation.NSBundle
+import platform.UIKit.UIColor
+import platform.UIKit.UIDevice
+import platform.UIKit.UIScreen
+import platform.UIKit.UIUserInterfaceIdiomPhone
+import vn.momo.kits.navigation.AttachHostBackGesture
+import vn.momo.kits.navigation.Navigator
+
+actual fun getPlatformName(): String = "iOS"
+
+actual fun isPhoneIdiom(): Boolean =
+    UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPhone
+
+@OptIn(ExperimentalForeignApi::class)
+@Composable
+actual fun getScreenDimensions(): ScreenDimension = memScoped {
+    val config = UIScreen.mainScreen.bounds.ptr[0]
+    return ScreenDimension(
+        config.size.width.toInt(),
+        config.size.height.toInt()
+    )
+}
+
+actual fun NativePaint.setMaskFilter(blurRadius: Float) {
+    this.maskFilter = MaskFilter.makeBlur(FilterBlurMode.NORMAL, blurRadius / 2, true)
+}
+
+@Composable
+actual fun getStatusBarHeight(): Dp {
+    return WindowInsets.systemBars.asPaddingValues().calculateTopPadding()
+}
+
+@Suppress("DEPRECATION")
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+actual fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
+    ComposeBackHandler(enabled = enabled, onBack = onBack)
+}
+
+@OptIn(InternalComposeUiApi::class)
+@Composable
+actual fun ProvideNavigationEventDispatcherOwner(navigator: Navigator, content: @Composable () -> Unit) {
+    val navigationEventDispatcherOwner = remember {
+        object : NavigationEventDispatcherOwner {
+            override val navigationEventDispatcher = NavigationEventDispatcher()
+        }
+    }
+
+    AttachHostBackGesture(navigationEventDispatcherOwner.navigationEventDispatcher, navigator)
+
+    CompositionLocalProvider(
+        LocalCompatNavigationEventDispatcherOwner provides navigationEventDispatcherOwner,
+        content = content
+    )
+}
+
+@Composable
+actual fun getScreenHeight(): Dp {
+    return getScreenDimensions().height.dp
+}
+
+actual fun getOSVersion(): OSVersion = OSVersion.IOS(
+    major = UIDevice.currentDevice.systemVersion.substringBefore(".").toIntOrNull() ?: 0
+)
+
+@OptIn(ExperimentalForeignApi::class, ExperimentalComposeUiApi::class)
+@Composable
+actual fun LottieAnimation(
+    path: String,
+    tintColor: Color?,
+    bgColor: Color?,
+    placedAsOverlay: Boolean,
+    iterations: Int,
+    isPlaying: Boolean,
+    onEvent: ((String) -> Unit)?,
+    modifier: Modifier,
+    useCompose: Boolean
+) {
+    if (useCompose) {
+        ComposeLottieAnimation(path, tintColor, bgColor, iterations, isPlaying, onEvent, modifier)
+        return
+    }
+
+    val loopCount = if (iterations == LottieIterateForever) -1.0 else iterations.toDouble()
+
+    var animation by remember { mutableStateOf<CompatibleAnimation?>(null) }
+    val animationView = remember { mutableStateOf<CompatibleAnimationView?>(null) }
+
+    LaunchedEffect(Unit) {
+        animation = CompatibleAnimation(name = "compose-resources/composeResources/vn.momo.compose.resources/".plus(path), subdirectory = null, NSBundle.mainBundle)
+    }
+
+    val currentOnEvent by rememberUpdatedState(onEvent)
+
+    LaunchedEffect(isPlaying) {
+        currentOnEvent?.invoke(if (isPlaying) LottieEvent.Start else LottieEvent.Pause)
+    }
+
+    LaunchedEffect(animationView.value, isPlaying) {
+        val view = animationView.value ?: return@LaunchedEffect
+        if (isPlaying) {
+            view.playWithCompletion(completion = { finished -> if (finished) currentOnEvent?.invoke(LottieEvent.Finish) })
+        } else {
+            view.pause()
+        }
+    }
+
+    when (val value = animation) {
+        null -> {
+            Box(modifier)
+        }
+
+        else -> {
+            Box(modifier) {
+                UIKitView(
+                    modifier = Modifier.fillMaxSize(),
+                    properties = UIKitInteropProperties(placedAsOverlay = placedAsOverlay),
+                    factory = {
+                        CompatibleAnimationView(value).apply {
+                            translatesAutoresizingMaskIntoConstraints = true
+
+                            setBackgroundColor(bgColor?.toUIColor() ?: UIColor.clearColor)
+
+                            setLoopAnimationCount(loopCount)
+                            setAnimationSpeed(1.0)
+
+                            if (tintColor != null) {
+                                val uiColor = tintColor.toUIColor()
+                                setColorValue(uiColor,
+                                    CompatibleAnimationKeypath("**.Fill 1.Color")
+                                )
+                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Fill.Color"))
+                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Color"))
+                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke 1.Color"))
+                                setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke.Color"))
+                            }
+
+                            animationView.value = this
+                        }
+                    },
+
+                    update = { view ->
+                        view.setBackgroundColor(bgColor?.toUIColor() ?: UIColor.clearColor)
+                        view.setLoopAnimationCount(loopCount)
+
+                        if (tintColor != null) {
+                            val uiColor = tintColor.toUIColor()
+
+                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Fill 1.Color"))
+                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Fill.Color"))
+                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Color"))
+                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke 1.Color"))
+                            view.setColorValue(uiColor, CompatibleAnimationKeypath("**.Stroke.Color"))
+                        }
+                    }
+                )
+            }
+        }
+    }
+}
+
+fun Color.toUIColor(): UIColor {
+    val argb = this.toArgb()
+
+    val a = ((argb shr 24) and 0xFF) / 255.0
+    val r = ((argb shr 16) and 0xFF) / 255.0
+    val g = ((argb shr 8) and 0xFF) / 255.0
+    val b = (argb and 0xFF) / 255.0
+
+    return UIColor(
+        red = r,
+        green = g,
+        blue = b,
+        alpha = a
+    )
+}
+
+actual fun NativePaint.setColor(color: Color){
+    this.color = color.toArgb()
+}

package/compose/src/iosMain/kotlin/vn/momo/kits/platform/ReservedRegions.ios.kt

@@ -0,0 +1,138 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.uikit.LocalUIViewController
+import androidx.compose.ui.unit.dp
+import kotlinx.cinterop.BetaInteropApi
+import kotlinx.cinterop.CFunction
+import kotlinx.cinterop.COpaquePointer
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.interpretCPointer
+import kotlinx.cinterop.interpretObjCPointer
+import kotlinx.cinterop.interpretObjCPointerOrNull
+import kotlinx.cinterop.invoke
+import kotlinx.cinterop.objcPtr
+import kotlinx.cinterop.reinterpret
+import kotlinx.cinterop.readValue
+import kotlinx.cinterop.useContents
+import platform.CoreGraphics.CGRectZero
+import platform.Foundation.NSArray
+import platform.Foundation.NSSelectorFromString
+import platform.Foundation.NSValue
+import platform.Foundation.valueForKey
+import platform.UIKit.CGRectValue
+import platform.UIKit.UIView
+import platform.UIKit.UIViewAutoresizingFlexibleHeight
+import platform.UIKit.UIViewAutoresizingFlexibleWidth
+import platform.darwin.NSObject
+import platform.Foundation.NSClassFromString
+import platform.posix.RTLD_DEFAULT
+import platform.posix.dlsym
+
+// The API is newer than the SDK Kotlin/Native binds, so it is reached through the runtime.
+@OptIn(ExperimentalForeignApi::class)
+private val regionsOfKind = NSSelectorFromString("reservedRegionsOfKind:")
+
+@OptIn(ExperimentalForeignApi::class)
+private val regionsOfKindOptions = NSSelectorFromString("reservedRegionsOfKind:options:")
+
+// a hinge never goes away, so a positive answer is kept for every later container
+private var isKnownFoldable = false
+
+@OptIn(ExperimentalForeignApi::class, BetaInteropApi::class)
+private fun regionKind(name: String): Any? {
+    // a class object fails `as? NSObjectProtocol` (K/N checks it as an instance), so it is reinterpreted
+    val kindClass = NSClassFromString("UIViewReservedRegionKind")
+        ?.let { interpretObjCPointer<NSObject>(it.objcPtr()) } ?: return null
+    return kindClass.performSelector(NSSelectorFromString(name))
+}
+
+// performSelector cannot pass the NSUInteger options, so objc_msgSend is called with the method's own signature.
+@OptIn(ExperimentalForeignApi::class)
+private val msgSendRegionsOfKindOptions = dlsym(RTLD_DEFAULT, "objc_msgSend")
+    ?.reinterpret<CFunction<(COpaquePointer?, COpaquePointer?, COpaquePointer?, ULong) -> COpaquePointer?>>()
+
+// Apple's foldable check: only a device with a hinge reports a `.division` region, inactive while
+// flat (UIViewReservedRegionQueryOptionsIncludeInactive) but still there. Screen size cannot tell it
+// apart from a large iPhone in landscape or a narrowed window.
+@OptIn(ExperimentalForeignApi::class)
+private fun UIView.hasDivisionRegion(): Boolean {
+    if (window == null || !respondsToSelector(regionsOfKindOptions)) return false
+    val msgSend = msgSendRegionsOfKindOptions ?: return false
+    val kind = regionKind("divisionRegionKind") as? NSObject ?: return false
+    val result = msgSend(
+        interpretCPointer(objcPtr()),
+        regionsOfKindOptions,
+        interpretCPointer(kind.objcPtr()),
+        1uL,
+    )
+    val regions = interpretObjCPointerOrNull<NSArray>(result?.rawValue ?: return false)
+    return (regions?.count ?: 0uL) > 0uL
+}
+
+@OptIn(ExperimentalForeignApi::class)
+private fun UIView.occlusionRegions(target: UIView): List<ReservedRegion> {
+    if (window == null || !respondsToSelector(regionsOfKind)) return emptyList()
+    val kind = regionKind("occlusionRegionKind") ?: return emptyList()
+    val regions = when (val result = performSelector(regionsOfKind, withObject = kind)) {
+        is List<*> -> result
+        is NSArray -> List(result.count.toInt()) { result.objectAtIndex(it.toULong()) }
+        else -> return emptyList()
+    }
+    return regions.mapNotNull { region ->
+        val frame = ((region as? NSObject)?.valueForKey("frame") as? NSValue)?.CGRectValue ?: return@mapNotNull null
+        convertRect(frame, toView = target).useContents {
+            ReservedRegion(origin.x.dp, origin.y.dp, size.width.dp, size.height.dp)
+        }
+    }
+}
+
+// Invisible full-size probe: reading the regions in layoutSubviews makes UIKit run it again
+// when they change, so nothing polls.
+@OptIn(ExperimentalForeignApi::class)
+private class ReservedRegionsProbe(
+    private val onChange: (ReservedRegions) -> Unit,
+) : UIView(frame = CGRectZero.readValue()) {
+    private var last: ReservedRegions? = null
+
+    init {
+        userInteractionEnabled = false
+        autoresizingMask = UIViewAutoresizingFlexibleWidth or UIViewAutoresizingFlexibleHeight
+    }
+
+    override fun layoutSubviews() {
+        super.layoutSubviews()
+        // re-read until found: the window may not report the hinge on the first pass
+        if (!isKnownFoldable) isKnownFoldable = hasDivisionRegion()
+        val regions = ReservedRegions(superview?.let { occlusionRegions(it) } ?: emptyList(), isKnownFoldable)
+        if (regions != last) {
+            last = regions
+            onChange(regions)
+        }
+    }
+
+    override fun didMoveToWindow() {
+        super.didMoveToWindow()
+        setNeedsLayout()
+    }
+}
+
+@OptIn(ExperimentalForeignApi::class)
+@Composable
+internal actual fun rememberReservedRegions(): ReservedRegions {
+    if (!isPhoneIdiom()) return ReservedRegions()
+    val host = LocalUIViewController.current.view
+    var regions by remember { mutableStateOf(ReservedRegions(isFoldable = isKnownFoldable)) }
+    DisposableEffect(host) {
+        val probe = ReservedRegionsProbe { regions = it }
+        probe.setFrame(host.bounds)
+        host.insertSubview(probe, atIndex = 0)
+        onDispose { probe.removeFromSuperview() }
+    }
+    return regions
+}

package/gradle/libs.versions.toml

@@ -0,0 +1,68 @@
+[versions]
+android-compileSdk = "37"
+android-minSdk = "24"
+android-targetSdk = "36"
+ktor-version = "3.0.0-rc-1"
+coroutines = "1.9.0"
+kotlin = "2.3.10"
+kSerialize = "1.7.1"
+compose = "1.10.3"
+navigation-multiplatform = "2.9.2"
+coil3-multiplatform = "3.0.0-alpha10"
+androidGradlePlugin = "9.2.1"
+r8 = "8.9.35"
+kotlinx-datetime = "0.7.1"
+airbnb-lottie = "5.2.0"
+compottie = "2.1.0"
+androidx-activity = "1.9.1"
+androidx-appcompat = "1.7.0"
+material = "1.10.0"
+vanniktechMavenPublish = "0.34.0"
+kits = "0.167.1-duo.1"
+nativemaxapi = "0.3.11"
+gif-image = "0.1.2"
+
+[libraries]
+ktor-client-core = { group = "io.ktor", name = "ktor-client-core", version.ref = "ktor-version" }
+ktor-client-darwin = { group = "io.ktor", name = "ktor-client-darwin", version.ref = "ktor-version" }
+ktor-client-okhttp = { group = "io.ktor", name = "ktor-client-okhttp", version.ref = "ktor-version" }
+jetbrains-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutines" }
+jetbrains-coroutines-core = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-core", version.ref = "coroutines" }
+jetbrains-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutines" }
+jetbrains-serialization = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization", version.ref = "kSerialize" }
+jetbrains-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kSerialize" }
+kotlinx-datetime = { group = "org.jetbrains.kotlinx", name = "kotlinx-datetime", version.ref = "kotlinx-datetime" }
+compose-ui-backhandler = { module = "org.jetbrains.compose.ui:ui-backhandler", version.ref = "compose" }
+navigation-multiplatform = { module = "org.jetbrains.androidx.navigation:navigation-compose", version.ref = "navigation-multiplatform" }
+coil-multiplatform-core = { module = "io.coil-kt.coil3:coil-core", version.ref = "coil3-multiplatform" }
+coil-multiplatform-compose = { module = "io.coil-kt.coil3:coil-compose", version.ref = "coil3-multiplatform" }
+coil-multiplatform-network-ktor = { module = "io.coil-kt.coil3:coil-network-ktor3", version.ref = "coil3-multiplatform" }
+r8 = { module = "com.android.tools:r8", version.ref = "r8" }
+airbnb-lottie = { group = "com.airbnb.android", name = "lottie-compose", version.ref = "airbnb-lottie" }
+# Depend on compottie-core (not the `compottie` umbrella). The umbrella drags in the
+# separate `keight` umbrella artifact, which collides with `keight-core` on the
+# `findRoot__at__ScriptRuntime` symbol (duplicate symbol at the iOS `ld` link of
+# shared.framework). compottie-core pulls only `keight-core` (which declares
+# keight.js.JsAny, so the earlier unlinked-symbol error stays fixed too).
+compottie = { module = "io.github.alexzhirkevich:compottie-core", version.ref = "compottie" }
+native-max-api = { group = "vn.momo.maxapi", name = "NativeMaxApi", version.ref = "nativemaxapi" }
+kits = { module = "vn.momo.kits:kits", version.ref = "kits" }
+androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "androidx-appcompat" }
+androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activity" }
+material = { module = "com.google.android.material:material", version.ref = "material" }
+
+gif-image = { module = "vn.momo.kits:gif-image", version.ref = "gif-image" }
+[plugins]
+jetbrains-kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+jetbrains-kotlin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
+jetbrains-kotlin-cocoapods = { id = "org.jetbrains.kotlin.native.cocoapods", version.ref = "kotlin" }
+jetbrains-kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+jetbrains-kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+kotlin-compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+compose = { id = "org.jetbrains.compose", version.ref = "compose" }
+android-library = { id = "com.android.library", version.ref = "androidGradlePlugin" }
+android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }
+vanniktech-mavenPublish = { id = "com.vanniktech.maven.publish", version.ref = "vanniktechMavenPublish" }
+
+android-kotlin-multiplatform-library = { id = "com.android.kotlin.multiplatform.library", version.ref = "androidGradlePlugin" }

package/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,8 @@
+#Thu Jul 31 17:05:40 ICT 2025
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/gradle.properties

@@ -0,0 +1,26 @@
+#Kotlin
+kotlin.code.style=official
+kotlin.daemon.jvmargs=-Xmx6144M
+
+#Gradle
+org.gradle.jvmargs=-Xmx8192M -Dfile.encoding=UTF-8
+org.gradle.configuration-cache=false
+org.gradle.caching=true
+
+#Android
+android.nonTransitiveRClass=true
+android.useAndroidX=true
+
+#KMP
+kotlin.apple.xcodeCompatibility.nowarn=true
+
+# Publishing
+name="ComposeKits"
+group=vn.momo.kits
+artifact.id=kits
+version=0.300.5
+
+repo=GitLab
+url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven
+gitlab.user=
+gitlab.password=