@momo-kits/native-kits 0.300.6-debug → 0.300.6

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

@@ -1,217 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,68 +0,0 @@
-[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.13"
-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

@@ -1,8 +0,0 @@
-#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

@@ -1,26 +0,0 @@
-#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.6
-
-repo=GitLab
-url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven
-gitlab.user=
-gitlab.password=