@momo-kits/native-kits 0.162.2-test.3-debug → 0.162.2-test.5-debug

package/compose/build.gradle.kts

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

package/compose/build.gradle.kts.backup

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.161.0-debug"
+        version = gitlabVersion
         summary = "IOS Shared module"
         homepage = "https://momo.vn"
         ios.deploymentTarget = "15.0"
@@ -86,14 +86,14 @@ kotlin {
 }
 
 android {
-    namespace = "vn.momo.kits.kits"
-    compileSdk = 35
+    namespace = "$gitlabGroup.$gitlabArtifactId"
+    compileSdk = libs.versions.android.compileSdk.get().toInt()
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
     }
     defaultConfig {
-        minSdk = 24
+        minSdk = libs.versions.android.minSdk.get().toInt()
     }
 }
 

package/compose/src/commonMain/kotlin/vn/momo/kits/application/Context.kt

@@ -28,6 +28,7 @@ data class MiniAppContext(
     val providerId: String = "",
     val permissions: List<Map<String, Any>>? = emptyList(),
     val features: FeatureFlags? = null,
+    val fontScaleConfig: FontScaleConfig? = null,
 ) {
     companion object {
 
@@ -59,6 +60,7 @@ data class MiniAppContext(
                 providerId = parent.providerId.ifBlank { child.providerId },
                 permissions = if (!parent.permissions.isNullOrEmpty()) parent.permissions else child.permissions,
                 features = mergeFeatureFlags(parent.features, child.features),
+                fontScaleConfig = parent.fontScaleConfig ?: child.fontScaleConfig,
             )
         }
 
@@ -102,4 +104,13 @@ val AppLanguage = staticCompositionLocalOf<String?> {
 
 val LocalComponentInformation = staticCompositionLocalOf<ComponentInformation?> {
     null
-}
+}
+
+@Immutable
+data class FontScaleConfig(
+    val useOSFontScale: Boolean = false,
+    val userScaleRate: Float? = null,
+)
+
+// Single source of truth: chứa cả flag OS lẫn rate user tự chỉnh.
+val LocalFontScaleConfig = staticCompositionLocalOf { FontScaleConfig() }

package/compose/src/commonMain/kotlin/vn/momo/kits/components/Text.kt

@@ -40,6 +40,7 @@ fun Text(
     softWrap: Boolean = true,
     accessibilityId: String? = null,
     inlineContent: Map<String, InlineTextContent> = mapOf(),
+    userScaleRate: Float? = null,
     ) {
     Text(
         text = AnnotatedString(text),
@@ -56,7 +57,8 @@ fun Text(
         letterSpacing = letterSpacing,
         softWrap = softWrap,
         accessibilityId = accessibilityId,
-        inlineContent = inlineContent
+        inlineContent = inlineContent,
+        userScaleRate = userScaleRate
     )
 }
 
@@ -78,13 +80,14 @@ fun Text(
     softWrap: Boolean = true,
     accessibilityId: String? = null,
     inlineContent: Map<String, InlineTextContent> = mapOf(),
+    userScaleRate: Float? = null,
 ) {
     // Cache theme access to avoid repeated lookups
     val theme = AppTheme.current
 
     // Call @Composable functions directly in composable context
-    val scaledFontSize = scaleSize(style.fontSize)
-    val scaledLineHeight = scaleSize(style.lineHeight)
+    val scaledFontSize = scaleSize(style.fontSize, userScaleRate)
+    val scaledLineHeight = scaleSize(style.lineHeight, userScaleRate)
     val fontFamilyResult = getFontFamily(fontFamily ?: theme.font, style.fontWeight)
 
     // Now memoize the results

package/compose/src/commonMain/kotlin/vn/momo/kits/const/Typography.kt

@@ -15,7 +15,7 @@ import androidx.compose.ui.unit.sp
 import org.jetbrains.compose.resources.Font
 import org.jetbrains.compose.resources.FontResource
 import org.jetbrains.compose.resources.InternalResourceApi
-import vn.momo.kits.application.FontScaleStore
+import vn.momo.kits.application.LocalFontScaleConfig
 import vn.momo.kits.platform.getScreenDimensions
 import vn.momo.uikits.resources.Res
 import vn.momo.uikits.resources.momosignature
@@ -37,9 +37,13 @@ const val MAX_FONT_SCALE = 1.5f
 const val MAX_DEVICE_SCALE = 5
 
 @Composable
-fun scaleSize(size: Float): Float {
-    val useDeviceFontScale = FontScaleStore.useDeviceFontScale
-    val appFontScale = FontScaleStore.appFontScale
+fun scaleSize(size: Float, userScaleRate: Float? = null): Float {
+    // single source of truth: useOSFontScale + userScaleRate cùng lấy từ LocalFontScaleConfig
+    val fontScaleConfig = LocalFontScaleConfig.current
+    val useOSFontScale = fontScaleConfig.useOSFontScale
+    // param userScaleRate override config; không có -> config.userScaleRate -> 1f (không scale)
+    val customRate = userScaleRate ?: fontScaleConfig.userScaleRate ?: 1f
+
     val deviceWidth = getScreenDimensions().width
     val deviceScale = deviceWidth / DEFAULT_SCREEN_SIZE
 
@@ -54,12 +58,11 @@ fun scaleSize(size: Float): Float {
             min(deviceScale * fontSizeScaleDevice, fontSizeScaleDevice + MAX_DEVICE_SCALE)
     }
 
-    if (useDeviceFontScale) {
-        if (fontScale > 1) {
-            fontSizeScaleOS = min(fontScale * fontSizeScaleOS, fontSizeScaleOS * MAX_FONT_SCALE)
-        }
-    } else {
-        fontSizeScaleOS = size * appFontScale
+    // useOSFontScale bật -> lấy scale của OS đè lên, ignore custom rate của user.
+    // tắt -> dùng custom rate user tự chỉnh. Cap cứng MAX_FONT_SCALE (150%) cả hai.
+    val appliedRate = if (useOSFontScale) fontScale else customRate
+    if (appliedRate > 1f) {
+        fontSizeScaleOS = min(appliedRate * fontSizeScaleOS, fontSizeScaleOS * MAX_FONT_SCALE)
     }
 
     return max(
@@ -69,32 +72,32 @@ fun scaleSize(size: Float): Float {
 }
 
 @Composable
-fun scaleSize(size: TextUnit): TextUnit {
+fun scaleSize(size: TextUnit, userScaleRate: Float? = null): TextUnit {
     if (!size.isSp) return size
 
     val density = LocalDensity.current
 
-    val scaled = scaleSize(size.value)
+    val scaled = scaleSize(size.value, userScaleRate)
     val spValue = scaled / density.fontScale
 
     return TextUnit(value = spValue, type = TextUnitType.Sp)
 }
 
 @Composable
-fun scaleSize(size: Dp): Dp {
-    return scaleSize(size.value).dp
+fun scaleSize(size: Dp, userScaleRate: Float? = null): Dp {
+    return scaleSize(size.value, userScaleRate).dp
 }
 
 @Composable
-fun scaleSize(textStyle: TextStyle): TextStyle {
+fun scaleSize(textStyle: TextStyle, userScaleRate: Float? = null): TextStyle {
     return textStyle.copy(
         fontSize = if (textStyle.fontSize != TextUnit.Unspecified)
-            scaleSize(textStyle.fontSize)
+            scaleSize(textStyle.fontSize, userScaleRate)
         else
             TextUnit.Unspecified,
 
         lineHeight = if (textStyle.lineHeight != TextUnit.Unspecified)
-            scaleSize(textStyle.lineHeight)
+            scaleSize(textStyle.lineHeight, userScaleRate)
         else
             TextUnit.Unspecified,
     )

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

@@ -9,6 +9,7 @@ import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.toRoute
+import kotlinx.coroutines.flow.collect
 import vn.momo.kits.application.*
 import vn.momo.kits.const.*
 import vn.momo.kits.platform.ProvideNavigationEventDispatcherOwner
@@ -37,6 +38,23 @@ fun NavigationContainer(
     val parentContext = ApplicationContext.current
     val mergedContext = MiniAppContext.merge(parentContext, applicationContext)
 
+    // FontScaleConfig host ghi xuống observer storage (single source of truth khi có).
+    var observerFontScaleConfig by remember { mutableStateOf<FontScaleConfig?>(null) }
+    LaunchedEffect(maxApi) {
+        val api = maxApi ?: return@LaunchedEffect
+        // getDataObserver = snapshot lúc mount; observer = subscribe các lần host ghi sau đó.
+        runCatching {
+            api.getDataObserver(FONT_SCALE_OBSERVER_KEY) { data ->
+                parseFontScaleConfig(data)?.let { observerFontScaleConfig = it }
+            }
+        }
+        runCatching {
+            api.observer(FONT_SCALE_OBSERVER_KEY).collect { data ->
+                observerFontScaleConfig = parseFontScaleConfig(data)
+            }
+        }
+    }
+
     val theme = remember { mutableStateOf(initialTheme) }
 
     LaunchedEffect(Unit) {
@@ -64,6 +82,7 @@ fun NavigationContainer(
             ApplicationContext provides mergedContext,
             AppConfig provides config,
             AppLanguage provides language,
+            LocalFontScaleConfig provides (observerFontScaleConfig ?: mergedContext?.fontScaleConfig ?: LocalFontScaleConfig.current),
         ) {
             LaunchedEffect(Unit) {
                 setNavigator?.invoke(navigator)
@@ -142,3 +161,28 @@ fun NavigationContainer(
 val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> {
     error("No MaxApi provided")
 }
+
+// Key observer storage host app ghi FontScaleConfig. Native lowercase key.
+private const val FONT_SCALE_OBSERVER_KEY = "font_scale_config"
+
+// Host trả object {useOSFontScale, userScaleRate}; phòng marshaling bọc envelope / lệch kiểu.
+private fun parseFontScaleConfig(raw: Map<String, Any?>?): FontScaleConfig? {
+    if (raw.isNullOrEmpty()) return null
+    @Suppress("UNCHECKED_CAST")
+    val data = (raw["response"] as? Map<String, Any?>)
+        ?: (raw["data"] as? Map<String, Any?>)
+        ?: raw
+    if (!data.containsKey("useOSFontScale") && !data.containsKey("userScaleRate")) return null
+    val useOS = when (val v = data["useOSFontScale"]) {
+        is Boolean -> v
+        is String -> v.equals("true", ignoreCase = true)
+        is Number -> v.toInt() != 0
+        else -> false
+    }
+    val rate = when (val v = data["userScaleRate"]) {
+        is Number -> v.toFloat()
+        is String -> v.toFloatOrNull()
+        else -> null
+    }
+    return FontScaleConfig(useOSFontScale = useOS, userScaleRate = rate)
+}

package/gradle.properties

@@ -18,7 +18,7 @@ kotlin.apple.xcodeCompatibility.nowarn=true
 name="ComposeKits"
 group=vn.momo.kits
 artifact.id=kits
-version=0.162.2-test.3
+version=0.162.2-test.5
 
 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.162.2-test.3-debug",
+  "version": "0.162.2-test.5-debug",
   "private": false,
   "dependencies": {},
   "devDependencies": {},

package/compose/src/commonMain/kotlin/vn/momo/kits/application/FontScaleStore.kt

@@ -1,91 +0,0 @@
-package vn.momo.kits.application
-
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.launch
-import vn.momo.maxapi.IMaxApi
-
-private const val KEY_USE_DEVICE_FONT_SCALE = "use_device_font_scale"
-private const val KEY_APP_FONT_SCALE = "app_font_scale"
-private const val MIN_APP_FONT_SCALE = 1f
-private const val MAX_APP_FONT_SCALE = 1.5f
-
-/**
- * Single in-memory mirror of the Observer Storage font-scale source of truth
- * (keys [KEY_USE_DEVICE_FONT_SCALE] + [KEY_APP_FONT_SCALE]).
- *
- * scaleSize() reads this holder directly, so every Compose subtree across all
- * NavigationContainer roots reacts to a change at once — no per-root wiring.
- *
- * [start] subscribes once to storage through the given [IMaxApi]: it seeds the
- * current value (the observer Flow only replays emissions made after subscribe),
- * then collects live changes. The subscription lives on its own scope, so it
- * survives navigation between screens. The caller must pass a real (adapter-backed)
- * IMaxApi — a NoopMaxApi emits a single error frame, which is ignored here.
- */
-object FontScaleStore {
-
-    var useDeviceFontScale by mutableStateOf(true)
-        private set
-    var appFontScale by mutableStateOf(1f)
-        private set
-
-    private var started = false
-    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
-
-    fun start(maxApi: IMaxApi) {
-        if (started) return
-        started = true
-
-        // Seed current persisted value.
-        maxApi.getDataObserver(KEY_USE_DEVICE_FONT_SCALE) { map ->
-            parseUseDevice(map)?.let { useDeviceFontScale = it }
-        }
-        maxApi.getDataObserver(KEY_APP_FONT_SCALE) { map ->
-            parseScale(map)?.let { appFontScale = it }
-        }
-
-        // Live updates.
-        scope.launch {
-            maxApi.observer(KEY_USE_DEVICE_FONT_SCALE).collect { map ->
-                parseUseDevice(map)?.let { useDeviceFontScale = it }
-            }
-        }
-        scope.launch {
-            maxApi.observer(KEY_APP_FONT_SCALE).collect { map ->
-                parseScale(map)?.let { appFontScale = it }
-            }
-        }
-    }
-
-    /**
-     * Callback map = serialized MaxApiResponse flattened: { status, response, errorCode, ... }.
-     * A stored string scalar arrives under "response" as a String ("1.5" / "false").
-     * Returns null for error frames (e.g. adapter-not-bound) and unset keys.
-     */
-    private fun response(map: Map<String, Any?>?): Any? {
-        if (map == null) return null
-        val errorCode = (map["errorCode"] as? Number)?.toInt() ?: 0
-        if (errorCode != 0) return null
-        return map["response"]
-    }
-
-    private fun parseScale(map: Map<String, Any?>?): Float? {
-        val value = when (val r = response(map)) {
-            is Number -> r.toFloat()
-            is String -> r.toFloatOrNull()
-            else -> null
-        } ?: return null
-        return value.coerceIn(MIN_APP_FONT_SCALE, MAX_APP_FONT_SCALE)
-    }
-
-    private fun parseUseDevice(map: Map<String, Any?>?): Boolean? = when (val r = response(map)) {
-        is Boolean -> r
-        is String -> r.toBooleanStrictOrNull()
-        else -> null
-    }
-}