@momo-kits/native-kits 0.167.1-duo.8 → 0.167.1-duo.9-debug

package/compose/src/commonMain/kotlin/vn/momo/kits/navigation/tracking/ScreenTracker.kt

@@ -0,0 +1,127 @@
+package vn.momo.kits.navigation.tracking
+
+import vn.momo.kits.application.MiniAppContext
+import vn.momo.maxapi.IMaxApi
+import kotlin.time.Clock
+import kotlin.time.ExperimentalTime
+
+class ScreenTrackingState {
+    @OptIn(ExperimentalTime::class)
+    var time: Long = Clock.System.now().toEpochMilliseconds()
+    var releaseNavigated: Boolean = false
+    var releaseLoad: Boolean = false
+    var releaseInteraction: Boolean = false
+    var previousScreenName: String? = null
+    var action: String = "push"
+}
+
+object ScreenTracker {
+
+    private var lastScreenName: String? = null
+
+    fun trackScreenNavigated(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        action: String,
+        state: ScreenTrackingState
+    ) {
+        if (state.releaseNavigated) return
+
+        val previousScreen = lastScreenName
+        lastScreenName = screenName
+
+        maxApi?.track(
+            eventName = "auto_screen_navigated",
+            params = buildBaseParams(context, screenName).apply {
+                put("pre_screen_name", previousScreen)
+                put("state", "navigated")
+                put("action", action)
+            }
+        )
+
+        state.releaseNavigated = true
+        state.previousScreenName = previousScreen
+    }
+
+    fun trackScreenDisplayed(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Long,
+        state: ScreenTrackingState
+    ) {
+        if (state.releaseLoad) return
+
+        maxApi?.track(
+            eventName = "auto_screen_displayed",
+            params = buildBaseParams(context, screenName).apply {
+                put("state", "load")
+                put("duration", duration)
+            }
+        )
+
+        state.releaseLoad = true
+    }
+
+    fun trackScreenInteracted(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        duration: Long,
+        totalDuration: Long,
+        state: ScreenTrackingState
+    ) {
+        if (state.releaseInteraction) return
+
+        maxApi?.track(
+            eventName = "auto_screen_interacted",
+            params = buildBaseParams(context, screenName).apply {
+                put("state", "interaction")
+                put("duration", duration)
+                put("total_duration", totalDuration)
+            }
+        )
+
+        state.releaseInteraction = true
+    }
+
+    private fun buildBaseParams(
+        context: MiniAppContext?,
+        screenName: String,
+        componentName: String = "Screen"
+    ): MutableMap<String, Any?> {
+        return mutableMapOf(
+            "app_id" to context?.appId,
+            "feature_code" to context?.appCode,
+            "screen_name" to screenName,
+            "component_name" to componentName,
+            "tracking_source" to 1
+        )
+    }
+
+    fun trackPopupDisplayed(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        parentScreenName: String?
+    ) {
+        maxApi?.track(
+            eventName = "auto_popup_displayed",
+            params = mutableMapOf<String, Any?>(
+                "screen_name" to parentScreenName,
+                "tracking_source" to 1,
+                "app_id" to context?.appId,
+                "feature_code" to context?.appCode,
+                "kits_version" to null,
+                "component_name" to "Modal"
+            )
+        )
+    }
+
+    fun getLastScreenName(): String? = lastScreenName
+
+    @Suppress("UNUSED")
+    fun reset() {
+        lastScreenName = null
+    }
+}

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/BackGesture.kt

@@ -0,0 +1,12 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+
+/** Fraction of container width, `null` when idle. Observe only — consuming would steal the
+ *  gesture from NavHost. Always `null` on Android. */
+@Composable
+expect fun rememberBackGestureProgress(): State<Float?>
+
+/** Android is a no-op: no host-owned recogniser to hand the gesture to. */
+expect fun reportFloatingArrowBack(shouldUse: Boolean)

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/ComposeLottieAnimation.kt

@@ -0,0 +1,91 @@
+package vn.momo.kits.platform
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import io.github.alexzhirkevich.compottie.ExperimentalCompottieApi
+import io.github.alexzhirkevich.compottie.LottieCompositionSpec
+import io.github.alexzhirkevich.compottie.animateLottieCompositionAsState
+import io.github.alexzhirkevich.compottie.dynamic.rememberLottieDynamicProperties
+import io.github.alexzhirkevich.compottie.rememberLottieComposition
+import io.github.alexzhirkevich.compottie.rememberLottiePainter
+import vn.momo.kits.utils.readJson
+
+@OptIn(ExperimentalCompottieApi::class)
+@Composable
+internal fun ComposeLottieAnimation(
+    path: String,
+    tintColor: Color?,
+    bgColor: Color?,
+    iterations: Int,
+    isPlaying: Boolean,
+    onEvent: ((String) -> Unit)?,
+    modifier: Modifier,
+) {
+    val json = readJson(path)
+
+    if (json.isEmpty()) {
+        Box(modifier.background(bgColor ?: Color.Transparent))
+        return
+    }
+
+    val composition by rememberLottieComposition(json) {
+        LottieCompositionSpec.JsonString(json)
+    }
+
+    val dynamicProperties = if (tintColor != null) {
+        rememberLottieDynamicProperties(tintColor) {
+            shapeLayer("**") {
+                fill("**") { color { tintColor } }
+                stroke("**") { color { tintColor } }
+            }
+        }
+    } else {
+        null
+    }
+
+    val lottieState = animateLottieCompositionAsState(
+        composition = composition,
+        iterations = iterations,
+        isPlaying = isPlaying,
+        restartOnPlay = false,
+    )
+
+    val currentOnEvent by rememberUpdatedState(onEvent)
+
+    LaunchedEffect(isPlaying) {
+        currentOnEvent?.invoke(if (isPlaying) LottieEvent.Start else LottieEvent.Pause)
+    }
+
+    LaunchedEffect(lottieState) {
+        var armed = false
+        snapshotFlow { lottieState.isAtEnd }.collect { atEnd ->
+            if (!atEnd) armed = true
+            else if (armed) { armed = false; currentOnEvent?.invoke(LottieEvent.Finish) }
+        }
+    }
+
+    Box(modifier.background(bgColor ?: Color.Transparent)) {
+        Image(
+            painter = rememberLottiePainter(
+                composition = composition,
+                progress = lottieState::value,
+                dynamicProperties = dynamicProperties,
+                enableExpressions = false,
+                expressionEngineFactory = { _, _ ->
+                    error("Lottie JS expressions are disabled in MoMo kits")
+                },
+            ),
+            contentDescription = null,
+            modifier = Modifier.fillMaxSize(),
+        )
+    }
+}

package/compose/src/commonMain/kotlin/vn/momo/kits/platform/OsFontScale.kt

@@ -0,0 +1,9 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+
+// Overrides LocalDensity.fontScale with the live OS Dynamic Type scale so text re-scales while a
+// screen is visible. Wrapped inside the containers so every screen is covered, not just callers of
+// the app-level wrappers.
+@Composable
+expect fun ProvideOsFontScale(content: @Composable () -> Unit)

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

@@ -0,0 +1,74 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.NativePaint
+import androidx.compose.ui.unit.Dp
+import vn.momo.kits.navigation.Navigator
+
+data class ScreenDimension(
+    val width: Int,
+    val height: Int,
+)
+
+expect fun getPlatformName(): String
+
+// iPhone idiom only; iPad windows and Android never get the iPhone / iPhone Duo layout.
+expect fun isPhoneIdiom(): Boolean
+
+@Composable
+expect fun getScreenDimensions(): ScreenDimension
+
+expect fun NativePaint.setMaskFilter(blurRadius: Float)
+
+@Composable
+expect fun getStatusBarHeight(): Dp
+
+@Composable
+expect fun BackHandler(enabled: Boolean, onBack: () -> Unit)
+
+@Suppress("ParamsComparedByRef")
+@Composable
+expect fun ProvideNavigationEventDispatcherOwner(navigator: Navigator, content: @Composable () -> Unit)
+
+@Composable
+expect fun getScreenHeight(): Dp
+
+sealed interface OSVersion {
+    val value: Int
+    data class Android(val sdk: Int) : OSVersion { override val value: Int get() = sdk }
+    data class IOS(val major: Int) : OSVersion { override val value: Int get() = major }
+
+    operator fun compareTo(other: Int): Int = value.compareTo(other)
+}
+expect fun getOSVersion(): OSVersion
+
+fun supportsImePadding(): Boolean = when (val v = getOSVersion()) {
+    is OSVersion.Android -> v.sdk > 29
+    is OSVersion.IOS -> true
+}
+const val LottieIterateForever: Int = Int.MAX_VALUE
+
+object LottieEvent {
+    const val Start = "start"
+    const val Pause = "pause"
+    const val Finish = "finish"
+}
+
+@Composable
+expect fun LottieAnimation(
+    path: String,
+    tintColor: Color? = null,
+    bgColor: Color? = null,
+    placedAsOverlay: Boolean = false,
+    iterations: Int = LottieIterateForever,
+    isPlaying: Boolean = true,
+    onEvent: ((String) -> Unit)? = null,
+    modifier: Modifier = Modifier,
+    useCompose: Boolean = false
+)
+
+expect fun NativePaint.setColor(
+    color: Color = Color.Black
+)

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

@@ -0,0 +1,13 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.ui.unit.Dp
+
+@Immutable
+internal data class ReservedRegion(val x: Dp, val y: Dp, val width: Dp, val height: Dp)
+
+// Regions the system occludes (iOS 27.1+), in the coordinates of the Compose root view: the
+// iPhone Duo camera, and the status bar cluster as it grows for a call or a Live Activity.
+@Composable
+internal expect fun rememberReservedRegions(): List<ReservedRegion>