@onekeyfe/react-native-scroll-guard 0.1.1

package/ScrollGuard.podspec

@@ -0,0 +1,29 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ScrollGuard"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/ScrollGuard+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(scrollguard)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME scrollguard)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/scrollguard+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android
+)

package/android/build.gradle

@@ -0,0 +1,124 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ScrollGuard_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/scrollguard+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ScrollGuard_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.scrollguard"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+    ]
+  }
+
+  buildFeatures {
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "scrollguardOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::scrollguard::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/scrollguard/ScrollGuard.kt

@@ -0,0 +1,117 @@
+package com.margelo.nitro.scrollguard
+
+import android.content.Context
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import android.widget.FrameLayout
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.uimanager.ThemedReactContext
+import kotlin.math.absoluteValue
+
+@DoNotStrip
+class HybridScrollGuard(val context: ThemedReactContext) : HybridScrollGuardSpec() {
+
+    override val view: View = ScrollGuardFrameLayout(context)
+
+    override var direction: ScrollGuardDirection? = ScrollGuardDirection.HORIZONTAL
+        set(value) {
+            field = value
+            (view as ScrollGuardFrameLayout).guardDirection = value ?: ScrollGuardDirection.HORIZONTAL
+        }
+}
+
+/**
+ * A native FrameLayout that prevents ancestor ViewPager2 (PagerView) from
+ * intercepting touch events that belong to child scrollable views.
+ *
+ * Mechanism: On ACTION_DOWN, immediately calls requestDisallowInterceptTouchEvent(true)
+ * to prevent all ancestors from intercepting. On ACTION_MOVE, checks the gesture
+ * direction and only keeps blocking for the guarded direction. Vertical gestures
+ * are released so the page can still scroll vertically.
+ */
+class ScrollGuardFrameLayout(context: Context) : FrameLayout(context) {
+
+    var guardDirection: ScrollGuardDirection = ScrollGuardDirection.HORIZONTAL
+
+    private var initialX = 0f
+    private var initialY = 0f
+    private val touchSlop = ViewConfiguration.get(context).scaledTouchSlop
+    private var directionDecided = false
+
+    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+        when (ev.action) {
+            MotionEvent.ACTION_DOWN -> {
+                initialX = ev.x
+                initialY = ev.y
+                directionDecided = false
+                // Immediately prevent all ancestors (including ViewPager2) from intercepting.
+                // This is critical: ViewPager2's onInterceptTouchEvent runs in the same
+                // touch dispatch pass, so we must disallow BEFORE it gets a chance to decide.
+                parent?.requestDisallowInterceptTouchEvent(true)
+            }
+            MotionEvent.ACTION_MOVE -> {
+                if (!directionDecided) {
+                    val dx = (ev.x - initialX).absoluteValue
+                    val dy = (ev.y - initialY).absoluteValue
+
+                    if (dx > touchSlop || dy > touchSlop) {
+                        directionDecided = true
+                        val isHorizontalGesture = dx > dy
+
+                        val shouldBlock = when (guardDirection) {
+                            ScrollGuardDirection.HORIZONTAL -> isHorizontalGesture
+                            ScrollGuardDirection.VERTICAL -> !isHorizontalGesture
+                            ScrollGuardDirection.BOTH -> true
+                        }
+
+                        if (shouldBlock) {
+                            // Guarded direction: keep blocking ancestors
+                            parent?.requestDisallowInterceptTouchEvent(true)
+                        } else {
+                            // Non-guarded direction: release to ancestors
+                            // (e.g., allow vertical scrolling of collapsible tabs)
+                            parent?.requestDisallowInterceptTouchEvent(false)
+                        }
+                    }
+                }
+            }
+            MotionEvent.ACTION_UP,
+            MotionEvent.ACTION_CANCEL -> {
+                directionDecided = false
+            }
+        }
+        // Never intercept: let children (ScrollView/FlatList) handle touches normally
+        return false
+    }
+
+    /**
+     * Re-assert disallow after child dispatch.
+     *
+     * This handles the case where a deeply-nested NestedScrollableHost (from another
+     * PagerView) calls requestDisallowInterceptTouchEvent(false) during its own
+     * dispatchTouchEvent, which would propagate up and override our earlier disallow.
+     */
+    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+        val handled = super.dispatchTouchEvent(ev)
+
+        if (ev.action == MotionEvent.ACTION_MOVE && directionDecided) {
+            val dx = (ev.x - initialX).absoluteValue
+            val dy = (ev.y - initialY).absoluteValue
+            val isHorizontalGesture = dx > dy
+
+            val shouldBlock = when (guardDirection) {
+                ScrollGuardDirection.HORIZONTAL -> isHorizontalGesture
+                ScrollGuardDirection.VERTICAL -> !isHorizontalGesture
+                ScrollGuardDirection.BOTH -> true
+            }
+
+            if (shouldBlock) {
+                // Re-assert after child dispatch to prevent override
+                parent?.requestDisallowInterceptTouchEvent(true)
+            }
+        }
+
+        return handled
+    }
+}

package/android/src/main/java/com/margelo/nitro/scrollguard/ScrollGuardPackage.kt

@@ -0,0 +1,27 @@
+package com.margelo.nitro.scrollguard
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class ScrollGuardPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(ScrollGuardViewGroupManager())
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("scrollguard")
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/scrollguard/ScrollGuardViewGroupManager.kt

@@ -0,0 +1,48 @@
+package com.margelo.nitro.scrollguard
+
+import android.view.View
+import com.facebook.react.uimanager.ReactStylesDiffMap
+import com.facebook.react.uimanager.StateWrapper
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.margelo.nitro.scrollguard.views.HybridScrollGuardStateUpdater
+
+/**
+ * Custom ViewGroupManager for ScrollGuard that supports child views.
+ *
+ * The nitrogen-generated HybridScrollGuardManager extends SimpleViewManager,
+ * which does not implement IViewGroupManager. Since ScrollGuardFrameLayout
+ * is a FrameLayout that wraps child scrollable views, we need a ViewGroupManager.
+ */
+class ScrollGuardViewGroupManager : ViewGroupManager<ScrollGuardFrameLayout>() {
+    private val views = hashMapOf<View, HybridScrollGuard>()
+
+    override fun getName(): String = "ScrollGuard"
+
+    override fun createViewInstance(reactContext: ThemedReactContext): ScrollGuardFrameLayout {
+        val hybridView = HybridScrollGuard(reactContext)
+        val view = hybridView.view as ScrollGuardFrameLayout
+        views[view] = hybridView
+        return view
+    }
+
+    override fun onDropViewInstance(view: ScrollGuardFrameLayout) {
+        super.onDropViewInstance(view)
+        views.remove(view)
+    }
+
+    override fun updateState(
+        view: ScrollGuardFrameLayout,
+        props: ReactStylesDiffMap,
+        stateWrapper: StateWrapper
+    ): Any? {
+        val hybridView = views[view]
+            ?: throw Error("Couldn't find view $view in local views table!")
+
+        hybridView.beforeUpdate()
+        HybridScrollGuardStateUpdater.updateViewProps(hybridView, stateWrapper)
+        hybridView.afterUpdate()
+
+        return super.updateState(view, props, stateWrapper)
+    }
+}

package/ios/ScrollGuard.swift

@@ -0,0 +1,243 @@
+import Foundation
+import UIKit
+
+class HybridScrollGuard: HybridScrollGuardSpec {
+
+  var view: UIView = ScrollGuardView()
+
+  var direction: ScrollGuardDirection? = .horizontal {
+    didSet {
+      (view as? ScrollGuardView)?.guardDirection = direction ?? .horizontal
+    }
+  }
+
+  override init() {
+    super.init()
+  }
+}
+
+// MARK: - ScrollGuardView
+
+/// Prevents ancestor PagerView from intercepting scroll gestures belonging to
+/// a sibling UIScrollView.
+///
+/// Two-layer blocking strategy:
+/// 1. A "touch detector" (UILongPressGestureRecognizer with minimumPressDuration=0)
+///    fires on touch-down IMMEDIATELY — before any pan gesture — and disables the
+///    pager's isScrollEnabled. This eliminates first-touch-after-page-transition bugs.
+/// 2. A "blocker" UIPanGestureRecognizer with require(toFail:) for belt-and-suspenders.
+///
+/// Both gestures live on the CHILD ScrollView (Nitro host views render React
+/// children as native siblings, not subviews).
+class ScrollGuardView: UIView, UIGestureRecognizerDelegate {
+
+  var guardDirection: ScrollGuardDirection = .horizontal {
+    didSet {
+      invalidateSetup()
+    }
+  }
+
+  private weak var connectedPager: UIScrollView?
+  private weak var connectedChild: UIScrollView?
+  private var blockerGesture: UIPanGestureRecognizer?
+  private var touchDetector: UILongPressGestureRecognizer?
+  private var pagerScrollEnabledOriginal: Bool = true
+
+  deinit {
+    cleanupConnection()
+  }
+
+  // MARK: - Touch pass-through
+
+  override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+    return nil
+  }
+
+  // MARK: - Lifecycle
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window != nil {
+      setupGestureBlocking()
+      if connectedChild == nil {
+        DispatchQueue.main.async { [weak self] in
+          self?.setupGestureBlocking()
+        }
+      }
+    }
+    // Do NOT clean up on window=nil — child persists across pager transitions.
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    if connectedChild == nil && window != nil {
+      setupGestureBlocking()
+    }
+  }
+
+  private func invalidateSetup() {
+    cleanupConnection()
+    if window != nil {
+      DispatchQueue.main.async { [weak self] in
+        self?.setupGestureBlocking()
+      }
+    }
+  }
+
+  private func cleanupConnection() {
+    if let child = connectedChild {
+      if let blocker = blockerGesture { child.removeGestureRecognizer(blocker) }
+      if let detector = touchDetector { child.removeGestureRecognizer(detector) }
+    }
+    // Restore pager scrolling if we disabled it
+    if let pager = connectedPager {
+      pager.isScrollEnabled = pagerScrollEnabledOriginal
+    }
+    blockerGesture = nil
+    touchDetector = nil
+    connectedPager = nil
+    connectedChild = nil
+  }
+
+  // MARK: - Setup
+
+  private func setupGestureBlocking() {
+    guard window != nil else { return }
+    guard let pagerSV = findAncestorPagingScrollView() else { return }
+    guard let childSV = findSiblingScrollView() else { return }
+
+    // Skip if already connected to the same child with gestures still attached
+    if connectedChild === childSV,
+       let blocker = blockerGesture,
+       let detector = touchDetector,
+       childSV.gestureRecognizers?.contains(blocker) == true,
+       childSV.gestureRecognizers?.contains(detector) == true {
+      return
+    }
+
+    cleanupConnection()
+
+    // 1) Touch detector — fires on touch-down BEFORE any pan gesture.
+    //    Immediately disables pager scrolling so it can't intercept.
+    let detector = UILongPressGestureRecognizer(target: self, action: #selector(handleTouchDetected(_:)))
+    detector.minimumPressDuration = 0
+    detector.cancelsTouchesInView = false
+    detector.delaysTouchesBegan = false
+    detector.delaysTouchesEnded = false
+    detector.delegate = self
+    childSV.addGestureRecognizer(detector)
+
+    // 2) Blocker pan gesture — belt-and-suspenders with require(toFail:).
+    let blocker = UIPanGestureRecognizer(target: self, action: #selector(handleBlockerPan(_:)))
+    blocker.cancelsTouchesInView = false
+    blocker.delaysTouchesBegan = false
+    blocker.delaysTouchesEnded = false
+    blocker.delegate = self
+    childSV.addGestureRecognizer(blocker)
+
+    // All pager gestures require blocker to fail
+    if let pagerGestures = pagerSV.gestureRecognizers {
+      for gesture in pagerGestures {
+        gesture.require(toFail: blocker)
+      }
+    }
+
+    blockerGesture = blocker
+    touchDetector = detector
+    connectedPager = pagerSV
+    connectedChild = childSV
+    pagerScrollEnabledOriginal = pagerSV.isScrollEnabled
+  }
+
+  // MARK: - Touch detector handler
+
+  @objc private func handleTouchDetected(_ gesture: UILongPressGestureRecognizer) {
+    guard let pager = connectedPager else { return }
+    switch gesture.state {
+    case .began:
+      // Touch down — immediately disable pager
+      pagerScrollEnabledOriginal = pager.isScrollEnabled
+      pager.isScrollEnabled = false
+    case .ended, .cancelled, .failed:
+      // Touch up — restore pager
+      pager.isScrollEnabled = pagerScrollEnabledOriginal
+    default:
+      break
+    }
+  }
+
+  // MARK: - Blocker pan handler
+
+  @objc private func handleBlockerPan(_ gesture: UIPanGestureRecognizer) {
+    // Empty — exists only for require(toFail:) blocking
+  }
+
+  // MARK: - UIGestureRecognizerDelegate
+
+  func gestureRecognizer(
+    _ gestureRecognizer: UIGestureRecognizer,
+    shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer
+  ) -> Bool {
+    return true
+  }
+
+  override func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
+    // Touch detector always begins (it handles all touches in the child area)
+    if gestureRecognizer === touchDetector { return true }
+
+    // Blocker only begins for guarded direction
+    guard gestureRecognizer === blockerGesture,
+          let pan = gestureRecognizer as? UIPanGestureRecognizer else {
+      return true
+    }
+    let velocity = pan.velocity(in: pan.view)
+    switch guardDirection {
+    case .horizontal:
+      return abs(velocity.x) > abs(velocity.y)
+    case .vertical:
+      return abs(velocity.y) > abs(velocity.x)
+    case .both:
+      return true
+    }
+  }
+
+  // MARK: - View hierarchy search
+
+  private func findAncestorPagingScrollView() -> UIScrollView? {
+    var current: UIView? = superview
+    while let v = current {
+      if let sv = v as? UIScrollView, sv.isPagingEnabled { return sv }
+      current = v.superview
+    }
+    return nil
+  }
+
+  private func findSiblingScrollView() -> UIScrollView? {
+    guard let parent = superview else { return nil }
+
+    var foundSelf = false
+    for subview in parent.subviews {
+      if subview === self { foundSelf = true; continue }
+      if foundSelf {
+        if let sv = findFirstScrollView(in: subview) { return sv }
+      }
+    }
+
+    let myFrame = self.frame
+    for subview in parent.subviews {
+      if subview === self { continue }
+      if subview.frame.intersects(myFrame) {
+        if let sv = findFirstScrollView(in: subview) { return sv }
+      }
+    }
+    return nil
+  }
+
+  private func findFirstScrollView(in view: UIView) -> UIScrollView? {
+    if let sv = view as? UIScrollView { return sv }
+    for subview in view.subviews {
+      if let sv = findFirstScrollView(in: subview) { return sv }
+    }
+    return nil
+  }
+}

package/lib/module/ScrollGuard.nitro.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export let ScrollGuardDirection = /*#__PURE__*/function (ScrollGuardDirection) {
+  ScrollGuardDirection["HORIZONTAL"] = "horizontal";
+  ScrollGuardDirection["VERTICAL"] = "vertical";
+  ScrollGuardDirection["BOTH"] = "both";
+  return ScrollGuardDirection;
+}({});
+//# sourceMappingURL=ScrollGuard.nitro.js.map

package/lib/module/ScrollGuard.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ScrollGuardDirection"],"sourceRoot":"../../src","sources":["ScrollGuard.nitro.ts"],"mappings":";;AAMA,WAAYA,oBAAoB,0BAApBA,oBAAoB;EAApBA,oBAAoB;EAApBA,oBAAoB;EAApBA,oBAAoB;EAAA,OAApBA,oBAAoB;AAAA","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import { getHostComponent } from 'react-native-nitro-modules';
+const ScrollGuardConfig = require('../nitrogen/generated/shared/json/ScrollGuardConfig.json');
+export { ScrollGuardDirection } from "./ScrollGuard.nitro.js";
+export const ScrollGuardView = getHostComponent('ScrollGuard', () => ScrollGuardConfig);
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getHostComponent","ScrollGuardConfig","require","ScrollGuardDirection","ScrollGuardView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,gBAAgB,QAAQ,4BAA4B;AAC7D,MAAMC,iBAAiB,GAAGC,OAAO,CAAC,0DAA0D,CAAC;AAE7F,SAASC,oBAAoB,QAAQ,wBAAqB;AAE1D,OAAO,MAAMC,eAAe,GAAGJ,gBAAgB,CAG7C,aAAa,EAAE,MAAMC,iBAAiB,CAAC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}