@momo-kits/native-kits 0.164.1-beta.15-debug → 0.164.1-beta.16-debug

package/compose/build.gradle.kts

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

package/compose/compose.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |spec|
     spec.name                     = 'compose'
-    spec.version                  = '0.164.1-beta.15-debug'
+    spec.version                  = '0.164.1-beta.16-debug'
     spec.homepage                 = 'https://momo.vn'
     spec.source                   = { :http=> ''}
     spec.authors                  = ''

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

@@ -0,0 +1,12 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+
+// No passive observer exists at androidx.activity 1.10.x — a second enabled callback would steal
+// the gesture from NavHost. Android's system back gesture emits its own platform haptic on commit.
+// Revisit if androidx.activity >= 1.12 is adopted; this then becomes a copy of the iOS actual.
+@Composable
+actual fun rememberBackGestureProgress(): State<Float?> = remember { mutableStateOf(null) }

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

@@ -94,6 +94,7 @@ fun NavigationContainer(
                     setNavigator?.invoke(navigator)
                 }
 
+                SwipeBackHaptic(maxApi)
 
                 // Gesture pops never reach Navigator.dismissScreen(), so prune the registry from
                 // the back stack itself. collectLatest lets a rapid re-push cancel a pending prune.

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

@@ -179,8 +179,13 @@ internal fun StackScreen(
     // onBackCompleted, so back still landed but nothing seeked. The root case it was guarding is
     // already covered by `!canPop` below, and letting a tab screen through means the nested tab
     // NavHost seeks its own transition back to the previous tab.
+    //
+    // `options.onBackHandler` was dropped for the same reason: it is set widely (tracking, custom
+    // close flows) and every one of those screens lost the seek. The trade is that NavHost pops
+    // them straight through `composeNavigator.popBackStack()`, so `onBackSafe` — and with it the
+    // handler — does not run on a gesture or hardware back. Screens that must intercept back
+    // should use `preventBack`, which is still a term below.
     val hasCustomBackHandling = !SwipeBackConfig.enabled ||
-            options.onBackHandler != null ||
             options.headerBackProps.preventBack != null ||
             OverplayComponentRegistry.isOverplayShowing() ||
             !canPop

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

@@ -0,0 +1,39 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.snapshotFlow
+import vn.momo.kits.platform.getScreenDimensions
+import vn.momo.kits.platform.rememberBackGestureProgress
+import vn.momo.maxapi.IMaxApi
+
+// RN fires the tick at a flat 100 px of thumb travel; keep it unscaled so the physical distance is
+// the same on every device.
+private const val SWIPE_BACK_HAPTIC_THRESHOLD_DP = 50f
+
+/**
+ * Fires one light tick once the back gesture has travelled ~100dp, re-arming when the finger drops
+ * back below the threshold. iOS only — [rememberBackGestureProgress] is always `null` on Android.
+ */
+@Composable
+internal fun SwipeBackHaptic(maxApi: IMaxApi?) {
+    if (maxApi == null) return
+
+    val progress = rememberBackGestureProgress()
+    val screenWidth = getScreenDimensions().width.toFloat()
+
+    LaunchedEffect(maxApi, screenWidth) {
+        if (screenWidth <= 0f) return@LaunchedEffect
+        val threshold = SWIPE_BACK_HAPTIC_THRESHOLD_DP / screenWidth
+        var isSendHaptic = false
+        snapshotFlow { progress.value }.collect { fraction ->
+            val travelled = fraction ?: 0f
+            if (travelled >= threshold && !isSendHaptic) {
+                runCatching { maxApi.triggerEventVibration("light", callback = null) }
+                isSendHaptic = true
+            } else if (travelled < threshold && isSendHaptic) {
+                isSendHaptic = false
+            }
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.State
+
+/**
+ * Progress of an in-flight back gesture as a fraction of the container width, or `null` while no
+ * gesture is running. Observing only — it must never consume the gesture, otherwise it would steal
+ * it from NavHost.
+ *
+ * Android always returns `null`: its NavHost runs on `androidx.activity`'s OnBackPressedDispatcher,
+ * which exposes progress only to the top-most enabled callback, and that has to stay NavHost's.
+ */
+@Composable
+expect fun rememberBackGestureProgress(): State<Float?>

package/compose/src/iosMain/kotlin/vn/momo/kits/navigation/HostBackGesture.ios.kt

@@ -0,0 +1,125 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.remember
+import androidx.navigationevent.NavigationEvent
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventInput
+import kotlinx.cinterop.ExperimentalForeignApi
+import platform.Foundation.NSThread
+import platform.darwin.dispatch_async
+import platform.darwin.dispatch_get_main_queue
+
+/**
+ * Kit end of the host's edge-pan recogniser.
+ *
+ * iOS keeps exactly one back-gesture recogniser and it belongs to the host app — the kit never
+ * installs its own, so the `.failed -> completed` conflict between two competing recognisers is
+ * unreachable by construction. The host replays its drag here; the events are fed into the
+ * `NavigationEventDispatcher` that [NavigationContainer] provides, which drives NavHost's
+ * `PredictiveBackHandler` and therefore `SeekableTransitionState.seekTo`. Parallax, scrim and edge
+ * shadow are children of that same transition, so they follow the finger for free.
+ *
+ * Only primitives cross the Swift boundary: `androidx.navigationevent` is a private transitive
+ * dependency and is absent from the generated framework header.
+ *
+ * Call every method from the main thread; anything else is re-posted to the main queue.
+ */
+object HostBackGestureBridge {
+    private val attachedInputs = mutableListOf<HostNavigationEventInput>()
+    private var gestureInput: HostNavigationEventInput? = null
+
+    /**
+     * Whether the top-most mounted container has an enabled back handler, i.e. the authoritative
+     * answer to "will Compose consume this back?". `false` means no container is mounted, or the
+     * mounted one deliberately opts out (kill switch, overlay showing, custom back handler), and
+     * the host should fall back to its own navigation.
+     */
+    val hasEnabledHandlers: Boolean
+        get() = attachedInputs.lastOrNull()?.hasEnabledHandlers == true
+
+    /** Begins a drag. Pairs with exactly one [completed] or [cancelled]. */
+    fun started() = onMain {
+        val input = attachedInputs.lastOrNull() ?: return@onMain
+        gestureInput = input
+        input.backStarted()
+    }
+
+    /** Drag progress in `0f..1f` — the fraction of the screen width travelled. */
+    fun progressed(progress: Float) = onMain {
+        gestureInput?.backProgressed(progress.coerceIn(0f, 1f))
+    }
+
+    /**
+     * Released past the commit threshold: the screen pops.
+     *
+     * Falls back to the attached input when no drag was started, so a host that commits without
+     * ever seeking still gets a back. Dispatching a bare completion is the documented
+     * non-predictive path — the same shape as a back button press — and dropping it here is what
+     * silently stranded the mini-app root, where the host never seeks.
+     */
+    fun completed() = onMain {
+        (gestureInput ?: attachedInputs.lastOrNull())?.backCompleted()
+        gestureInput = null
+    }
+
+    /** Released below the commit threshold: the screen springs back. */
+    fun cancelled() = onMain {
+        gestureInput?.backCancelled()
+        gestureInput = null
+    }
+
+    internal fun attach(input: HostNavigationEventInput) {
+        attachedInputs += input
+    }
+
+    internal fun detach(input: HostNavigationEventInput) {
+        attachedInputs -= input
+        // A container unmounted mid-drag must not hand its pending terminal event to whichever
+        // container is on top now: NavigationEventInput fabricates a non-predictive start for a
+        // completed/cancelled it never saw begin, which would pop a screen out of nowhere.
+        if (gestureInput === input) gestureInput = null
+    }
+}
+
+/** Wires one [NavigationContainer]'s dispatcher to [HostBackGestureBridge] while it is composed. */
+@Composable
+internal fun AttachHostBackGesture(dispatcher: NavigationEventDispatcher) {
+    val input = remember(dispatcher) { HostNavigationEventInput() }
+
+    DisposableEffect(dispatcher, input) {
+        dispatcher.addInput(input)
+        HostBackGestureBridge.attach(input)
+        onDispose {
+            HostBackGestureBridge.detach(input)
+            dispatcher.removeInput(input)
+        }
+    }
+}
+
+internal class HostNavigationEventInput : NavigationEventInput() {
+    var hasEnabledHandlers: Boolean = false
+        private set
+
+    override fun onHasEnabledHandlersChanged(hasEnabledHandlers: Boolean) {
+        this.hasEnabledHandlers = hasEnabledHandlers
+    }
+
+    // Touch coordinates are not forwarded — the stack transition is seeked by progress alone, and
+    // leaving them out keeps the bridge's Swift-facing signatures primitive.
+    fun backStarted() = dispatchOnBackStarted(NavigationEvent(swipeEdge = NavigationEvent.EDGE_LEFT))
+
+    fun backProgressed(progress: Float) = dispatchOnBackProgressed(
+        NavigationEvent(swipeEdge = NavigationEvent.EDGE_LEFT, progress = progress)
+    )
+
+    fun backCancelled() = dispatchOnBackCancelled()
+
+    fun backCompleted() = dispatchOnBackCompleted()
+}
+
+@OptIn(ExperimentalForeignApi::class)
+private fun onMain(block: () -> Unit) {
+    if (NSThread.isMainThread()) block() else dispatch_async(dispatch_get_main_queue()) { block() }
+}

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

@@ -0,0 +1,35 @@
+package vn.momo.kits.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.State
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.InternalComposeUiApi
+import androidx.compose.ui.backhandler.LocalCompatNavigationEventDispatcherOwner
+import androidx.navigationevent.NavigationEventTransitionState
+
+// NavigationEventDispatcher.transitionState is a passive observer: UIKitNavigationEventInput
+// publishes every edge-pan event to it without any handler consuming the gesture. Its `progress`
+// is touch.x / view width, i.e. a plain fraction of the screen width.
+@OptIn(InternalComposeUiApi::class)
+@Composable
+actual fun rememberBackGestureProgress(): State<Float?> {
+    val dispatcher = LocalCompatNavigationEventDispatcherOwner.current?.navigationEventDispatcher
+    val progress = remember { mutableStateOf<Float?>(null) }
+
+    LaunchedEffect(dispatcher) {
+        if (dispatcher == null) {
+            progress.value = null
+            return@LaunchedEffect
+        }
+        dispatcher.transitionState.collect { state ->
+            progress.value = (state as? NavigationEventTransitionState.InProgress)
+                ?.takeIf { it.direction == NavigationEventTransitionState.TRANSITIONING_BACK }
+                ?.latestEvent
+                ?.progress
+        }
+    }
+
+    return progress
+}

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

@@ -17,6 +17,7 @@ import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.InternalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.backhandler.LocalCompatNavigationEventDispatcherOwner
+import androidx.compose.ui.backhandler.BackHandler as ComposeBackHandler
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.NativePaint
 import androidx.compose.ui.graphics.toArgb
@@ -38,6 +39,7 @@ import platform.Foundation.NSBundle
 import platform.UIKit.UIColor
 import platform.UIKit.UIDevice
 import platform.UIKit.UIScreen
+import vn.momo.kits.navigation.AttachHostBackGesture
 
 actual fun getPlatformName(): String = "iOS"
 
@@ -60,21 +62,32 @@ actual fun getStatusBarHeight(): Dp {
     return WindowInsets.systemBars.asPaddingValues().calculateTopPadding()
 }
 
+// An enabled kit BackHandler is registered inside the NavHost destination, so it out-ranks
+// NavHost's own predictive-back handler and swallows the gesture — that is how a screen opts out
+// of swipe-back (the port of RN's `hasCustomBackHandling`).
+@Suppress("DEPRECATION")
+@OptIn(ExperimentalComposeUiApi::class)
 @Composable
 actual fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
+    ComposeBackHandler(enabled = enabled, onBack = onBack)
 }
 
 @OptIn(InternalComposeUiApi::class)
 @Composable
 actual fun ProvideNavigationEventDispatcherOwner(content: @Composable () -> Unit) {
+    // Detached on purpose: passing the scene's owner through would arm Compose's own
+    // UIKitBackGestureRecognizer alongside the host's, and UIKit settles that conflict by driving
+    // one to .failed, which UIKitNavigationEventInput turns into a fabricated completed back.
+    // Enabled on purpose: every NavigationEventDispatcher.dispatchOn* early-returns while
+    // isEnabled is false, which would mute the host-driven seek as well.
     val navigationEventDispatcherOwner = remember {
         object : NavigationEventDispatcherOwner {
-            override val navigationEventDispatcher = NavigationEventDispatcher().apply {
-                isEnabled = false
-            }
+            override val navigationEventDispatcher = NavigationEventDispatcher()
         }
     }
 
+    AttachHostBackGesture(navigationEventDispatcherOwner.navigationEventDispatcher)
+
     CompositionLocalProvider(
         LocalCompatNavigationEventDispatcherOwner provides navigationEventDispatcherOwner,
         content = content

package/gradle.properties

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

package/ios/native-kits.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKits'
-  s.version          = '0.164.1-beta.15'
+  s.version          = '0.164.1-beta.2'
   s.summary          = 'MoMoUIKits for iOS'
   s.homepage         = 'https://momo.vn'
   s.license          = { :type => 'MIT' }

package/ios-demo/MoMoUIKitsDemo.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'MoMoUIKitsDemo'
-  s.version          = '0.164.1-beta.15'
+  s.version          = '0.164.1-beta.2'
   s.summary          = 'Demo browser for MoMoUIKits SwiftUI components'
   s.homepage         = 'https://momo.vn'
   s.license          = { :type => 'MIT' }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@momo-kits/native-kits",
-  "version": "0.164.1-beta.15-debug",
+  "version": "0.164.1-beta.16-debug",
   "private": false,
   "dependeNavigationncies": {},
   "devDependencies": {},