@momo-kits/native-kits 0.157.7-debug → 0.157.8-debug

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.157.7-debug"
+        version = "0.157.8-debug"
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"

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

@@ -41,8 +41,10 @@ import vn.momo.kits.const.AppTheme
 import vn.momo.kits.const.Colors
 import vn.momo.kits.const.Radius
 import vn.momo.kits.const.Spacing
+import vn.momo.kits.application.ApplicationContext
 import vn.momo.kits.application.IsShowBaseLineDebug
 import vn.momo.kits.const.Typography
+import vn.momo.kits.navigation.tracking.ScreenTracker
 import vn.momo.kits.modifier.conditional
 import vn.momo.kits.modifier.noFeedbackClickable
 import vn.momo.kits.platform.BackHandler
@@ -70,6 +72,18 @@ internal fun BottomSheet(
 
     val coroutineScope = rememberCoroutineScope()
 
+    val maxApi = LocalMaxApi.current
+    val context = ApplicationContext.current
+
+    DisposableEffect(Unit) {
+        ScreenTracker.trackPopupDisplayed(
+            maxApi = maxApi,
+            context = context,
+            parentScreenName = ScreenTracker.getLastScreenName()
+        )
+        onDispose { }
+    }
+
     suspend fun openEvent(){
         backgroundAlpha.animateTo(
             targetValue = 0.3f,
@@ -236,4 +250,4 @@ sealed class BottomHeader {
     data class Custom(
         val content: @Composable () -> Unit
     ) : BottomHeader()
-}
+}

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

@@ -22,10 +22,12 @@ import androidx.compose.ui.draw.scale
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 import kotlinx.coroutines.launch
+import vn.momo.kits.application.ApplicationContext
 import vn.momo.kits.application.IsShowBaseLineDebug
 import vn.momo.kits.const.Colors
 import vn.momo.kits.modifier.conditional
 import vn.momo.kits.modifier.noFeedbackClickable
+import vn.momo.kits.navigation.tracking.ScreenTracker
 import vn.momo.kits.platform.BackHandler
 
 @Composable
@@ -41,6 +43,18 @@ internal fun ModalScreen(
 
     val coroutineScope = rememberCoroutineScope()
 
+    val maxApi = LocalMaxApi.current
+    val context = ApplicationContext.current
+
+    DisposableEffect(Unit) {
+        ScreenTracker.trackPopupDisplayed(
+            maxApi = maxApi,
+            context = context,
+            parentScreenName = ScreenTracker.getLastScreenName()
+        )
+        onDispose { }
+    }
+
     fun openEvent() {
         coroutineScope.launch {
             launch {
@@ -116,4 +130,4 @@ internal fun ModalScreen(
             content()
         }
     }
-}
+}

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

@@ -72,6 +72,7 @@ val LocalNavigation = staticCompositionLocalOf<Navigation> {
 
 @Stable
 data class NavigationOptions(
+    val screenName: String? = null,
     val onBackHandler: (() -> Unit)? = null,
     val hiddenBack: Boolean = false,
     val headerBackProps: HeaderBackProps = HeaderBackProps(),

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

@@ -38,6 +38,7 @@ import vn.momo.maxapi.IMaxApi
 
 @Composable
 fun NavigationContainer(
+    initialScreenName: String,
     initialScreen: @Composable () -> Unit,
     options: NavigationOptions? = null,
     initialTheme: Theme = defaultTheme,
@@ -73,7 +74,7 @@ fun NavigationContainer(
         }
     }
 
-    val startDestination = DynamicScreenRegistry.register(initialScreen, options)
+    val startDestination = DynamicScreenRegistry.register(initialScreenName, initialScreen, options)
 
     CompositionLocalProvider(
         LocalNavigator provides navigator,
@@ -112,6 +113,7 @@ fun NavigationContainer(
                 if (screen != null){
                     StackScreen(
                         id = route.id,
+                        name = screen.name,
                         content = screen.content,
                         navigationOptions = screen.options
                     )
@@ -140,6 +142,7 @@ fun NavigationContainer(
                 if (screen != null){
                     StackScreen(
                         id = route.id,
+                        name = screen.name,
                         content = screen.content,
                         navigationOptions = screen.options
                     )

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

@@ -28,17 +28,17 @@ class Navigator(
 ) {
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
 
-    fun push(content: @Composable () -> Unit, options: NavigationOptions? = null) {
-        val route = DynamicScreenRegistry.register(content, options)
+    fun push(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
+        val route = DynamicScreenRegistry.register(screenName, content, options)
         navController.navigate(DynamicScreenRoute(route.id))
     }
 
-    fun replace(content: @Composable () -> Unit, options: NavigationOptions? = null) {
+    fun replace(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
         if (navController.previousBackStackEntry != null){
             val latestScreen = DynamicScreenRegistry.getLatestScreen()
             latestScreen?.let { DynamicScreenRegistry.unregisterScreen(it.id) }
             navController.popBackStack()
-            push(content, options)
+            push(screenName, content, options)
         }
     }
 
@@ -103,15 +103,15 @@ class Navigator(
         }
     }
 
-    fun present(content: @Composable () -> Unit, options: NavigationOptions? = null) {
-        val route = DynamicScreenRegistry.register(content, options)
+    fun present(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
+        val route = DynamicScreenRegistry.register(screenName, content, options)
         navController.navigate(DynamicDialogRoute(route.id))
     }
 
-    fun reset(content: @Composable () -> Unit, options: NavigationOptions? = null) {
+    fun reset(screenName: String, content: @Composable () -> Unit, options: NavigationOptions? = null) {
         DynamicScreenRegistry.unregisterAll()
 
-        val route = DynamicScreenRegistry.register(content, options)
+        val route = DynamicScreenRegistry.register(screenName, content, options)
         navController.navigate(DynamicScreenRoute(route.id)) {
             popUpTo(0) { inclusive = true }
         }
@@ -176,6 +176,7 @@ data class DynamicDialogRoute(val id: Int)
 
 data class DynamicScreen(
     val id: Int,
+    val name: String,
     val content: @Composable () -> Unit,
     var options: NavigationOptions? = null
 )
@@ -184,10 +185,11 @@ object DynamicScreenRegistry {
     private val screens = mutableMapOf<Int, DynamicScreen>()
     private var idCounter = 1
 
-    fun register(content: @Composable () -> Unit, options: NavigationOptions?): DynamicScreenRoute {
+    fun register(screenName: String, content: @Composable () -> Unit, options: NavigationOptions?): DynamicScreenRoute {
         val id = idCounter++
         screens[id] = DynamicScreen(
             id = id,
+            name = screenName,
             content = content,
             options = options
         )

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

@@ -63,26 +63,81 @@ import vn.momo.kits.navigation.component.HeaderType
 import vn.momo.kits.navigation.component.InputSearchType
 import vn.momo.kits.platform.BackHandler
 import vn.momo.kits.platform.getAndroidBuildVersion
+import vn.momo.kits.navigation.tracking.ScreenTracker
+import vn.momo.kits.navigation.tracking.ScreenTrackingState
+import kotlinx.coroutines.delay
+import vn.momo.kits.application.ApplicationContext
+import kotlin.time.Clock
+import kotlin.time.ExperimentalTime
 
 internal val LocalFooterHeightPx = staticCompositionLocalOf { mutableIntStateOf(0) }
 internal val LocalHeaderRightWidthPx = staticCompositionLocalOf { mutableIntStateOf(0) }
 
-@OptIn(ExperimentalMaterialApi::class)
+@OptIn(ExperimentalMaterialApi::class, ExperimentalTime::class)
 @Composable
 internal fun StackScreen(
     content: @Composable () -> Unit,
     navigationOptions: NavigationOptions? = null,
     id: Int = -1,
+    name: String = "",
     bottomTabIndex: Int = -1,
     onBackHandler: (() -> Unit)? = null,
 ) {
     val navigator = LocalNavigator.current
+    val maxApi = LocalMaxApi.current
+    val context = ApplicationContext.current
     val statusBar = AppStatusBar.current
     val density = LocalDensity.current
     val navigation = remember { Navigation(id = id, bottomTabIndex = bottomTabIndex, initOptions = navigationOptions) }
 
     val options by navigation.currentOptions
 
+    // Auto tracking state
+    val trackingState = remember {
+        ScreenTrackingState().apply {
+            startTime = Clock.System.now().toEpochMilliseconds()
+        }
+    }
+
+    // Determine action: push or back
+    val action = remember {
+        if (ScreenTracker.getLastScreenName() != null) "push" else "back"
+    }
+
+    // Auto tracking effects
+    LaunchedEffect(name) {
+        // Track screen navigated immediately
+        ScreenTracker.trackScreenNavigated(
+            maxApi = maxApi,
+            context = context,
+            screenName = name,
+            action = action,
+            state = trackingState
+        )
+
+        // Track screen displayed after 2 seconds (debounce)
+        delay(2000)
+        val loadTime = Clock.System.now().toEpochMilliseconds() - trackingState.startTime
+        ScreenTracker.trackScreenDisplayed(
+            maxApi = maxApi,
+            context = context,
+            screenName = name,
+            duration = loadTime,
+            state = trackingState
+        )
+
+        // Track screen interacted after displayed
+        val interactionTime = Clock.System.now().toEpochMilliseconds() - trackingState.startTime
+        ScreenTracker.trackScreenInteracted(
+            maxApi = maxApi,
+            context = context,
+            screenName = name,
+            duration = interactionTime - loadTime,
+            totalDuration = interactionTime,
+            state = trackingState
+        )
+    }
+
     val limit = with(density) {
         (statusBar).toPx() + HEADER_HEIGHT
     }.toInt()

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

@@ -0,0 +1,167 @@
+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
+
+/**
+ * Screen tracking state holder
+ */
+class ScreenTrackingState {
+    @OptIn(ExperimentalTime::class)
+    var startTime: Long = Clock.System.now().toEpochMilliseconds()
+    var endTime: Long = startTime
+    var releaseNavigated: Boolean = false
+    var releaseLoad: Boolean = false
+    var releaseInteraction: Boolean = false
+    var previousScreenName: String? = null
+    var action: String = "push"
+}
+
+/**
+ * Screen tracker for auto tracking events
+ *
+ * Tracks 3 main events:
+ * - auto_screen_navigated: When screen is focused
+ * - auto_screen_displayed: When screen finished loading
+ * - auto_screen_interacted: When screen is ready for interaction
+ */
+object ScreenTracker {
+
+    private var lastScreenName: String? = null
+
+    /**
+     * Track screen navigation event
+     * Called when screen is focused
+     */
+    fun trackScreenNavigated(
+        maxApi: IMaxApi?,
+        context: MiniAppContext?,
+        screenName: String,
+        action: String,
+        state: ScreenTrackingState
+    ) {
+        if (state.releaseNavigated) return
+
+        val previousScreen = lastScreenName
+        lastScreenName = screenName
+
+        println("Tracking screen navigated native kit: $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
+    }
+
+    /**
+     * Track screen displayed event
+     * Called when screen finished loading all elements
+     */
+    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
+    }
+
+    /**
+     * Track screen interacted event
+     * Called when screen is ready for user interaction
+     */
+    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
+    }
+
+    /**
+     * Build base tracking params from MiniAppContext
+     */
+    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
+        )
+    }
+
+    /**
+     * Track popup/modal displayed event
+     *
+     * @param popupName name of the popup/modal
+     * @param parentScreenName the screen that shows the popup
+     */
+    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"
+            )
+        )
+    }
+
+    /**
+     * Get previous screen name for back navigation detection
+     */
+    fun getLastScreenName(): String? = lastScreenName
+
+    /**
+     * Reset tracker (for testing or cleanup)
+     */
+    @Suppress("UNUSED")
+    fun reset() {
+        lastScreenName = null
+    }
+}

package/gradle.properties

@@ -18,7 +18,7 @@ kotlin.apple.xcodeCompatibility.nowarn=true
 name="ComposeKits"
 group=vn.momo.kits
 artifact.id=kits
-version=0.157.7
+version=0.157.8
 
 repo=GitLab
 url=https://gitlab.mservice.com.vn/api/v4/projects/5400/packages/maven

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.157.7-debug",
+  "version": "0.157.8-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},