@amazon-devices/react-native-gesture-handler 2.0.1758683737

package/android/build.gradle

@@ -0,0 +1,205 @@
+import groovy.json.JsonSlurper
+
+import javax.inject.Inject
+import java.nio.file.Files
+
+buildscript {
+    def kotlin_version = rootProject.ext.has('kotlinVersion') ? rootProject.ext.get('kotlinVersion') : project.properties['RNGH_kotlinVersion']
+
+    repositories {
+        maven {
+            url "https://plugins.gradle.org/m2/"
+        }
+        mavenCentral()
+        google()
+    }
+
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version")
+        classpath("com.android.tools.build:gradle:7.2.1")
+        classpath("com.diffplug.spotless:spotless-plugin-gradle:6.7.2")
+    }
+}
+
+def isNewArchitectureEnabled() {
+    // To opt-in for the New Architecture, you can either:
+    // - Set `newArchEnabled` to true inside the `gradle.properties` file
+    // - Invoke gradle with `-newArchEnabled=true`
+    // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def resolveReactNativeDirectory() {
+    def reactNativeLocation = safeExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+    if (reactNativeLocation != null) {
+        return file(reactNativeLocation)
+    }
+
+    // monorepo workaround
+    // react-native can be hoisted or in project's own node_modules
+    def reactNativeFromProjectNodeModules = file("${rootProject.projectDir}/../node_modules/react-native")
+    if (reactNativeFromProjectNodeModules.exists()) {
+        return reactNativeFromProjectNodeModules
+    }
+
+    def reactNativeFromNodeModulesWithReanimated = file("${projectDir}/../../react-native")
+    if (reactNativeFromNodeModulesWithReanimated.exists()) {
+        return reactNativeFromNodeModulesWithReanimated
+    }
+
+    throw new Exception(
+        "[react-native-gesture-handler] Unable to resolve react-native location in " +
+            "node_modules. You should add project extension property (in app/build.gradle) " +
+            "`REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
+    )
+}
+
+if (isNewArchitectureEnabled()) {
+    apply plugin: 'com.facebook.react'
+}
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+if (project == rootProject) {
+    apply from: "spotless.gradle"
+}
+
+// Check whether Reanimated 2.3 or higher is installed alongside Gesture Handler
+def shouldUseCommonInterfaceFromReanimated() {
+    def reanimated = rootProject.subprojects.find { it.name == 'react-native-reanimated' }
+    if (reanimated != null) {
+        def inputFile = new File(reanimated.projectDir, '../package.json')
+        def json = new JsonSlurper().parseText(inputFile.text)
+        def reanimatedVersion = json.version as String
+        def (major, minor, patch) = reanimatedVersion.tokenize('.')
+        return (Integer.parseInt(major) == 2 && Integer.parseInt(minor) >= 3) || Integer.parseInt(major) == 3
+    } else {
+        return false
+    }
+}
+
+def reactNativeArchitectures() {
+    def value = project.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def REACT_NATIVE_DIR = resolveReactNativeDirectory()
+
+def reactProperties = new Properties()
+file("$REACT_NATIVE_DIR/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
+
+def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
+def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.startsWith("0.0.0-") ? 1000 : REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
+
+repositories {
+    mavenCentral()
+}
+
+android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 33)
+    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
+    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
+        namespace "com.swmansion.gesturehandler"
+    }
+
+    // Used to override the NDK path/version on internal CI or by allowing
+    // users to customize the NDK path/version from their root project (e.g. for M1 support)
+    if (rootProject.hasProperty("ndkPath")) {
+        ndkPath rootProject.ext.ndkPath
+    }
+    if (rootProject.hasProperty("ndkVersion")) {
+        ndkVersion rootProject.ext.ndkVersion
+    }
+
+    if (REACT_NATIVE_MINOR_VERSION >= 71) {
+        buildFeatures {
+            prefab true
+        }
+    }
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+        targetSdkVersion safeExtGet('targetSdkVersion', 33)
+        versionCode 1
+        versionName "1.0"
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+        buildConfigField "int", "REACT_NATIVE_MINOR_VERSION", REACT_NATIVE_MINOR_VERSION.toString()
+
+        if (isNewArchitectureEnabled()) {
+            var appProject = rootProject.allprojects.find {it.plugins.hasPlugin('com.android.application')}
+            externalNativeBuild {
+                cmake {
+                    cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-Werror", "-std=c++17", "-DANDROID"
+                    arguments "-DAPP_BUILD_DIR=${appProject.buildDir}",
+                        "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
+                        "-DANDROID_STL=c++_shared"
+                    abiFilters (*reactNativeArchitectures())
+                }
+            }
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    if (isNewArchitectureEnabled()) {
+        externalNativeBuild {
+            cmake {
+                path "src/main/jni/CMakeLists.txt"
+            }
+        }
+    }
+
+    packagingOptions {
+        // For some reason gradle only complains about the duplicated version of libreact_render libraries
+        // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
+        // only the ones that make the build fail (ideally we should only include libgesturehandler but we
+        // are only allowed to specify exclude patterns)
+        exclude "**/libreact_render*.so"
+    }
+
+    sourceSets.main {
+        java {
+            // Include "common/" only when it's not provided by Reanimated to mitigate
+            // multiple definitions of the same class preventing build
+            if (shouldUseCommonInterfaceFromReanimated()) {
+                srcDirs += 'reanimated/src/main/java'
+            } else {
+                srcDirs += 'common/src/main/java'
+                srcDirs += 'noreanimated/src/main/java'
+            }
+
+            if (isNewArchitectureEnabled()) {
+                srcDirs += 'src/fabric/java'
+            } else {
+                // this folder also includes files from codegen so the library can compile with
+                // codegen turned off
+                srcDirs += 'src/paper/java'
+            }
+        }
+    }
+}
+
+def kotlin_version = safeExtGet('kotlinVersion', project.properties['RNGH_kotlinVersion'])
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+' // from node_modules
+    
+
+    if (shouldUseCommonInterfaceFromReanimated()) {
+        // Include Reanimated as dependency to load the common interface
+        implementation (rootProject.subprojects.find { it.name == 'react-native-reanimated' }) {
+            exclude group:'com.facebook.fbjni' // resolves "Duplicate class com.facebook.jni.CppException"
+        }
+    }
+
+    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation "androidx.core:core-ktx:1.6.0"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/common/src/main/java/com/swmansion/common/GestureHandlerStateManager.kt

@@ -0,0 +1,5 @@
+package com.swmansion.common
+
+interface GestureHandlerStateManager {
+  fun setGestureHandlerState(handlerTag: Int, newState: Int)
+}

package/android/gradle.properties

@@ -0,0 +1,19 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx10248m -XX:MaxPermSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+RNGH_kotlinVersion=1.6.21

package/android/noreanimated/src/main/java/com/swmansion/gesturehandler/ReanimatedEventDispatcher.kt

@@ -0,0 +1,10 @@
+package com.swmansion.gesturehandler
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.events.Event
+
+class ReanimatedEventDispatcher {
+  fun <T : Event<T>>sendEvent(event: T, reactApplicationContext: ReactContext) {
+    // no-op
+  }
+}

package/android/reanimated/src/main/java/com/swmansion/gesturehandler/ReanimatedEventDispatcher.kt

@@ -0,0 +1,17 @@
+package com.swmansion.gesturehandler
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.uimanager.events.Event
+import com.swmansion.reanimated.ReanimatedModule
+
+class ReanimatedEventDispatcher {
+  private var reanimatedModule: ReanimatedModule? = null
+
+  fun <T : Event<T>>sendEvent(event: T, reactApplicationContext: ReactContext) {
+    if (reanimatedModule == null) {
+      reanimatedModule = reactApplicationContext.getNativeModule(ReanimatedModule::class.java)
+    }
+
+    reanimatedModule?.nodesManager?.onEventDispatch(event)
+  }
+}

package/android/src/fabric/java/com/swmansion/gesturehandler/RNGestureHandlerComponentsRegistry.java

@@ -0,0 +1,29 @@
+package com.swmansion.gesturehandler.react;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.fabric.ComponentFactory;
+import com.facebook.soloader.SoLoader;
+
+@DoNotStrip
+public class RNGestureHandlerComponentsRegistry {
+  static {
+    SoLoader.loadLibrary("fabricjni");
+    SoLoader.loadLibrary("gesturehandler");
+  }
+
+  @DoNotStrip private final HybridData mHybridData;
+
+  @DoNotStrip
+  private native HybridData initHybrid(ComponentFactory componentFactory);
+
+  @DoNotStrip
+  private RNGestureHandlerComponentsRegistry(ComponentFactory componentFactory) {
+    mHybridData = initHybrid(componentFactory);
+  }
+
+  @DoNotStrip
+  public static RNGestureHandlerComponentsRegistry register(ComponentFactory componentFactory) {
+    return new RNGestureHandlerComponentsRegistry(componentFactory);
+  }
+}

package/android/src/fabric/java/com/swmansion/gesturehandler/ReactContextExtensions.kt

@@ -0,0 +1,12 @@
+package com.swmansion.gesturehandler
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.fabric.FabricUIManager
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.events.Event
+
+fun ReactContext.dispatchEvent(event: Event<*>) {
+  val fabricUIManager = UIManagerHelper.getUIManager(this, UIManagerType.FABRIC) as FabricUIManager
+  fabricUIManager.eventDispatcher.dispatchEvent(event)
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/com/swmansion/gesturehandler/RNGestureHandlerPackage.kt

@@ -0,0 +1,21 @@
+package com.swmansion.gesturehandler
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.swmansion.gesturehandler.react.RNGestureHandlerButtonViewManager
+import com.swmansion.gesturehandler.react.RNGestureHandlerModule
+import com.swmansion.gesturehandler.react.RNGestureHandlerRootViewManager
+
+class RNGestureHandlerPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf<NativeModule>(RNGestureHandlerModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext) =
+    listOf<ViewManager<*, *>>(
+      RNGestureHandlerRootViewManager(),
+      RNGestureHandlerButtonViewManager()
+    )
+}

package/android/src/main/java/com/swmansion/gesturehandler/core/FlingGestureHandler.kt

@@ -0,0 +1,100 @@
+package com.swmansion.gesturehandler.core
+
+import android.os.Handler
+import android.os.Looper
+import android.view.MotionEvent
+
+class FlingGestureHandler : GestureHandler<FlingGestureHandler>() {
+  var numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED
+  var direction = DEFAULT_DIRECTION
+
+  private val maxDurationMs = DEFAULT_MAX_DURATION_MS
+  private val minAcceptableDelta = DEFAULT_MIN_ACCEPTABLE_DELTA
+  private var startX = 0f
+  private var startY = 0f
+  private var handler: Handler? = null
+  private var maxNumberOfPointersSimultaneously = 0
+  private val failDelayed = Runnable { fail() }
+
+  override fun resetConfig() {
+    super.resetConfig()
+    numberOfPointersRequired = DEFAULT_NUMBER_OF_TOUCHES_REQUIRED
+    direction = DEFAULT_DIRECTION
+  }
+
+  private fun startFling(event: MotionEvent) {
+    startX = event.rawX
+    startY = event.rawY
+    begin()
+    maxNumberOfPointersSimultaneously = 1
+    if (handler == null) {
+      handler = Handler(Looper.getMainLooper()) // lazy delegate?
+    } else {
+      handler!!.removeCallbacksAndMessages(null)
+    }
+    handler!!.postDelayed(failDelayed, maxDurationMs)
+  }
+
+  private fun tryEndFling(event: MotionEvent) = if (
+    maxNumberOfPointersSimultaneously == numberOfPointersRequired &&
+    (
+      direction and DIRECTION_RIGHT != 0 &&
+        event.rawX - startX > minAcceptableDelta ||
+        direction and DIRECTION_LEFT != 0 &&
+        startX - event.rawX > minAcceptableDelta ||
+        direction and DIRECTION_UP != 0 &&
+        startY - event.rawY > minAcceptableDelta ||
+        direction and DIRECTION_DOWN != 0 &&
+        event.rawY - startY > minAcceptableDelta
+      )
+  ) {
+    handler!!.removeCallbacksAndMessages(null)
+    activate()
+    true
+  } else {
+    false
+  }
+
+  override fun activate(force: Boolean) {
+    super.activate(force)
+    end()
+  }
+
+  private fun endFling(event: MotionEvent) {
+    if (!tryEndFling(event)) {
+      fail()
+    }
+  }
+
+  override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
+    val state = state
+    if (state == STATE_UNDETERMINED) {
+      startFling(sourceEvent)
+    }
+    if (state == STATE_BEGAN) {
+      tryEndFling(sourceEvent)
+      if (sourceEvent.pointerCount > maxNumberOfPointersSimultaneously) {
+        maxNumberOfPointersSimultaneously = sourceEvent.pointerCount
+      }
+      val action = sourceEvent.actionMasked
+      if (action == MotionEvent.ACTION_UP) {
+        endFling(sourceEvent)
+      }
+    }
+  }
+
+  override fun onCancel() {
+    handler?.removeCallbacksAndMessages(null)
+  }
+
+  override fun onReset() {
+    handler?.removeCallbacksAndMessages(null)
+  }
+
+  companion object {
+    private const val DEFAULT_MAX_DURATION_MS: Long = 800
+    private const val DEFAULT_MIN_ACCEPTABLE_DELTA: Long = 160
+    private const val DEFAULT_DIRECTION = DIRECTION_RIGHT
+    private const val DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1
+  }
+}