react-native-gesture-handler 2.13.3 → 2.14.0

package/RNGestureHandler.podspec

@@ -3,30 +3,6 @@ require "json"
 new_arch_enabled = ENV['RCT_NEW_ARCH_ENABLED'] == '1'
 apple_platform = new_arch_enabled ? '11.0' : '9.0'
 
-# Utility function to install dependencies if React Native's
-# install_modules_dependencies is not defined
-def install_dependencies(s, new_arch_enabled)
-  if new_arch_enabled
-    folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-
-    s.pod_target_xcconfig = {
-      'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/boost" "$(PODS_ROOT)/boost-for-react-native" "$(PODS_ROOT)/RCT-Folly"',
-      'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
-    }
-    s.compiler_flags  = folly_compiler_flags + ' -DRCT_NEW_ARCH_ENABLED'
-
-    s.dependency "React"
-    s.dependency "React-RCTFabric" # This is for fabric component
-    s.dependency "React-Codegen"
-    s.dependency "RCT-Folly"
-    s.dependency "RCTRequired"
-    s.dependency "RCTTypeSafety"
-    s.dependency "ReactCommon/turbomodule/core"
-  else
-    s.dependency "React-Core"
-  end
-end
-
 Pod::Spec.new do |s|
   # NPM package specification
   package = JSON.parse(File.read(File.join(File.dirname(__FILE__), "package.json")))
@@ -45,6 +21,24 @@ Pod::Spec.new do |s|
   if defined?(install_modules_dependencies()) != nil
     install_modules_dependencies(s);
   else
-    install_dependencies(s, new_arch_enabled)
+    if new_arch_enabled
+      folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+  
+      s.pod_target_xcconfig = {
+        'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/boost" "$(PODS_ROOT)/boost-for-react-native" "$(PODS_ROOT)/RCT-Folly"',
+        'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
+      }
+      s.compiler_flags  = folly_compiler_flags + ' -DRCT_NEW_ARCH_ENABLED'
+  
+      s.dependency "React"
+      s.dependency "React-RCTFabric" # This is for fabric component
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    else
+      s.dependency "React-Core"
+    end
   end
 end

package/android/build.gradle

@@ -139,6 +139,7 @@ android {
                     cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-Werror", "-std=c++17", "-DANDROID"
                     arguments "-DAPP_BUILD_DIR=${appProject.buildDir}",
                         "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
+                        "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_STL=c++_shared"
                     abiFilters (*reactNativeArchitectures())
                 }
@@ -179,11 +180,11 @@ android {
             }
 
             if (isNewArchitectureEnabled()) {
-                srcDirs += 'src/fabric/java'
+                srcDirs += 'fabric/src/main/java'
             } else {
                 // this folder also includes files from codegen so the library can compile with
                 // codegen turned off
-                srcDirs += 'src/paper/java'
+                srcDirs += 'paper/src/main/java'
             }
         }
     }

package/android/gradle.properties

@@ -9,8 +9,8 @@
 
 # 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
+# Default value: -Xmx10248m -XX:MaxMetaspaceSize=256m
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=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

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

@@ -19,13 +19,9 @@ class GestureHandlerOrchestrator(
    * traversing view hierarchy and looking for gesture handlers.
    */
   var minimumAlphaForTraversal = DEFAULT_MIN_ALPHA_FOR_TRAVERSAL
-
-  private val gestureHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val awaitingHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val preparedHandlers = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private val handlersToCancel = arrayOfNulls<GestureHandler<*>?>(SIMULTANEOUS_GESTURE_HANDLER_LIMIT)
-  private var gestureHandlersCount = 0
-  private var awaitingHandlersCount = 0
+  private val gestureHandlers = arrayListOf<GestureHandler<*>>()
+  private val awaitingHandlers = arrayListOf<GestureHandler<*>>()
+  private val preparedHandlers = arrayListOf<GestureHandler<*>>()
   private var isHandlingTouch = false
   private var handlingChangeSemaphore = 0
   private var finishedHandlersCleanupScheduled = false
@@ -60,23 +56,9 @@ class GestureHandlerOrchestrator(
     }
   }
 
-  private inline fun compactHandlersIf(handlers: Array<GestureHandler<*>?>, count: Int, predicate: (handler: GestureHandler<*>?) -> Boolean): Int {
-    var out = 0
-    for (i in 0 until count) {
-      if (predicate(handlers[i])) {
-        handlers[out++] = handlers[i]
-      }
-    }
-    return out
-  }
-
   private fun cleanupFinishedHandlers() {
-    var shouldCleanEmptyCells = false
-    for (i in gestureHandlersCount - 1 downTo 0) {
-      val handler = gestureHandlers[i]!!
+    for (handler in gestureHandlers.asReversed()) {
       if (isFinished(handler.state) && !handler.isAwaiting) {
-        gestureHandlers[i] = null
-        shouldCleanEmptyCells = true
         handler.reset()
         handler.apply {
           isActive = false
@@ -85,17 +67,14 @@ class GestureHandlerOrchestrator(
         }
       }
     }
-    if (shouldCleanEmptyCells) {
-      gestureHandlersCount = compactHandlersIf(gestureHandlers, gestureHandlersCount) { handler ->
-        handler != null
-      }
-    }
+
+    gestureHandlers.removeAll { isFinished(it.state) && !it.isAwaiting }
+
     finishedHandlersCleanupScheduled = false
   }
 
   private fun hasOtherHandlerToWaitFor(handler: GestureHandler<*>): Boolean {
-    for (i in 0 until gestureHandlersCount) {
-      val otherHandler = gestureHandlers[i]!!
+    for (otherHandler in gestureHandlers) {
       if (!isFinished(otherHandler.state) && shouldHandlerWaitForOther(handler, otherHandler)) {
         return true
       }
@@ -115,9 +94,7 @@ class GestureHandlerOrchestrator(
   }
 
   private fun cleanupAwaitingHandlers() {
-    awaitingHandlersCount = compactHandlersIf(awaitingHandlers, awaitingHandlersCount) { handler ->
-      handler!!.isAwaiting
-    }
+    awaitingHandlers.removeAll { !it.isAwaiting }
   }
 
   /*package*/
@@ -125,9 +102,8 @@ class GestureHandlerOrchestrator(
     handlingChangeSemaphore += 1
     if (isFinished(newState)) {
       // if there were handlers awaiting completion of this handler, we can trigger active state
-      for (i in 0 until awaitingHandlersCount) {
-        val otherHandler = awaitingHandlers[i]
-        if (shouldHandlerWaitForOther(otherHandler!!, handler)) {
+      for (otherHandler in awaitingHandlers) {
+        if (shouldHandlerWaitForOther(otherHandler, handler)) {
           if (newState == GestureHandler.STATE_END) {
             // gesture has ended, we need to kill the awaiting handler
             otherHandler.cancel()
@@ -182,21 +158,15 @@ class GestureHandlerOrchestrator(
       shouldResetProgress = true
       activationIndex = this@GestureHandlerOrchestrator.activationIndex++
     }
-    var toCancelCount = 0
-    // Cancel all handlers that are required to be cancel upon current handler's activation
-    for (i in 0 until gestureHandlersCount) {
-      val otherHandler = gestureHandlers[i]!!
+
+    for (otherHandler in gestureHandlers.asReversed()) {
       if (shouldHandlerBeCancelledBy(otherHandler, handler)) {
-        handlersToCancel[toCancelCount++] = otherHandler
+        otherHandler.cancel()
       }
     }
-    for (i in toCancelCount - 1 downTo 0) {
-      handlersToCancel[i]!!.cancel()
-    }
 
     // Clear all awaiting handlers waiting for the current handler to fail
-    for (i in awaitingHandlersCount - 1 downTo 0) {
-      val otherHandler = awaitingHandlers[i]!!
+    for (otherHandler in awaitingHandlers.reversed()) {
       if (shouldHandlerBeCancelledBy(otherHandler, handler)) {
         otherHandler.cancel()
         otherHandler.isAwaiting = false
@@ -218,32 +188,31 @@ class GestureHandlerOrchestrator(
   private fun deliverEventToGestureHandlers(event: MotionEvent) {
     // Copy handlers to "prepared handlers" array, because the list of active handlers can change
     // as a result of state updates
-    val handlersCount = gestureHandlersCount
+    preparedHandlers.clear()
+    preparedHandlers.addAll(gestureHandlers)
 
-    gestureHandlers.copyInto(preparedHandlers, 0, 0, handlersCount)
     // We want to deliver events to active handlers first in order of their activation (handlers
     // that activated first will first get event delivered). Otherwise we deliver events in the
     // order in which handlers has been added ("most direct" children goes first). Therefore we rely
     // on Arrays.sort providing a stable sort (as children are registered in order in which they
     // should be tested)
-    preparedHandlers.sortWith(handlersComparator, 0, handlersCount)
-    for (i in 0 until handlersCount) {
-      deliverEventToGestureHandler(preparedHandlers[i]!!, event)
+    preparedHandlers.sortWith(handlersComparator)
+    for (handler in preparedHandlers) {
+      deliverEventToGestureHandler(handler, event)
     }
   }
 
   private fun cancelAll() {
-    for (i in awaitingHandlersCount - 1 downTo 0) {
-      awaitingHandlers[i]!!.cancel()
+    for (handler in awaitingHandlers.reversed()) {
+      handler.cancel()
     }
     // Copy handlers to "prepared handlers" array, because the list of active handlers can change
     // as a result of state updates
-    val handlersCount = gestureHandlersCount
-    for (i in 0 until handlersCount) {
-      preparedHandlers[i] = gestureHandlers[i]
-    }
-    for (i in handlersCount - 1 downTo 0) {
-      preparedHandlers[i]!!.cancel()
+    preparedHandlers.clear()
+    preparedHandlers.addAll(gestureHandlers)
+
+    for (handler in gestureHandlers.reversed()) {
+      handler.cancel()
     }
   }
 
@@ -325,7 +294,7 @@ class GestureHandlerOrchestrator(
     return parent === wrapperView
   }
 
-  fun isAnyHandlerActive() = gestureHandlers.any { it?.state == GestureHandler.STATE_ACTIVE }
+  fun isAnyHandlerActive() = gestureHandlers.any { it.state == GestureHandler.STATE_ACTIVE }
 
   /**
    * Transforms an event in the coordinates of wrapperView into the coordinate space of the received view.
@@ -399,13 +368,11 @@ class GestureHandlerOrchestrator(
   }
 
   private fun addAwaitingHandler(handler: GestureHandler<*>) {
-    for (i in 0 until awaitingHandlersCount) {
-      if (awaitingHandlers[i] === handler) {
-        return
-      }
+    if (awaitingHandlers.contains(handler)) {
+      return
     }
-    check(awaitingHandlersCount < awaitingHandlers.size) { "Too many recognizers" }
-    awaitingHandlers[awaitingHandlersCount++] = handler
+
+    awaitingHandlers.add(handler)
     with(handler) {
       isAwaiting = true
       activationIndex = this@GestureHandlerOrchestrator.activationIndex++
@@ -413,13 +380,11 @@ class GestureHandlerOrchestrator(
   }
 
   private fun recordHandlerIfNotPresent(handler: GestureHandler<*>, view: View) {
-    for (i in 0 until gestureHandlersCount) {
-      if (gestureHandlers[i] === handler) {
-        return
-      }
+    if (gestureHandlers.contains(handler)) {
+      return
     }
-    check(gestureHandlersCount < gestureHandlers.size) { "Too many recognizers" }
-    gestureHandlers[gestureHandlersCount++] = handler
+
+    gestureHandlers.add(handler)
     handler.isActive = false
     handler.isAwaiting = false
     handler.activationIndex = Int.MAX_VALUE
@@ -608,7 +573,6 @@ class GestureHandlerOrchestrator(
   companion object {
     // The limit doesn't necessarily need to exists, it was just simpler to implement it that way
     // it is also more allocation-wise efficient to have a fixed limit
-    private const val SIMULTANEOUS_GESTURE_HANDLER_LIMIT = 20
 
     // Be default fully transparent views can receive touch
     private const val DEFAULT_MIN_ALPHA_FOR_TRAVERSAL = 0f

package/android/src/main/java/com/swmansion/gesturehandler/react/Extensions.kt

@@ -13,4 +13,4 @@ val ReactContext.UIManager: UIManagerModule
   get() = this.getNativeModule(UIManagerModule::class.java)!!
 
 fun Context.isScreenReaderOn() =
-  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isEnabled
+  (getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager).isTouchExplorationEnabled

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerButtonViewManager.kt

@@ -188,6 +188,17 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       return false
     }
 
+    private fun updateBackgroundColor(backgroundColor: Int, borderRadius: Float, selectable: Drawable?) {
+      val colorDrawable = PaintDrawable(backgroundColor)
+
+      if (borderRadius != 0f) {
+        colorDrawable.setCornerRadius(borderRadius)
+      }
+
+      val layerDrawable = LayerDrawable(if (selectable != null) arrayOf(colorDrawable, selectable) else arrayOf(colorDrawable))
+      background = layerDrawable
+    }
+
     fun updateBackground() {
       if (!needBackgroundUpdate) {
         return
@@ -223,19 +234,12 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       if (useDrawableOnForeground && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
         foreground = selectable
         if (_backgroundColor != Color.TRANSPARENT) {
-          setBackgroundColor(_backgroundColor)
+          updateBackgroundColor(_backgroundColor, borderRadius, null)
         }
       } else if (_backgroundColor == Color.TRANSPARENT && rippleColor == null) {
         background = selectable
       } else {
-        val colorDrawable = PaintDrawable(_backgroundColor)
-
-        if (borderRadius != 0f) {
-          colorDrawable.setCornerRadius(borderRadius)
-        }
-
-        val layerDrawable = LayerDrawable(if (selectable != null) arrayOf(colorDrawable, selectable) else arrayOf(colorDrawable))
-        background = layerDrawable
+        updateBackgroundColor(_backgroundColor, borderRadius, selectable)
       }
     }
 

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerEvent.kt

@@ -12,9 +12,10 @@ import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import com.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.react.eventbuilders.GestureHandlerEventDataBuilder
 
 class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>() {
-  private var extraData: WritableMap? = null
+  private var dataBuilder: GestureHandlerEventDataBuilder<*>? = null
   private var coalescingKey: Short = 0
 
   // On the new architecture, native animated expects event names prefixed with `top` instead of `on`,
@@ -26,17 +27,17 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
 
   private fun <T : GestureHandler<T>> init(
     handler: T,
-    dataExtractor: RNGestureHandlerEventDataExtractor<T>?,
+    dataBuilder: GestureHandlerEventDataBuilder<T>,
     useNativeAnimatedName: Boolean
   ) {
     super.init(handler.view!!.id)
-    extraData = createEventData(handler, dataExtractor)
-    coalescingKey = handler.eventCoalescingKey
+    this.dataBuilder = dataBuilder
     this.useTopPrefixedName = useNativeAnimatedName
+    coalescingKey = handler.eventCoalescingKey
   }
 
   override fun onDispose() {
-    extraData = null
+    dataBuilder = null
     EVENTS_POOL.release(this)
   }
 
@@ -47,7 +48,7 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
   override fun getCoalescingKey() = coalescingKey
 
   override fun dispatch(rctEventEmitter: RCTEventEmitter) {
-    rctEventEmitter.receiveEvent(viewTag, EVENT_NAME, extraData)
+    rctEventEmitter.receiveEvent(viewTag, EVENT_NAME, createEventData(dataBuilder!!))
   }
 
   companion object {
@@ -58,20 +59,17 @@ class RNGestureHandlerEvent private constructor() : Event<RNGestureHandlerEvent>
 
     fun <T : GestureHandler<T>> obtain(
       handler: T,
-      dataExtractor: RNGestureHandlerEventDataExtractor<T>?,
+      dataBuilder: GestureHandlerEventDataBuilder<T>,
       useTopPrefixedName: Boolean = false
     ): RNGestureHandlerEvent =
       (EVENTS_POOL.acquire() ?: RNGestureHandlerEvent()).apply {
-        init(handler, dataExtractor, useTopPrefixedName)
+        init(handler, dataBuilder, useTopPrefixedName)
       }
 
-    fun <T : GestureHandler<T>> createEventData(
-      handler: T,
-      dataExtractor: RNGestureHandlerEventDataExtractor<T>?
+    fun createEventData(
+      dataBuilder: GestureHandlerEventDataBuilder<*>
     ): WritableMap = Arguments.createMap().apply {
-      dataExtractor?.extractEventData(handler, this)
-      putInt("handlerTag", handler.tag)
-      putInt("state", handler.state)
+      dataBuilder.buildEventData(this)
     }
   }
 }

package/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerInteractionManager.kt

@@ -9,6 +9,8 @@ import com.swmansion.gesturehandler.core.NativeViewGestureHandler
 class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
   private val waitForRelations = SparseArray<IntArray>()
   private val simultaneousRelations = SparseArray<IntArray>()
+  private val blockingRelations = SparseArray<IntArray>()
+
   fun dropRelationsForHandlerWithTag(handlerTag: Int) {
     waitForRelations.remove(handlerTag)
     simultaneousRelations.remove(handlerTag)
@@ -33,6 +35,10 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
       val tags = convertHandlerTagsArray(config, KEY_SIMULTANEOUS_HANDLERS)
       simultaneousRelations.put(handler.tag, tags)
     }
+    if (config.hasKey(KEY_BLOCKS_HANDLERS)) {
+      val tags = convertHandlerTagsArray(config, KEY_BLOCKS_HANDLERS)
+      blockingRelations.put(handler.tag, tags)
+    }
   }
 
   override fun shouldWaitForHandlerFailure(handler: GestureHandler<*>, otherHandler: GestureHandler<*>) =
@@ -41,7 +47,7 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
   override fun shouldRequireHandlerToWaitForFailure(
     handler: GestureHandler<*>,
     otherHandler: GestureHandler<*>,
-  ) = false
+  ) = blockingRelations[handler.tag]?.any { tag -> tag == otherHandler.tag } ?: false
 
   override fun shouldHandlerBeCancelledBy(handler: GestureHandler<*>, otherHandler: GestureHandler<*>): Boolean {
     if (otherHandler is NativeViewGestureHandler) {
@@ -63,5 +69,6 @@ class RNGestureHandlerInteractionManager : GestureHandlerInteractionController {
   companion object {
     private const val KEY_WAIT_FOR = "waitFor"
     private const val KEY_SIMULTANEOUS_HANDLERS = "simultaneousHandlers"
+    private const val KEY_BLOCKS_HANDLERS = "blocksHandlers"
   }
 }