@momo-kits/native-kits 0.159.1-beta.8 → 0.160.1-beta.2-debug

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

@@ -0,0 +1,253 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.CubicBezierEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+import vn.momo.kits.components.Divider
+import vn.momo.kits.components.Icon
+import vn.momo.kits.components.Text
+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
+import vn.momo.kits.platform.getScreenHeight
+
+@Composable
+internal fun BottomSheet(
+    content: @Composable () -> Unit,
+    header: BottomHeader,
+    isSurface: Boolean = false,
+    barrierDismissible: Boolean = true,
+    onDismiss: (() -> Unit)?
+) {
+    val navigator = LocalNavigator.current
+
+    val screenHeightDp = getScreenHeight()
+    val screenHeightPx = with(LocalDensity.current) { screenHeightDp.toPx() }
+    val sheetOffset = remember { Animatable(screenHeightPx) }
+
+    val backgroundAlpha = remember { Animatable(0f) }
+    val dynamicAlpha = ((1f - (sheetOffset.value / screenHeightPx)).coerceIn(0f, 1f)) * 0.3f
+    val alpha = backgroundAlpha.value + dynamicAlpha
+
+    val sheetCloseOffset = with(LocalDensity.current) { 100.dp.toPx() }
+
+    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,
+            animationSpec = tween(
+                durationMillis = 100,
+                easing = CubicBezierEasing(0.05f, 0.7f, 0.1f, 1f)
+            )
+        )
+        sheetOffset.animateTo(
+            targetValue = 0f,
+            animationSpec = tween(
+                durationMillis = 350,
+                easing = CubicBezierEasing(0.05f, 0.7f, 0.1f, 1f)
+            )
+        )
+    }
+
+    fun closeEvent(){
+        coroutineScope.launch {
+            sheetOffset.animateTo(
+                targetValue = screenHeightPx,
+                animationSpec = tween(
+                    durationMillis = 200,
+                    easing = CubicBezierEasing(0.3f, 0.0f, 0.8f, 0.15f)
+                )
+            )
+            backgroundAlpha.animateTo(
+                targetValue = 0f,
+                animationSpec = tween(
+                    durationMillis = 100,
+                    easing = CubicBezierEasing(0.3f, 0.0f, 0.8f, 0.15f)
+                )
+            )
+            navigator.pop()
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        openEvent()
+    }
+
+    DisposableEffect(Unit) {
+        OverplayComponentRegistry.bindClose { closeEvent() }
+        onDispose {
+            onDismiss?.invoke()
+        }
+    }
+
+    BackHandler(true){
+        closeEvent()
+    }
+
+    BoxWithConstraints(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(Color.Black.copy(alpha = alpha))
+            .noFeedbackClickable {
+                if(barrierDismissible) closeEvent()
+            }
+    ) {
+        val parentHeight = with(LocalDensity.current) { constraints.maxHeight.toDp() }
+
+        Box(
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .offset { IntOffset(x = 0, y = sheetOffset.value.toInt()) }
+                .fillMaxWidth()
+                .heightIn(max = parentHeight - 90.dp)
+                .background(
+                    color = if (isSurface) AppTheme.current.colors.background.surface else AppTheme.current.colors.background.default,
+                    shape = RoundedCornerShape(topStart = Radius.M, topEnd = Radius.M)
+                )
+                .conditional(IsShowBaseLineDebug) {
+                    border(1.dp, Colors.blue_03)
+                }
+                .noFeedbackClickable {  },
+            contentAlignment = Alignment.BottomCenter
+        ) {
+            Column {
+                Box(
+                    modifier = Modifier
+                        .height(72.dp)
+                        .fillMaxWidth()
+                        .pointerInput(Unit) {
+                            detectDragGestures(
+                                onDrag = { change, dragAmount ->
+                                    change.consume()
+                                    coroutineScope.launch {
+                                        val newOffset = (sheetOffset.value + dragAmount.y).coerceAtLeast(0f)
+                                        sheetOffset.snapTo(newOffset)
+                                    }
+                                },
+                                onDragEnd = {
+                                    coroutineScope.launch {
+                                        if (sheetOffset.value > sheetCloseOffset) {
+                                            closeEvent()
+                                        } else {
+                                            sheetOffset.animateTo(0f)
+                                        }
+                                    }
+                                }
+                            )
+                        }
+                ) {
+                    Column(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(horizontal = Spacing.M),
+                        horizontalAlignment = Alignment.CenterHorizontally
+                    ) {
+                        Spacer(Modifier.height(8.dp))
+                        Box(
+                            modifier = Modifier
+                                .height(4.dp)
+                                .width(40.dp)
+                                .background(
+                                    color = Colors.black_06,
+                                    shape = RoundedCornerShape(Radius.S)
+                                )
+                        )
+                        Spacer(Modifier.height(4.dp))
+                        Box(Modifier.fillMaxWidth().height(56.dp), contentAlignment = Alignment.Center){
+                            when (header) {
+                                is BottomHeader.Title -> {
+                                    Row(modifier = Modifier.fillMaxSize(), verticalAlignment = Alignment.CenterVertically) {
+                                        Box(Modifier.size(24.dp))
+                                        Box(Modifier.fillMaxHeight().weight(1f), contentAlignment = Alignment.Center){
+                                            Text(
+                                                text = header.data,
+                                                color = Colors.black_17,
+                                                style = Typography.headerDefaultBold
+                                            )
+                                        }
+                                        Box(Modifier
+                                            .size(24.dp)
+                                            .noFeedbackClickable {
+                                                closeEvent()
+                                            },
+                                            contentAlignment = Alignment.Center
+                                        ){
+                                            Icon(source = "navigation_close")
+                                        }
+                                    }
+                                }
+                                is BottomHeader.Custom -> {
+                                    header.content()
+                                }
+                            }
+                        }
+                    }
+                }
+                Divider()
+                content()
+            }
+        }
+    }
+}
+
+sealed class BottomHeader {
+    data class Title(
+        val data: String = "Bottom Sheet Title",
+    ) : BottomHeader()
+
+    data class Custom(
+        val content: @Composable () -> Unit
+    ) : BottomHeader()
+}

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

@@ -0,0 +1,133 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.CubicBezierEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.wrapContentSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+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
+internal fun ModalScreen(
+    content: @Composable () -> Unit,
+    barrierDismissible: Boolean = true,
+    onDismiss: (() -> Unit)? = null
+) {
+    val navigator = LocalNavigator.current
+
+    val alpha = remember { Animatable(0f) }
+    val scale = remember { Animatable(0.8f) }
+
+    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 {
+                alpha.animateTo(
+                    targetValue = 1f,
+                    animationSpec = tween(durationMillis = 250)
+                )
+            }
+            launch {
+                scale.animateTo(
+                    targetValue = 1f,
+                    animationSpec = tween(
+                        durationMillis = 250,
+                        easing = CubicBezierEasing(0.2f, 0.0f, 0f, 1f)
+                    )
+                )
+            }
+        }
+    }
+
+    fun closeEvent() {
+        coroutineScope.launch {
+            alpha.animateTo(
+                targetValue = 0f,
+                animationSpec = tween(durationMillis = 200)
+            )
+            scale.animateTo(
+                targetValue = 0.8f,
+                animationSpec = tween(durationMillis = 200)
+            )
+            navigator.pop()
+        }
+    }
+
+    LaunchedEffect(Unit) {
+        openEvent()
+    }
+
+    DisposableEffect(Unit) {
+        OverplayComponentRegistry.bindClose { closeEvent() }
+        onDispose {
+            onDismiss?.invoke()
+        }
+    }
+
+    BackHandler(enabled = true) {
+        closeEvent()
+    }
+
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(Color.Black.copy(alpha = 0.6f * alpha.value))
+            .noFeedbackClickable {
+                if(barrierDismissible) closeEvent()
+            },
+        contentAlignment = Alignment.Center
+    ) {
+        Box(
+            modifier = Modifier
+                .scale(scale.value)
+                .alpha(alpha.value)
+                .wrapContentSize()
+                .conditional(IsShowBaseLineDebug) {
+                    border(1.dp, Colors.blue_03)
+                }
+                .clickable(
+                    indication = null,
+                    interactionSource = remember { MutableInteractionSource() }
+                ) {},
+        contentAlignment = Alignment.Center
+        ) {
+            content()
+        }
+    }
+}

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

@@ -0,0 +1,99 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.foundation.gestures.ScrollableState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color
+import vn.momo.kits.navigation.bottomtab.setBottomTabOption
+import vn.momo.kits.navigation.component.FloatingButtonProps
+import vn.momo.kits.navigation.component.HeaderBackProps
+import vn.momo.kits.navigation.component.HeaderRight
+import vn.momo.kits.navigation.component.HeaderTitle
+import vn.momo.kits.navigation.component.HeaderType
+
+class Navigation(
+    val id: Int = -1,
+    val bottomTabIndex: Int = -1,
+    val initOptions: NavigationOptions? = null
+) {
+    private val _options = mutableStateOf(initOptions ?: NavigationOptions())
+    val currentOptions: State<NavigationOptions> get() = _options
+    val options: NavigationOptions get() = _options.value
+
+    fun setOptions(
+        onBackHandler: (() -> Unit)? = null,
+        hiddenBack: Boolean? = null,
+        headerBackProps: HeaderBackProps? = null,
+        headerTitle: HeaderTitle? = null,
+        headerRight: HeaderRight? = null,
+        headerType: HeaderType? = null,
+        scrollData: ScrollData? = null,
+        backgroundColor: Color? = null,
+        tintColor: Color? = null,
+        footerComponent: (@Composable () -> Unit)? = null,
+        floatingButtonProps: FloatingButtonProps? = null,
+        keyboardOptions: KeyboardOptions? = null
+    ) {
+        updateOptions(
+            options.copy(
+                onBackHandler = onBackHandler ?: options.onBackHandler,
+                hiddenBack = hiddenBack ?: options.hiddenBack,
+                headerBackProps = headerBackProps ?: options.headerBackProps,
+                headerTitle = headerTitle ?: options.headerTitle,
+                headerRight = headerRight ?: options.headerRight,
+                headerType = headerType ?: options.headerType,
+                scrollData = scrollData ?: options.scrollData,
+                backgroundColor = backgroundColor ?: options.backgroundColor,
+                tintColor = tintColor ?: options.tintColor,
+                footerComponent = footerComponent ?: options.footerComponent,
+                floatingButtonProps = floatingButtonProps ?: options.floatingButtonProps,
+                keyboardOptions = keyboardOptions ?: options.keyboardOptions,
+            )
+        )
+    }
+
+    fun setOptions(newOptions: NavigationOptions) {
+        updateOptions(newOptions)
+    }
+
+    private fun updateOptions(updated: NavigationOptions) {
+        _options.value = updated
+        if (bottomTabIndex != -1) setBottomTabOption(bottomTabIndex, updated)
+        if (id != -1) DynamicScreenRegistry.setOptions(id, updated)
+    }
+}
+
+val LocalNavigation = staticCompositionLocalOf<Navigation> {
+    error("No NavigationStack provided")
+}
+
+@Stable
+data class NavigationOptions(
+    val screenName: String? = null,
+    val onBackHandler: (() -> Unit)? = null,
+    val hiddenBack: Boolean = false,
+    val headerBackProps: HeaderBackProps = HeaderBackProps(),
+    val headerTitle: HeaderTitle = HeaderTitle.Default("Stack"),
+    val headerRight: HeaderRight = HeaderRight.Toolkit(),
+    val headerType: HeaderType = HeaderType.Default(),
+    val scrollData: ScrollData = ScrollData(),
+    val backgroundColor: Color? = null,
+    val tintColor: Color? = null,
+    val footerComponent: @Composable (() -> Unit)? = null,
+    val floatingButtonProps: FloatingButtonProps? = null,
+    val keyboardOptions: KeyboardOptions = KeyboardOptions()
+)
+
+data class KeyboardOptions(
+    val keyboardShouldPersistTaps: Boolean = false,
+    val useAvoidKeyboard: Boolean = true
+)
+
+
+data class ScrollData(
+    val scrollable: Boolean = true,
+    val scrollState: ScrollableState? = null,
+)

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

@@ -0,0 +1,140 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.animation.*
+import androidx.compose.animation.core.tween
+import androidx.compose.runtime.*
+import androidx.compose.ui.unit.Dp
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
+import androidx.navigation.toRoute
+import vn.momo.kits.application.*
+import vn.momo.kits.const.*
+import vn.momo.kits.platform.ProvideNavigationEventDispatcherOwner
+import vn.momo.kits.utils.getAppStatusBarHeight
+import vn.momo.kits.utils.getNavigationBarHeight
+import vn.momo.maxapi.IMaxApi
+
+@Composable
+fun NavigationContainer(
+    initialScreenName: String,
+    initialScreen: @Composable () -> Unit,
+    options: NavigationOptions? = null,
+    initialTheme: Theme = defaultTheme,
+    applicationContext: MiniAppContext? = null,
+    maxApi: IMaxApi? = null,
+    setNavigator: ((Navigator) -> Unit)? = null,
+    statusBarHeight: Dp? = null,
+    config: KitConfig? = null,
+    language: String? = null
+){
+    val navController = rememberNavController()
+    val navigator = remember { Navigator(navController = navController, maxApi = maxApi) }
+    val statusBarHeight = statusBarHeight ?: getAppStatusBarHeight()
+    val navigationBarHeight = getNavigationBarHeight()
+
+    val parentContext = ApplicationContext.current
+    val mergedContext = MiniAppContext.merge(parentContext, applicationContext)
+
+    val theme = remember { mutableStateOf(initialTheme) }
+
+    LaunchedEffect(Unit) {
+        val headerBar = config?.headerBar
+        if (headerBar != null && theme.value.assets.headerBackground == null) {
+            theme.value = theme.value.copy(
+                assets = ThemeAssets(
+                    headerBackground = headerBar
+                )
+            )
+        }
+    }
+
+    val startDestination = DynamicScreenRegistry.register(initialScreenName, initialScreen, options)
+
+    ProvideNavigationEventDispatcherOwner {
+        CompositionLocalProvider(
+            LocalNavigator provides navigator,
+            LocalMaxApi provides maxApi,
+            AppTheme provides theme.value,
+            AppStatusBar provides statusBarHeight,
+            AppNavigationBar provides navigationBarHeight,
+            ApplicationContext provides mergedContext,
+            AppConfig provides config,
+            AppLanguage provides language,
+        ) {
+            LaunchedEffect(Unit) {
+                setNavigator?.invoke(navigator)
+            }
+
+            NavHost(navController, startDestination = startDestination) {
+                composable<DynamicScreenRoute>(
+                    enterTransition = {
+                        slideInHorizontally(
+                            animationSpec = tween(300),
+                            initialOffsetX = { it }
+                        )
+                    },
+                    exitTransition = null,
+                    popEnterTransition = { fadeIn(animationSpec = tween(0)) },
+                    popExitTransition = {
+                        slideOutHorizontally(
+                            animationSpec = tween(300),
+                            targetOffsetX = { it }
+                        )
+                    }
+                ) { backStackEntry ->
+                    val route = backStackEntry.toRoute<DynamicScreenRoute>()
+                    val screen = DynamicScreenRegistry.getScreen(route.id)
+
+                    if (screen != null) {
+                        StackScreen(
+                            id = route.id,
+                            name = screen.name,
+                            content = screen.content,
+                            navigationOptions = screen.options
+                        )
+                    }
+                }
+
+                composable<DynamicDialogRoute>(
+                    enterTransition = {
+                        slideInVertically(
+                            animationSpec = tween(300),
+                            initialOffsetY = { it }
+                        )
+                    },
+                    exitTransition = null,
+                    popEnterTransition = { fadeIn(animationSpec = tween(0)) },
+                    popExitTransition = {
+                        slideOutVertically(
+                            animationSpec = tween(300),
+                            targetOffsetY = { it }
+                        )
+                    }
+                ) { backStackEntry ->
+                    val route = backStackEntry.toRoute<DynamicDialogRoute>()
+                    val screen = DynamicScreenRegistry.getScreen(route.id)
+
+                    if (screen != null) {
+                        StackScreen(
+                            id = route.id,
+                            name = screen.name,
+                            content = screen.content,
+                            navigationOptions = screen.options
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    DisposableEffect(Unit) {
+        onDispose {
+            navigator.dispose()
+        }
+    }
+}
+
+val LocalMaxApi = staticCompositionLocalOf<IMaxApi?> {
+    error("No MaxApi provided")
+}