@momo-kits/native-kits 0.156.6-beta.4 → 0.156.6-dialog.1-debug

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

@@ -0,0 +1,270 @@
+package vn.momo.kits.platform
+
+import android.annotation.SuppressLint
+import android.content.res.Resources
+import android.graphics.BlurMaskFilter
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.os.Build
+import androidx.compose.foundation.layout.Box
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.NativePaint
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import com.airbnb.lottie.LottieProperty
+import com.airbnb.lottie.compose.LottieAnimation
+import com.airbnb.lottie.compose.LottieCompositionSpec
+import com.airbnb.lottie.compose.LottieConstants
+import com.airbnb.lottie.compose.rememberLottieComposition
+import com.airbnb.lottie.compose.rememberLottieDynamicProperties
+import com.airbnb.lottie.compose.rememberLottieDynamicProperty
+import android.graphics.Matrix
+import android.widget.ImageView
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.view.doOnLayout
+import coil3.load
+import coil3.request.crossfade
+import coil3.size.ViewSizeResolver
+import android.view.ViewGroup
+import android.view.WindowManager
+import androidx.compose.runtime.SideEffect
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.window.DialogWindowProvider
+import androidx.core.view.WindowCompat
+import vn.momo.kits.components.Options
+import vn.momo.kits.const.AppNavigationBar
+import vn.momo.kits.const.AppStatusBar
+import vn.momo.kits.utils.readJson
+import androidx.activity.compose.BackHandler as AndroidBackHandler
+
+actual fun getPlatformName(): String = "Android"
+
+@Composable
+actual fun getScreenDimensions(): ScreenDimension {
+    val config = LocalConfiguration.current
+    return ScreenDimension(
+        config.screenWidthDp, config.screenHeightDp
+    )
+}
+
+actual fun NativePaint.setMaskFilter(blurRadius: Float) {
+    this.maskFilter = BlurMaskFilter(blurRadius, BlurMaskFilter.Blur.NORMAL)
+}
+
+@SuppressLint("InternalInsetResource")
+@Composable
+actual fun getStatusBarHeight(): Dp {
+    val resourceId = Resources.getSystem().getIdentifier(
+        "status_bar_height",
+        "dimen",
+        "android"
+    )
+    return if(resourceId > 0) Resources.getSystem().getDimensionPixelSize(resourceId).dp else 0.dp
+}
+
+@Composable
+actual fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
+    AndroidBackHandler(enabled = enabled, onBack = onBack)
+}
+
+@Composable
+actual fun getScreenHeight(): Dp {
+    return getScreenDimensions().height.dp + if (getAndroidBuildVersion() >= 35) 0.dp else AppStatusBar.current + AppNavigationBar.current
+}
+
+@Composable
+actual fun LottieAnimation(
+    path: String,
+    tintColor: Color?,
+    bgColor: Color?,
+    modifier: Modifier
+) {
+    val json = readJson(path)
+
+    if (json.isEmpty()) {
+        Box(modifier)
+        return
+    }
+
+    val composition by rememberLottieComposition(
+        LottieCompositionSpec.JsonString(json)
+    )
+
+    val colorFilter = PorterDuffColorFilter(
+        tintColor?.toArgb() ?: Color.White.toArgb(),
+        PorterDuff.Mode.SRC_ATOP
+    )
+
+    val dynamicProperties = rememberLottieDynamicProperties(
+        rememberLottieDynamicProperty(
+            property = LottieProperty.COLOR_FILTER,
+            value = colorFilter,
+            keyPath = arrayOf("**")
+        )
+    )
+
+    LottieAnimation(
+        composition = composition,
+        iterations = LottieConstants.IterateForever,
+        dynamicProperties = if (tintColor != null) dynamicProperties else null,
+        modifier = modifier
+    )
+}
+
+actual fun NativePaint.setColor(color: Color){
+    this.color = color.toArgb()
+}
+
+actual fun getAndroidBuildVersion(): Int = Build.VERSION.SDK_INT
+
+@Composable
+actual fun NativeImage(
+    source: Any,
+    options: Options,
+    loading: Boolean,
+    onLoading: () -> Unit,
+    onSuccess: () -> Unit,
+    onError: () -> Unit,
+) {
+    val currentOptions by rememberUpdatedState(options)
+
+    AndroidView(
+        modifier = Modifier.fillMaxSize(),
+        factory = { ctx ->
+            ImageView(ctx).apply {
+                adjustViewBounds = false
+
+                addOnLayoutChangeListener { v, _, _, _, _, _, _, _, _ ->
+                    (v as ImageView).apply {
+                        applyOrDefer(currentOptions.contentScale, currentOptions.alignment)
+                        colorFilter = currentOptions.tintColor?.let {
+                            PorterDuffColorFilter(it.toArgb(), PorterDuff.Mode.SRC_ATOP)
+                        }
+                    }
+                }
+            }
+        },
+        update = { imageView ->
+            imageView.alpha = currentOptions.alpha.coerceIn(0f, 1f)
+            imageView.applyOrDefer(currentOptions.contentScale, currentOptions.alignment)
+            imageView.colorFilter = currentOptions.tintColor?.let {
+                PorterDuffColorFilter(it.toArgb(), PorterDuff.Mode.SRC_ATOP)
+            }
+
+            imageView.load(source) {
+                crossfade(loading)
+                size(ViewSizeResolver(imageView))
+                listener(
+                    onStart = { onLoading() },
+                    onSuccess = { _, _ ->
+                        imageView.applyOrDefer(currentOptions.contentScale, currentOptions.alignment)
+                        imageView.colorFilter = currentOptions.tintColor?.let {
+                            PorterDuffColorFilter(it.toArgb(), PorterDuff.Mode.SRC_ATOP)
+                        }
+                        onSuccess()
+                    },
+                    onError = { _, _ -> onError() }
+                )
+            }
+        }
+    )
+}
+private fun ImageView.applyMatrixInternal(
+    contentScale: ContentScale,
+    alignment: Alignment
+): Boolean {
+    val d = drawable ?: return false
+
+    val vw = width - paddingLeft - paddingRight
+    val vh = height - paddingTop - paddingBottom
+    if (vw <= 0 || vh <= 0) return false
+
+    val dw = (d.intrinsicWidth).takeIf { it > 0 } ?: return false
+    val dh = (d.intrinsicHeight).takeIf { it > 0 } ?: return false
+
+    val sxFit = vw.toFloat() / dw.toFloat()
+    val syFit = vh.toFloat() / dh.toFloat()
+
+    val (sx, sy) = when (contentScale) {
+        ContentScale.Crop       -> maxOf(sxFit, syFit).let { it to it }
+        ContentScale.Fit        -> minOf(sxFit, syFit).let { it to it }
+        ContentScale.FillWidth  -> sxFit to sxFit
+        ContentScale.FillHeight -> syFit to syFit
+        ContentScale.FillBounds -> sxFit to syFit
+        ContentScale.Inside     -> minOf(1f, minOf(sxFit, syFit)).let { it to it }
+        ContentScale.None       -> 1f to 1f
+        else                    -> maxOf(sxFit, syFit).let { it to it }
+    }
+
+    val (bx, by) = when (alignment) {
+        Alignment.TopStart     -> -1f to -1f
+        Alignment.TopCenter    ->  0f to -1f
+        Alignment.TopEnd       ->  1f to -1f
+        Alignment.CenterStart  -> -1f to  0f
+        Alignment.Center       ->  0f to  0f
+        Alignment.CenterEnd    ->  1f to  0f
+        Alignment.BottomStart  -> -1f to  1f
+        Alignment.BottomCenter ->  0f to  1f
+        Alignment.BottomEnd    ->  1f to  1f
+        else                   ->  0f to  0f
+    }
+
+    val scaledW = dw * sx
+    val scaledH = dh * sy
+
+    val tx = (vw - scaledW) * (bx + 1f) / 2f
+    val ty = (vh - scaledH) * (by + 1f) / 2f
+
+    if (scaleType != ImageView.ScaleType.MATRIX) {
+        scaleType = ImageView.ScaleType.MATRIX
+    }
+
+    val m = imageMatrix ?: Matrix()
+    m.reset()
+    m.setScale(sx, sy)
+    m.postTranslate(tx, ty)
+    imageMatrix = m
+    return true
+}
+
+private fun ImageView.applyOrDefer(contentScale: ContentScale, alignment: Alignment) {
+    if (!applyMatrixInternal(contentScale, alignment)) {
+        doOnLayout { if (!applyMatrixInternal(contentScale, alignment)) post { applyMatrixInternal(contentScale, alignment) } }
+    }
+}
+
+@Composable
+actual fun ConfigureDialogWindow(decorFitsSystemWindows: Boolean) {
+    val view = LocalView.current
+    if (!view.isInEditMode) {
+        SideEffect {
+            // In Compose, LocalView.current inside a Dialog is the DialogLayout
+            // which itself implements DialogWindowProvider.
+            val window = (view as? DialogWindowProvider)?.window
+                ?: (view.parent as? DialogWindowProvider)?.window
+                ?: return@SideEffect
+
+            WindowCompat.setDecorFitsSystemWindows(window, decorFitsSystemWindows)
+
+            if (!decorFitsSystemWindows) {
+                // Extend layout behind the status bar and navigation bar so the
+                // dialog scrim covers the full screen uniformly.
+                window.setLayout(
+                    ViewGroup.LayoutParams.MATCH_PARENT,
+                    ViewGroup.LayoutParams.MATCH_PARENT
+                )
+                window.statusBarColor = android.graphics.Color.TRANSPARENT
+                window.navigationBarColor = android.graphics.Color.TRANSPARENT
+            }
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+package vn.momo.kits.application
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.zIndex
+import vn.momo.kits.components.InputSearch
+import vn.momo.kits.components.InputSearchProps
+import vn.momo.kits.const.Radius
+import vn.momo.kits.const.Spacing
+
+@Composable
+fun AnimationSearchInput(
+    animations: HeaderAnimations,
+    inputSearchProps: InputSearchProps
+) {
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .offset(
+                x = animations.translateX.dp,
+                y = animations.translateY.dp
+            )
+    ) {
+        Box(
+            modifier = Modifier
+                .height(HEADER_HEIGHT.dp)
+                .padding(vertical = Spacing.S)
+                .zIndex(1f)
+        ) {
+            Box(
+                modifier = Modifier
+                    .width(animations.width.dp)
+                    .background(
+                        color = animations.backgroundSearch,
+                        shape = RoundedCornerShape(Radius.XL)
+                    )
+            ) {
+                InputSearch(
+                    inputSearchProps = inputSearchProps.copy(
+                        showButtonText = false,
+                        backgroundColor = Color.Transparent
+                    )
+                )
+            }
+        }
+    }
+}

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

@@ -0,0 +1,95 @@
+package vn.momo.kits.application
+
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.staticCompositionLocalOf
+import vn.momo.kits.components.TrustBannerData
+
+@Immutable
+data class FeatureFlags(
+    val showBaseLineDebug: Boolean? = false,
+)
+
+@Immutable
+data class KitConfig(
+    val trustBanner: TrustBannerData? = null,
+    val headerBar: String? = null,
+    val headerGradient: String? = null,
+)
+
+@Immutable
+data class MiniAppContext(
+    val appIcon: String = "",
+    val appName: Any? = null,
+    val appId: String = "",
+    val appCode: String = "",
+    val description: Any? = null,
+    val support: Map<String, Any?> = emptyMap(),
+    val toolkitConfig: Map<String, Any?> = emptyMap(),
+    val providerId: String = "",
+    val permissions: List<Map<String, Any>>? = emptyList(),
+    val features: FeatureFlags? = null,
+) {
+    companion object {
+
+        fun toMap(context: MiniAppContext?): Map<String, Any?> = mapOf(
+            "icon"          to (context?.appIcon ?: ""),
+            "name"          to context?.appName,
+            "appId"         to (context?.appId ?: ""),
+            "code"          to (context?.appCode ?: ""),
+            "description"   to (context?.description ?: ""),
+            "support"       to (context?.support ?: emptyMap()),
+            "toolkitConfig" to (context?.toolkitConfig ?: emptyMap()),
+            "providerId"    to (context?.providerId ?: ""),
+            "permissions"   to (context?.permissions ?: emptyList()),
+        )
+
+        fun merge(parent: MiniAppContext?, child: MiniAppContext?): MiniAppContext? {
+            if (parent == null && child == null) return null
+            if (parent == null) return child
+            if (child == null) return parent
+
+            return MiniAppContext(
+                appIcon = parent.appIcon.ifBlank { child.appIcon },
+                appName = parent.appName ?: child.appName,
+                appId = parent.appId.ifBlank { child.appId },
+                appCode = parent.appCode.ifBlank { child.appCode },
+                description = parent.description ?: child.description,
+                support = mergeMaps(parent.support, child.support),
+                toolkitConfig = mergeMaps(parent.toolkitConfig, child.toolkitConfig),
+                providerId = parent.providerId.ifBlank { child.providerId },
+                permissions = if (!parent.permissions.isNullOrEmpty()) parent.permissions else child.permissions,
+                features = mergeFeatureFlags(parent.features, child.features)
+            )
+        }
+
+        private fun mergeMaps(parent: Map<String, Any?>, child: Map<String, Any?>): Map<String, Any?> {
+            return child + parent
+        }
+
+        private fun mergeFeatureFlags(parent: FeatureFlags?, child: FeatureFlags?): FeatureFlags? {
+            if (parent == null && child == null) return null
+            if (parent == null) return child
+            if (child == null) return parent
+
+            return FeatureFlags(
+                showBaseLineDebug = parent.showBaseLineDebug ?: child.showBaseLineDebug
+            )
+        }
+    }
+}
+
+var IsShowBaseLineDebug = false
+
+val ApplicationContext = staticCompositionLocalOf<MiniAppContext?> {
+    null
+}
+
+val AppConfig = staticCompositionLocalOf<KitConfig?> {
+    null
+}
+
+val AppLanguage = staticCompositionLocalOf<String?> {
+    null
+}
+
+internal val ScaleSizeMaxRate  = staticCompositionLocalOf<Float?> { null }

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

@@ -0,0 +1,201 @@
+package vn.momo.kits.application
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.CubicBezierEasing
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.expandHorizontally
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkHorizontally
+import androidx.compose.foundation.ScrollState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.sizeIn
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.AlertDialogDefaults.shape
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.FloatingActionButtonDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.zIndex
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.launch
+import vn.momo.kits.components.Icon
+import vn.momo.kits.components.Text
+import vn.momo.kits.const.Typography
+
+enum class FABSize {
+    SMALL,
+    DEFAULT,
+}
+
+enum class FABPosition {
+    END,
+    CENTER,
+}
+
+data class FabProps(
+    val icon: String,
+    val iconColor: Color? = null,
+    val label: String? = null,
+    val onClick: () -> Unit,
+    val size: FABSize = FABSize.DEFAULT,
+    val bottom: Dp? = null,
+    val scrollState: ScrollState? = null,
+    val position: FABPosition? = FABPosition.END,
+)
+
+@Deprecated("Use vn.momo.kits.navigation.FloatingButton instead", ReplaceWith("vn.momo.kits.navigation.FloatingButton"))
+@Composable
+fun FloatingButton(
+    scrollPosition: Int,
+    bottom: Dp,
+    onClick: () -> Unit,
+    containerColor: Color,
+    contentColor: Color = containerColor,
+    icon: String,
+    iconColor: Color? = null,
+    text: String? = null,
+    elevation: androidx.compose.material3.FloatingActionButtonElevation = FloatingActionButtonDefaults.elevation(
+        4.dp,
+        4.dp,
+        4.dp,
+        4.dp
+    ),
+    size: FABSize = FABSize.DEFAULT,
+    position: FABPosition = FABPosition.END,
+    keyboardSize: Dp = 0.dp,
+) {
+    val scrollPositionStateFlow = remember { MutableStateFlow(scrollPosition) }
+    var lastScrollPosition by rememberSaveable { mutableStateOf(0) }
+    val coroutineScope = rememberCoroutineScope()
+    var isExpanded by rememberSaveable { mutableStateOf(false) }
+
+    val startPadding = if (isExpanded) 12.dp else 0.dp
+    val endPadding = if (isExpanded) 12.dp else 0.dp
+    val widthIn = if ((size === FABSize.SMALL)) 36.dp else 48.dp
+
+
+    val width = animateDpAsState(
+        targetValue = if (isExpanded && text != null) 80.dp else widthIn,
+        animationSpec = tween(
+            durationMillis = 200,
+            easing = CubicBezierEasing(0.2f, 0.2f, 0.2f, 0.2f),
+        )
+    )
+
+    LaunchedEffect(text) {
+        if (text != null) {
+            coroutineScope.launch {
+                scrollPositionStateFlow
+                    .collectLatest { debouncedScrollPosition ->
+                        isExpanded = debouncedScrollPosition > lastScrollPosition
+                        delay(300)
+                        lastScrollPosition = debouncedScrollPosition
+
+                    }
+            }
+        }
+    }
+
+    LaunchedEffect(scrollPosition) {
+        scrollPositionStateFlow.value = scrollPosition
+    }
+
+    Box(
+        Modifier
+            .fillMaxSize()
+            .padding(end = 12.dp, bottom = bottom)
+            .offset(y = -keyboardSize)
+            .background(Color.Transparent)
+            .zIndex(10f),
+        contentAlignment = if (position == FABPosition.END) Alignment.BottomEnd else Alignment.BottomCenter,
+    ) {
+        FloatingActionButton(
+            onClick = onClick,
+            shape = shape,
+            containerColor = containerColor,
+            contentColor = contentColor,
+            elevation = elevation,
+            interactionSource = remember { MutableInteractionSource() },
+            modifier = Modifier
+                .sizeIn(minWidth = width.value)
+                .height(widthIn)
+        ) {
+            Row(
+                modifier = Modifier.padding(start = startPadding, end = endPadding),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = if (isExpanded) Arrangement.Start else Arrangement.Center
+            ) {
+                Icon(
+                    icon,
+                    size = if (size === FABSize.SMALL) 12.dp else 24.dp,
+                    color = iconColor ?: Color.White
+                )
+                AnimatedVisibility(
+                    visible = isExpanded,
+                    enter = ExtendedFabExpandAnimation,
+                    exit = ExtendedFabCollapseAnimation,
+                ) {
+                    Row {
+                        Spacer(Modifier.width(12.dp))
+                        Text(
+                            text ?: "",
+                            color = Color.White,
+                            style = Typography.actionDefaultBold
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+private val ExtendedFabCollapseAnimation = fadeOut(
+    animationSpec = tween(
+        durationMillis = 800,
+        easing = CubicBezierEasing(0.0f, 0.0f, 1.0f, 1.0f),
+    )
+) + shrinkHorizontally(
+    animationSpec = tween(
+        durationMillis = 500,
+        easing = CubicBezierEasing(0.2f, 0.0f, 0.0f, 1.0f),
+    ),
+    shrinkTowards = Alignment.Start,
+)
+
+private val ExtendedFabExpandAnimation = fadeIn(
+    animationSpec = tween(
+        durationMillis = 200,
+        delayMillis = 100,
+        easing = CubicBezierEasing(0.0f, 0.0f, 1.0f, 1.0f),
+    ),
+) + expandHorizontally(
+    animationSpec = tween(
+        durationMillis = 500,
+        easing = CubicBezierEasing(0.2f, 0.0f, 0.0f, 1.0f),
+    ),
+    expandFrom = Alignment.Start,
+)