@momo-kits/native-kits 0.160.6-debug → 0.160.7-beta.5-debug

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

@@ -8,6 +8,7 @@ import androidx.compose.animation.core.rememberInfiniteTransition
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
+import androidx.compose.ui.draw.alpha
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
@@ -131,7 +132,9 @@ fun InputOTP(
             },
             decorationBox = { innerTextField ->
                 Box {
-                    Box(modifier = Modifier.size(0.dp)) { innerTextField() }
+                    Box(
+                        modifier = Modifier.fillMaxWidth().height(56.dp).alpha(0f)
+                    ) { innerTextField() }
                     if (floatingValue.isNotEmpty()) {
                         Box(
                             modifier = Modifier.wrapContentSize()

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

@@ -96,4 +96,5 @@ data class KeyboardOptions(
 data class ScrollData(
     val scrollable: Boolean = true,
     val scrollState: ScrollableState? = null,
+    val scrollToTopCallback: (() -> Unit)? = null,
 )

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

@@ -3,6 +3,7 @@ package vn.momo.kits.navigation
 import androidx.compose.animation.*
 import androidx.compose.animation.core.tween
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.unit.Dp
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
@@ -49,7 +50,9 @@ fun NavigationContainer(
         }
     }
 
-    val startDestination = DynamicScreenRegistry.register(initialScreenName, initialScreen, options)
+    val screenId = rememberSaveable { DynamicScreenRegistry.nextId() }
+    DynamicScreenRegistry.bind(screenId, initialScreenName, initialScreen, options)
+    val startDestination = remember(screenId) { DynamicScreenRoute(screenId) }
 
     ProvideNavigationEventDispatcherOwner {
         CompositionLocalProvider(
@@ -132,6 +135,7 @@ fun NavigationContainer(
     DisposableEffect(Unit) {
         onDispose {
             navigator.dispose()
+            DynamicScreenRegistry.unregisterScreen(screenId)
         }
     }
 }

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

@@ -196,6 +196,18 @@ object DynamicScreenRegistry {
         return DynamicScreenRoute(id)
     }
 
+    fun nextId(): Int = idCounter++
+
+    fun bind(id: Int, screenName: String, content: @Composable () -> Unit, options: NavigationOptions?) {
+        screens[id] = DynamicScreen(
+            id = id,
+            name = screenName,
+            content = content,
+            options = options
+        )
+        if (id >= idCounter) idCounter = id + 1 // keep counter ahead after process-death restore
+    }
+
     fun unregisterScreen(id: Int) {
         screens.remove(id)
     }

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

@@ -0,0 +1,8 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+
+@Composable
+internal expect fun RegisterScrollToTop(callback: (() -> Unit)?)
+
+

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

@@ -11,6 +11,7 @@ import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
 import androidx.compose.foundation.layout.aspectRatio
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -27,10 +28,12 @@ import androidx.compose.material.ExperimentalMaterialApi
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.State
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshotFlow
 import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.Alignment
@@ -150,6 +153,10 @@ internal fun StackScreen(
     val footerHeightPx = remember { mutableIntStateOf(0) }
     val headerRightWidthPx = remember { mutableIntStateOf(0) }
 
+    if (navigation.options.scrollData.scrollToTopCallback != null) {
+        RegisterScrollToTop(navigation.options.scrollData.scrollToTopCallback)
+    }
+
     BackHandler(true) { navigator.onBackSafe() }
 
     CompositionLocalProvider(
@@ -160,37 +167,35 @@ internal fun StackScreen(
         LocalFooterHeightPx provides footerHeightPx,
         LocalHeaderRightWidthPx provides headerRightWidthPx
     ) {
-        Box(Modifier
-            .fillMaxSize()
-            .background(options.backgroundColor ?: AppTheme.current.colors.background.default)
-            .conditional(options.keyboardOptions.keyboardShouldPersistTaps) {
-                hideKeyboardOnTap()
-            }
-            .conditional(options.keyboardOptions.useAvoidKeyboard && supportsImePadding()) {
-                imePadding()
-            }
+        Box(
+            Modifier
+                .fillMaxSize()
+                .background(options.backgroundColor ?: AppTheme.current.colors.background.default)
+                .conditional(options.keyboardOptions.keyboardShouldPersistTaps) {
+                    hideKeyboardOnTap()
+                }
+                .conditional(options.keyboardOptions.useAvoidKeyboard && supportsImePadding()) {
+                    imePadding()
+                }
         ) {
             Box(Modifier.zIndex(1f)) {
                 HeaderBackground()
             }
 
-            Box(Modifier.zIndex(5f)) {
+            Box(Modifier.zIndex(4f)) {
                 Header(onBackHandler)
             }
 
-            Column (Modifier.zIndex(6f)) {
+            Column(Modifier.zIndex(5f)) {
                 SearchAnimated(isScrollInProgress = scrollInProcess)
             }
 
             Column(Modifier.zIndex(2f).fillMaxSize()) {
                 MainContent(content = content)
-            }
-
-            Box(Modifier.zIndex(4f).align(Alignment.BottomCenter)) {
                 FooterContent()
             }
 
-            Box(Modifier.zIndex(7f)){
+            Box(Modifier.zIndex(6f)) {
                 FloatingContent()
             }
 
@@ -200,15 +205,15 @@ internal fun StackScreen(
 }
 
 @Composable
-fun FloatingContent(){
+fun FloatingContent() {
     val options = LocalOptions.current
     val density = LocalDensity.current
     val footerHeightPx = LocalFooterHeightPx.current
     val scrollState = LocalScrollState.current
 
     val fabProps = options.floatingButtonProps ?: return
-    val bottomPadding = fabProps.bottom ?:
-    (Spacing.M + if (options.footerComponent != null) with(density){ footerHeightPx.intValue.toDp() } else 0.dp)
+    val bottomPadding = fabProps.bottom
+        ?: (Spacing.M + if (options.footerComponent != null) with(density) { footerHeightPx.intValue.toDp() } else 0.dp)
 
     FloatingButton(
         scrollPosition = fabProps.scrollState?.value ?: scrollState.value,
@@ -224,17 +229,19 @@ fun FloatingContent(){
 }
 
 @Composable
-fun ColumnScope.MainContent(content: @Composable ()-> Unit){
+fun ColumnScope.MainContent(content: @Composable () -> Unit) {
     val options = LocalOptions.current
     val inputSearchType = getInputSearchType(options)
     val density = LocalDensity.current
     val scrollState = LocalScrollState.current
 
-    Spacer(Modifier.height(
-        if (options.headerType is HeaderType.DefaultOrExtended || (options.headerType is HeaderType.Transparent && !options.headerType.isFullScreenContent))
-            AppStatusBar.current + HEADER_HEIGHT.dp else 0.dp)
+    Spacer(
+        Modifier.height(
+            if (options.headerType is HeaderType.DefaultOrExtended || (options.headerType is HeaderType.Transparent && !options.headerType.isFullScreenContent))
+                AppStatusBar.current + HEADER_HEIGHT.dp else 0.dp
+        )
     )
-    if (inputSearchType == InputSearchType.Animated){
+    if (inputSearchType == InputSearchType.Animated) {
         val scrollDp = with(density) { scrollState.value.toDp() }
 
         val animatedTopPadding by animateDpAsState(
@@ -243,35 +250,31 @@ fun ColumnScope.MainContent(content: @Composable ()-> Unit){
         )
         Spacer(Modifier.height(animatedTopPadding))
     }
-    Column (Modifier
-        .fillMaxWidth()
-        .weight(1f)
-        .conditional(options.scrollData.scrollable && options.scrollData.scrollState is ScrollState) {
-            verticalScroll(scrollState)
-        }
+    Column(
+        Modifier
+            .fillMaxWidth()
+            .weight(1f)
+            .conditional(options.scrollData.scrollable && options.scrollData.scrollState is ScrollState) {
+                verticalScroll(scrollState)
+            }
     ) {
         ScreenContent(content = content)
     }
 
-    if (options.footerComponent != null){
-        val footerHeight = LocalFooterHeightPx.current
-        val footerHeightDp = with(density) { footerHeight.value.toDp() }
-        Spacer(Modifier.height(footerHeightDp))
-    }
 }
 
 @Composable
-fun ScreenContent(content: @Composable () -> Unit){
+fun ScreenContent(content: @Composable () -> Unit) {
     val scrollState = LocalScrollState.current
     val options = LocalOptions.current
 
-    if (options.headerType is HeaderType.Animated){
+    if (options.headerType is HeaderType.Animated) {
         val animatedHeader = options.headerType
         Box {
-            Box(Modifier.fillMaxWidth().aspectRatio(animatedHeader.aspectRatio.value)){
+            Box(Modifier.fillMaxWidth().aspectRatio(animatedHeader.aspectRatio.value)) {
                 animatedHeader.composable.invoke(scrollState.value)
             }
-            Box(Modifier.offset(x = 0.dp, y = AppStatusBar.current + HEADER_HEIGHT.dp + animatedHeader.layoutOffSet)){
+            Box(Modifier.offset(x = 0.dp, y = AppStatusBar.current + HEADER_HEIGHT.dp + animatedHeader.layoutOffSet)) {
                 content()
             }
         }
@@ -281,25 +284,27 @@ fun ScreenContent(content: @Composable () -> Unit){
 }
 
 @Composable
-fun FooterContent(){
+fun FooterContent() {
     val options = LocalOptions.current
-    if (options.footerComponent != null){
-        val ime = WindowInsets.ime
-        val density = LocalDensity.current
-        val imeBottom = ime.getBottom(density)
-        val thresholdPx = with(density) { 50.dp.toPx() }
-        val isKeyboardVisible = imeBottom > thresholdPx
-        val bottomPadding = if (isKeyboardVisible) 0.dp else AppNavigationBar.current
+    if (options.footerComponent != null) {
+        val keyboardSize = keyboardSizeState()
+        val bottomPadding = (AppNavigationBar.current - keyboardSize.value).coerceAtLeast(0.dp)
         Footer(footerComponent = options.footerComponent, bottomPadding = bottomPadding)
     }
 }
 
 @Composable
-fun OverplayView(bottomTabIndex: Int, id: Int){
+fun keyboardSizeState(): State<Dp> {
+    val bottom = WindowInsets.ime.asPaddingValues()
+    return rememberUpdatedState(bottom.calculateBottomPadding())
+}
+
+@Composable
+fun OverplayView(bottomTabIndex: Int, id: Int) {
     val overplayType = OverplayComponentRegistry.getOverplayType()
 
     if (overplayType != null) {
-        Box(Modifier.zIndex(if (overplayType == OverplayComponentType.SNACK_BAR) 3f else 8f).fillMaxSize()){
+        Box(Modifier.zIndex(if (overplayType == OverplayComponentType.SNACK_BAR) 3f else 7f).fillMaxSize()) {
             if (bottomTabIndex != -1) return@Box
             if (OverplayComponentRegistry.currentRootId() != id) return@Box
             OverplayComponentRegistry.OverlayComponent()
@@ -322,22 +327,24 @@ fun Footer(footerComponent: @Composable (() -> Unit)?, bottomPadding: Dp) {
     Box(Modifier.onGloballyPositioned {
         if (footerHeightPx.intValue != it.size.height) footerHeightPx.intValue = it.size.height
     }) {
-        Box(Modifier
-            .fillMaxWidth()
-            .background(AppTheme.current.colors.background.surface)
-            .conditional(IsShowBaseLineDebug) {
-                border(1.dp, Colors.blue_03)
-            }
-            .padding(top = Spacing.S, start = Spacing.M, end = Spacing.M, bottom = bottomPadding + Spacing.S)
-        ){
+        Box(
+            Modifier
+                .fillMaxWidth()
+                .background(AppTheme.current.colors.background.surface)
+                .conditional(IsShowBaseLineDebug) {
+                    border(1.dp, Colors.blue_03)
+                }
+                .padding(top = Spacing.S, start = Spacing.M, end = Spacing.M, bottom = bottomPadding + Spacing.S)
+        ) {
             footerComponent.invoke()
         }
 
-        Box(modifier = Modifier
-            .fillMaxWidth()
-            .height(6.dp)
-            .offset(x = 0.dp, y = (-6).dp)
-            .background(shadowBrush)
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(6.dp)
+                .offset(x = 0.dp, y = (-6).dp)
+                .background(shadowBrush)
         )
     }
 }
@@ -347,6 +354,7 @@ data class InputSearchLayoutParams(
     val startPadding: Dp,
     val endPadding: Dp
 )
+
 @Composable
 fun SearchAnimated(
     isScrollInProgress: Boolean
@@ -455,12 +463,6 @@ fun SearchAnimated(
     }
 }
 
-@Composable
-internal fun isKeyboardVisible(): Boolean {
-    val ime = WindowInsets.ime
-    val density = LocalDensity.current
-    return ime.getBottom(density) > 0
-}
 private fun quantize(value: Int, stepPx: Int): Int {
     if (stepPx <= 1) return value
     return (value / stepPx) * stepPx
@@ -540,13 +542,15 @@ internal val LocalOptions = staticCompositionLocalOf<NavigationOptions> { error(
 
 val StackScreenScrollableState = staticCompositionLocalOf<ScrollableState?> { null }
 
-internal fun getInputSearchType(options: NavigationOptions): InputSearchType{
+internal fun getInputSearchType(options: NavigationOptions): InputSearchType {
     return when (val headerType = options.headerType) {
         is HeaderType.DefaultOrExtended -> when {
             headerType.inputSearchProps == null -> InputSearchType.None
             headerType.useAnimated -> InputSearchType.Animated
             else -> InputSearchType.Header
         }
+
         else -> InputSearchType.None
     }
 }
+

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

@@ -0,0 +1,62 @@
+package vn.momo.kits.platform
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import io.github.alexzhirkevich.compottie.Compottie
+import io.github.alexzhirkevich.compottie.ExperimentalCompottieApi
+import io.github.alexzhirkevich.compottie.LottieCompositionSpec
+import io.github.alexzhirkevich.compottie.dynamic.rememberLottieDynamicProperties
+import io.github.alexzhirkevich.compottie.rememberLottieComposition
+import io.github.alexzhirkevich.compottie.rememberLottiePainter
+import vn.momo.kits.utils.readJson
+
+@OptIn(ExperimentalCompottieApi::class)
+@Composable
+internal fun ComposeLottieAnimation(
+    path: String,
+    tintColor: Color?,
+    bgColor: Color?,
+    modifier: Modifier,
+) {
+    val json = readJson(path)
+
+    if (json.isEmpty()) {
+        Box(modifier.background(bgColor ?: Color.Transparent))
+        return
+    }
+
+    val composition by rememberLottieComposition(json) {
+        LottieCompositionSpec.JsonString(json)
+    }
+
+    // Recolor only the fill/stroke color slots (matching the native lottie-ios per-keypath tint)
+    // instead of a global ColorFilter.tint, which would flatten a multicolor animation to a silhouette.
+    val dynamicProperties = if (tintColor != null) {
+        rememberLottieDynamicProperties(tintColor) {
+            shapeLayer("**") {
+                fill("**") { color { tintColor } }
+                stroke("**") { color { tintColor } }
+            }
+        }
+    } else {
+        null
+    }
+
+    Box(modifier.background(bgColor ?: Color.Transparent)) {
+        Image(
+            painter = rememberLottiePainter(
+                composition = composition,
+                iterations = Compottie.IterateForever,
+                dynamicProperties = dynamicProperties,
+            ),
+            contentDescription = null,
+            modifier = Modifier.fillMaxSize(),
+        )
+    }
+}

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

@@ -44,13 +44,21 @@ fun supportsImePadding(): Boolean = when (val v = getOSVersion()) {
     is OSVersion.IOS -> true
 }
 
+/**
+ * @param useCompose when `true`, renders via the pure-Compose Compottie engine instead of the
+ * platform-native engine (airbnb-lottie on Android, lottie-ios on iOS). Defaults to `false` for
+ * backward compatibility. Note: when `useCompose = true`, `tintColor` recolors only the fill/stroke
+ * color slots (matching the native lottie-ios per-keypath tint), so gradient and text-layer colors
+ * are left untinted; `placedAsOverlay` is a no-op.
+ */
 @Composable
 expect fun LottieAnimation(
     path: String,
     tintColor: Color? = null,
     bgColor: Color? = null,
     placedAsOverlay: Boolean = false,
-    modifier: Modifier = Modifier
+    modifier: Modifier = Modifier,
+    useCompose: Boolean = false
 )
 
 expect fun NativePaint.setColor(

package/compose/src/commonMain/kotlin/vn/momo/kits/utils/Resources.kt

@@ -24,13 +24,21 @@ fun getResource(name: String): DrawableResource {
 @Composable
 fun readJson(name: String): String {
     val path = name.plus(".json")
+    val candidatePaths = listOf(
+        path,
+        "composeResources/vn.momo.compose.resources/$path",
+    )
 
     val jsonContent by rememberState(path, { "" }) {
         val cached = resourceCache.getOrPut(path) {
-            val content = try {
-                readResourceBytes(path).decodeToString()
-            } catch (_: Exception) {
-                ""
+            var content = ""
+            for (candidate in candidatePaths) {
+                try {
+                    content = readResourceBytes(candidate).decodeToString()
+                    break
+                } catch (_: Exception) {
+                    // try next candidate
+                }
             }
             ResourceCache.JSON(content)
         } as ResourceCache.JSON

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

@@ -0,0 +1,33 @@
+package vn.momo.kits.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import platform.Foundation.NSNotification
+import platform.Foundation.NSNotificationCenter
+import platform.Foundation.NSOperationQueue
+import platform.darwin.NSObjectProtocol
+
+private const val STATUS_BAR_TAPPED_NOTIFICATION = "statusBarSelected"
+
+@Composable
+internal actual fun RegisterScrollToTop(callback: (() -> Unit)?) {
+    val maxApi = LocalMaxApi.current
+    DisposableEffect(callback) {
+        val cb = callback
+        val token: NSObjectProtocol? = if (cb != null) {
+            NSNotificationCenter.defaultCenter.addObserverForName(
+                name = STATUS_BAR_TAPPED_NOTIFICATION,
+                `object` = null,
+                queue = NSOperationQueue.mainQueue,
+            ) { _: NSNotification? ->
+                runCatching { cb() }.onFailure {
+                    maxApi?.logFile("[ScrollToTop] callback threw: ${it.message}") {}
+
+                }
+            }
+        } else null
+        onDispose {
+            token?.let { NSNotificationCenter.defaultCenter.removeObserver(it) }
+        }
+    }
+}

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

@@ -98,8 +98,14 @@ actual fun LottieAnimation(
     tintColor: Color?,
     bgColor: Color?,
     placedAsOverlay: Boolean,
-    modifier: Modifier
+    modifier: Modifier,
+    useCompose: Boolean
 ) {
+    if (useCompose) {
+        ComposeLottieAnimation(path, tintColor, bgColor, modifier)
+        return
+    }
+
     var animation by remember { mutableStateOf<CompatibleAnimation?>(null) }
 
     LaunchedEffect(Unit) {

package/gradle/libs.versions.toml

@@ -13,6 +13,7 @@ androidGradlePlugin = "8.13.2"
 r8 = "8.9.35"
 kotlinx-datetime = "0.7.1"
 airbnb-lottie = "5.2.0"
+compottie = "2.2.1"
 androidx-activity = "1.9.1"
 androidx-appcompat = "1.7.0"
 material = "1.10.0"
@@ -38,6 +39,7 @@ coil-multiplatform-compose = { module = "io.coil-kt.coil3:coil-compose", version
 coil-multiplatform-network-ktor = { module = "io.coil-kt.coil3:coil-network-ktor3", version.ref = "coil3-multiplatform" }
 r8 = { module = "com.android.tools:r8", version.ref = "r8" }
 airbnb-lottie = { group = "com.airbnb.android", name = "lottie-compose", version.ref = "airbnb-lottie" }
+compottie = { module = "io.github.alexzhirkevich:compottie", version.ref = "compottie" }
 native-max-api = { group = "vn.momo.maxapi", name = "NativeMaxApi", version.ref = "nativemaxapi" }
 kits = { module = "vn.momo.kits:kits", version.ref = "kits" }
 androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "androidx-appcompat" }

package/gradle.properties

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

package/ios/StatusBarTap/StatusBarTap.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Posts `MoMoStatusBarTap.notificationName` on every status-bar tap.
+/// The swizzle installs automatically at framework load (`+load`) — calling
+/// `install` is a no-op kept for explicit/manual triggering.
+@interface MoMoStatusBarTap : NSObject
+@property (class, nonatomic, readonly) NSNotificationName notificationName;
++ (void)install;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/StatusBarTap/StatusBarTap.m

@@ -0,0 +1,75 @@
+#import <UIKit/UIKit.h>
+#import <objc/message.h>
+#import <objc/runtime.h>
+#import "StatusBarTap.h"
+
+// Performs the actual swizzle once per process. Safe to call multiple times.
+static void mm_installStatusBarTapSwizzleOnce(void) {
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        Class cls = [UIStatusBarManager class];
+        SEL originalSelector = NSSelectorFromString(@"handleTapAction:");
+        SEL swizzledSelector = NSSelectorFromString(@"mm_handleTapAction:");
+
+        Method originalMethod = class_getInstanceMethod(cls, originalSelector);
+        Method swizzledMethod = class_getInstanceMethod(cls, swizzledSelector);
+        if (!originalMethod || !swizzledMethod) return;
+
+        // Verify the original method matches the (id) -> void shape we expect.
+        // Encoding may include byte offsets (e.g. "v32@0:8@16") so we filter
+        // digits out before comparing.
+        const char *encPtr = method_getTypeEncoding(originalMethod);
+        if (encPtr) {
+            NSMutableString *enc = [NSMutableString string];
+            for (const char *p = encPtr; *p; p++) {
+                if (!(*p >= '0' && *p <= '9')) [enc appendFormat:@"%c", *p];
+            }
+            if (![enc isEqualToString:@"v@:@"]) return;
+        }
+
+        BOOL didAdd = class_addMethod(cls,
+                                      originalSelector,
+                                      method_getImplementation(swizzledMethod),
+                                      method_getTypeEncoding(swizzledMethod));
+        if (didAdd) {
+            class_replaceMethod(cls,
+                                swizzledSelector,
+                                method_getImplementation(originalMethod),
+                                method_getTypeEncoding(originalMethod));
+        } else {
+            method_exchangeImplementations(originalMethod, swizzledMethod);
+        }
+    });
+}
+
+@implementation MoMoStatusBarTap
++ (NSNotificationName)notificationName { return @"statusBarSelected"; }
++ (void)install { mm_installStatusBarTapSwizzleOnce(); }
+@end
+
+// MARK: - Swizzle target on UIStatusBarManager
+// `mm_handleTapAction:` is the replacement IMP. After the add/exchange,
+// this selector points at the original UIKit IMP — calling it inside
+// the body invokes UIKit's real handler so UIScrollView.scrollsToTop
+// and any other side effects continue to work.
+
+@interface UIStatusBarManager (MoMoStatusBarTap)
+@end
+
+@implementation UIStatusBarManager (MoMoStatusBarTap)
+
+// Auto-install at framework load. Commented out so the swizzle stays
+// opt-in via `[MoMoStatusBarTap install]`. Uncomment to revert to
+// auto-installation before main().
+//
+// + (void)load {
+//     mm_installStatusBarTapSwizzleOnce();
+// }
+
+- (void)mm_handleTapAction:(id)action {
+    [self mm_handleTapAction:action];
+    [[NSNotificationCenter defaultCenter] postNotificationName:MoMoStatusBarTap.notificationName
+                                                        object:nil];
+}
+
+@end

package/ios/native-kits.podspec

@@ -10,7 +10,8 @@ Pod::Spec.new do |s|
   s.ios.deployment_target = '15.0'
   s.swift_version         = '5.0'
 
-  s.source_files       = "**/*.swift"
+  s.source_files       = "**/*.{swift,m,h}"
+  s.public_header_files = "StatusBarTap/*.h"
   s.framework             = 'SwiftUI', 'Combine'
   s.dependency  'SDWebImageSwiftUI'
   s.dependency       'lottie-ios'

package/local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Mon Dec 22 10:07:29 ICT 2025
+sdk.dir=/Users/phuc/Library/Android/sdk