@momo-kits/native-kits 0.164.1-beta.8-debug → 0.164.1-beta.9-debug

package/compose/build.gradle.kts

@@ -40,7 +40,7 @@ kotlin {
     }
 
     cocoapods {
-        version = "0.164.1-beta.8-debug"
+        version = "0.164.1-beta.9-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.8-debug'
+    spec.version                  = '0.164.1-beta.9-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,8 @@ 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.
                 LaunchedEffect(navController, registry) {

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

@@ -46,9 +46,9 @@ private val EDGE_SHADOW_WIDTH = 8.dp
 
 /**
  * Kill switch for the swipe-back gesture. Set to `false` to make kit back handling always win,
- * which disables the predictive-back drag on both platforms — on iOS that means the host-driven
- * seek stops following the finger, though the host's own gesture still fires a plain back. Screen
- * transitions stay on the parallax curve either way.
+ * which disables the predictive-back drag on both platforms — the gesture then pops without
+ * following the finger, and fires no haptic. Screen transitions stay on the parallax curve either
+ * way.
  */
 object SwipeBackConfig {
     // Snapshot-backed so a host toggle takes effect on the next frame instead of waiting for an

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

@@ -0,0 +1,41 @@
+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 = 100f
+
+/**
+ * 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?) {
+    // With the kill switch off the kit's own BackHandler swallows the gesture, so the card never
+    // moves — a tick there would be a phantom.
+    if (maxApi == null || !SwipeBackConfig.enabled) 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/ComposeBackGesture.ios.kt

@@ -0,0 +1,65 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.remember
+import androidx.navigationevent.NavigationEventDispatcher
+import androidx.navigationevent.NavigationEventInput
+
+/**
+ * Read-only answer to "will Compose consume this back?", for the iOS host.
+ *
+ * Compose owns the edge-pan gesture through its own `UIKitBackGestureRecognizer`; the host reads
+ * this to decide whether to stand down or keep driving its own recogniser, instead of guessing.
+ * Nothing here dispatches — [ObserveBackGestureOwnership] only listens.
+ *
+ * Pair it with [Navigator.canPop]: the mini-app root reports an enabled handler too (it swallows
+ * back to reach `maxApi.dismiss`), yet there the host still owns the gesture.
+ */
+object ComposeBackGesture {
+    private val observers = mutableListOf<BackHandlerObserver>()
+
+    /** State of the top-most mounted container; `false` when none is mounted. */
+    val hasEnabledHandlers: Boolean
+        get() = observers.lastOrNull()?.hasEnabledHandlers == true
+
+    internal fun attach(observer: BackHandlerObserver) {
+        observers += observer
+    }
+
+    internal fun detach(observer: BackHandlerObserver) {
+        observers -= observer
+    }
+}
+
+/**
+ * Publishes one [NavigationContainer]'s back-handling state to [ComposeBackGesture] while composed.
+ *
+ * Only called for a container whose dispatcher is the scene's — a bare-`UIView` host gets the
+ * detached fallback dispatcher, which can never receive an edge pan, so reporting its handlers
+ * would tell the host to stand down in favour of a gesture that does not exist.
+ */
+@Composable
+internal fun ObserveBackGestureOwnership(dispatcher: NavigationEventDispatcher) {
+    val observer = remember(dispatcher) { BackHandlerObserver() }
+
+    DisposableEffect(dispatcher, observer) {
+        dispatcher.addInput(observer)
+        ComposeBackGesture.attach(observer)
+        onDispose {
+            ComposeBackGesture.detach(observer)
+            dispatcher.removeInput(observer)
+        }
+    }
+}
+
+// A NavigationEventInput that never dispatches: adding an input is the only way to observe the
+// dispatcher's enabled-handler state without registering a handler, which would consume the gesture.
+internal class BackHandlerObserver : NavigationEventInput() {
+    var hasEnabledHandlers: Boolean = false
+        private set
+
+    override fun onHasEnabledHandlersChanged(hasEnabledHandlers: Boolean) {
+        this.hasEnabledHandlers = hasEnabledHandlers
+    }
+}

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

@@ -39,7 +39,7 @@ import platform.Foundation.NSBundle
 import platform.UIKit.UIColor
 import platform.UIKit.UIDevice
 import platform.UIKit.UIScreen
-import vn.momo.kits.navigation.AttachHostBackGesture
+import vn.momo.kits.navigation.ObserveBackGestureOwnership
 
 actual fun getPlatformName(): String = "iOS"
 
@@ -75,21 +75,29 @@ actual fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
 @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 {
+    val platformOwner = LocalCompatNavigationEventDispatcherOwner.current
+    if (platformOwner != null) {
+        // UIKitNavigationEventInput is registered on the scene's dispatcher, and that dispatcher
+        // having enabled handlers is what arms Compose's UIKitBackGestureRecognizer. Providing a
+        // fresh NavigationEventDispatcher() here would shadow it with an input-less one that never
+        // sees a single edge-pan event — no recogniser, and no finger-following seek.
+        ObserveBackGestureOwnership(platformOwner.navigationEventDispatcher)
+        content()
+        return
+    }
+
+    // Bare UIView hosts have no scene dispatcher, and BackHandler/PredictiveBackHandler error() on
+    // a null owner. Disabled: nothing can feed it, so it exists only to keep those from throwing.
+    val fallbackOwner = remember {
         object : NavigationEventDispatcherOwner {
-            override val navigationEventDispatcher = NavigationEventDispatcher()
+            override val navigationEventDispatcher = NavigationEventDispatcher().apply {
+                isEnabled = false
+            }
         }
     }
 
-    AttachHostBackGesture(navigationEventDispatcherOwner.navigationEventDispatcher)
-
     CompositionLocalProvider(
-        LocalCompatNavigationEventDispatcherOwner provides navigationEventDispatcherOwner,
+        LocalCompatNavigationEventDispatcherOwner provides fallbackOwner,
         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.8
+version=0.164.1-beta.9
 
 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.8'
+  s.version          = '0.164.1-beta.9'
   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.8'
+  s.version          = '0.164.1-beta.9'
   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.8-debug",
+  "version": "0.164.1-beta.9-debug",
   "private": false,
   "dependeNavigationncies": {},
   "devDependencies": {},

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

@@ -1,125 +0,0 @@
-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() }
-}