react-native-gesture-handler 1.10.1 → 2.1.0

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

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

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

@@ -0,0 +1,95 @@
+package com.swmansion.gesturehandler.react
+
+import android.util.SparseArray
+import android.view.View
+import com.facebook.react.bridge.UiThreadUtil
+import com.swmansion.gesturehandler.GestureHandler
+import com.swmansion.gesturehandler.GestureHandlerRegistry
+import java.util.*
+
+class RNGestureHandlerRegistry : GestureHandlerRegistry {
+  private val handlers = SparseArray<GestureHandler<*>>()
+  private val attachedTo = SparseArray<Int?>()
+  private val handlersForView = SparseArray<ArrayList<GestureHandler<*>>>()
+
+  @Synchronized
+  fun registerHandler(handler: GestureHandler<*>) {
+    handlers.put(handler.tag, handler)
+  }
+
+  @Synchronized
+  fun getHandler(handlerTag: Int): GestureHandler<*>? {
+    return handlers[handlerTag]
+  }
+
+  @Synchronized
+  fun attachHandlerToView(handlerTag: Int, viewTag: Int, useDeviceEvents: Boolean = false): Boolean {
+    val handler = handlers[handlerTag]
+    return handler?.let {
+      detachHandler(handler)
+      handler.usesDeviceEvents = useDeviceEvents
+      registerHandlerForViewWithTag(viewTag, handler)
+      true
+    } ?: false
+  }
+
+  @Synchronized
+  private fun registerHandlerForViewWithTag(viewTag: Int, handler: GestureHandler<*>) {
+    check(attachedTo[handler.tag] == null) { "Handler $handler already attached" }
+    attachedTo.put(handler.tag, viewTag)
+    var listToAdd = handlersForView[viewTag]
+    if (listToAdd == null) {
+      listToAdd = ArrayList(1)
+      listToAdd.add(handler)
+      handlersForView.put(viewTag, listToAdd)
+    } else {
+      listToAdd.add(handler)
+    }
+  }
+
+  @Synchronized
+  private fun detachHandler(handler: GestureHandler<*>) {
+    val attachedToView = attachedTo[handler.tag]
+    if (attachedToView != null) {
+      attachedTo.remove(handler.tag)
+      val attachedHandlers = handlersForView[attachedToView]
+      if (attachedHandlers != null) {
+        attachedHandlers.remove(handler)
+        if (attachedHandlers.size == 0) {
+          handlersForView.remove(attachedToView)
+        }
+      }
+    }
+    if (handler.view != null) {
+      // Handler is in "prepared" state which means it is registered in the orchestrator and can
+      // receive touch events. This means that before we remove it from the registry we need to
+      // "cancel" it so that orchestrator does no longer keep a reference to it.
+      UiThreadUtil.runOnUiThread { handler.cancel() }
+    }
+  }
+
+  @Synchronized
+  fun dropHandler(handlerTag: Int) {
+    handlers[handlerTag]?.let {
+      detachHandler(it)
+      handlers.remove(handlerTag)
+    }
+  }
+
+  @Synchronized
+  fun dropAllHandlers() {
+    handlers.clear()
+    attachedTo.clear()
+    handlersForView.clear()
+  }
+
+  @Synchronized
+  fun getHandlersForViewWithTag(viewTag: Int): ArrayList<GestureHandler<*>>? {
+    return handlersForView[viewTag]
+  }
+
+  @Synchronized
+  override fun getHandlersForView(view: View): ArrayList<GestureHandler<*>>? {
+    return getHandlersForViewWithTag(view.id)
+  }
+}

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

@@ -0,0 +1,132 @@
+package com.swmansion.gesturehandler.react
+
+import android.os.SystemClock
+import android.util.Log
+import android.view.MotionEvent
+import android.view.ViewGroup
+import android.view.ViewParent
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.views.modal.ReactModalHostView
+import com.swmansion.gesturehandler.GestureHandler
+import com.swmansion.gesturehandler.GestureHandlerOrchestrator
+
+class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView: ViewGroup) {
+  private val orchestrator: GestureHandlerOrchestrator?
+  private val jsGestureHandler: GestureHandler<*>?
+  val rootView: ViewGroup
+  private var shouldIntercept = false
+  private var passingTouch = false
+
+  init {
+    UiThreadUtil.assertOnUiThread()
+    val wrappedViewTag = wrappedView.id
+    check(wrappedViewTag >= 1) { "Expect view tag to be set for $wrappedView" }
+    val module = context.getNativeModule(RNGestureHandlerModule::class.java)!!
+    val registry = module.registry
+    rootView = findRootViewTag(wrappedView)
+    Log.i(
+      ReactConstants.TAG,
+      "[GESTURE HANDLER] Initialize gesture handler for root view $rootView")
+    orchestrator = GestureHandlerOrchestrator(
+      wrappedView, registry, RNViewConfigurationHelper()).apply {
+      minimumAlphaForTraversal = MIN_ALPHA_FOR_TOUCH
+    }
+    jsGestureHandler = RootViewGestureHandler().apply { tag = -wrappedViewTag }
+    with(registry) {
+      registerHandler(jsGestureHandler)
+      attachHandlerToView(jsGestureHandler.tag, wrappedViewTag)
+    }
+    module.registerRootHelper(this)
+  }
+
+  fun tearDown() {
+    Log.i(
+      ReactConstants.TAG,
+      "[GESTURE HANDLER] Tearing down gesture handler registered for root view $rootView")
+    val module = context.getNativeModule(RNGestureHandlerModule::class.java)!!
+    with(module) {
+      registry.dropHandler(jsGestureHandler!!.tag)
+      unregisterRootHelper(this@RNGestureHandlerRootHelper)
+    }
+  }
+
+  private inner class RootViewGestureHandler : GestureHandler<RootViewGestureHandler>() {
+    override fun onHandle(event: MotionEvent) {
+      val currentState = state
+      if (currentState == STATE_UNDETERMINED) {
+        begin()
+        shouldIntercept = false
+      }
+      if (event.actionMasked == MotionEvent.ACTION_UP) {
+        end()
+      }
+    }
+
+    override fun onCancel() {
+      shouldIntercept = true
+      val time = SystemClock.uptimeMillis()
+      val event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0f, 0f, 0).apply {
+        action = MotionEvent.ACTION_CANCEL
+      }
+      if (rootView is RootView) {
+        rootView.onChildStartedNativeGesture(event)
+      }
+    }
+  }
+
+  fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // If this method gets called it means that some native view is attempting to grab lock for
+    // touch event delivery. In that case we cancel all gesture recognizers
+    if (orchestrator != null && !passingTouch) {
+      // if we are in the process of delivering touch events via GH orchestrator, we don't want to
+      // treat it as a native gesture capturing the lock
+      tryCancelAllHandlers()
+    }
+  }
+
+  fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    // We mark `mPassingTouch` before we get into `mOrchestrator.onTouchEvent` so that we can tell
+    // if `requestDisallow` has been called as a result of a normal gesture handling process or
+    // as a result of one of the gesture handlers activating
+    passingTouch = true
+    orchestrator!!.onTouchEvent(ev)
+    passingTouch = false
+    return shouldIntercept
+  }
+
+  private fun tryCancelAllHandlers() {
+    // In order to cancel handlers we activate handler that is hooked to the root view
+    jsGestureHandler?.apply {
+      if (state == GestureHandler.STATE_BEGAN) {
+        // Try activate main JS handler
+        activate()
+        end()
+      }
+    }
+  }
+
+  /*package*/
+  fun handleSetJSResponder(viewTag: Int, blockNativeResponder: Boolean) {
+    if (blockNativeResponder) {
+      UiThreadUtil.runOnUiThread { tryCancelAllHandlers() }
+    }
+  }
+
+  companion object {
+    private const val MIN_ALPHA_FOR_TOUCH = 0.1f
+    private fun findRootViewTag(viewGroup: ViewGroup): ViewGroup {
+      UiThreadUtil.assertOnUiThread()
+      var parent: ViewParent? = viewGroup
+      while (parent != null && parent !is RootView) {
+        parent = parent.parent
+      }
+      checkNotNull(parent) {
+        "View $viewGroup has not been mounted under ReactRootView"
+      }
+      return parent as ViewGroup
+    }
+  }
+}

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

@@ -0,0 +1,5 @@
+package com.swmansion.gesturehandler.react
+
+interface RNGestureHandlerRootInterface {
+  val rootHelper: RNGestureHandlerRootHelper?
+}

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

@@ -0,0 +1,68 @@
+package com.swmansion.gesturehandler.react
+
+import android.content.Context
+import android.util.Log
+import android.view.MotionEvent
+import android.view.ViewGroup
+import android.view.ViewParent
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.views.modal.ReactModalHostView
+import com.facebook.react.views.view.ReactViewGroup
+
+class RNGestureHandlerRootView(context: Context?) : ReactViewGroup(context) {
+  private var _enabled = false
+  private var rootHelper: RNGestureHandlerRootHelper? = null // TODO: resettable lateinit
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    _enabled = !hasGestureHandlerEnabledRootView(this)
+    if (!_enabled) {
+      Log.i(
+        ReactConstants.TAG,
+        "[GESTURE HANDLER] Gesture handler is already enabled for a parent view"
+      )
+    }
+    if (_enabled && rootHelper == null) {
+      rootHelper = RNGestureHandlerRootHelper(context as ReactContext, this)
+    }
+  }
+
+  fun tearDown() {
+    rootHelper?.tearDown()
+  }
+
+  override fun dispatchTouchEvent(ev: MotionEvent) =
+    if (_enabled && rootHelper!!.dispatchTouchEvent(ev)) {
+      true
+    } else super.dispatchTouchEvent(ev)
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    if (_enabled) {
+      rootHelper!!.requestDisallowInterceptTouchEvent(disallowIntercept)
+    }
+    super.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  companion object {
+    private fun hasGestureHandlerEnabledRootView(viewGroup: ViewGroup): Boolean {
+      UiThreadUtil.assertOnUiThread()
+
+      var parent = viewGroup.parent
+      while (parent != null) {
+        if (parent is RNGestureHandlerEnabledRootView || parent is RNGestureHandlerRootView) {
+          return true
+        }
+        // Checks other roots views but it's mainly for ReactModalHostView.DialogRootViewGroup
+        // since modals are outside RN hierachy and we have to initialize GH's root view for it
+        // Note that RNGestureHandlerEnabledRootView implements RootView - that's why this check has to be below
+        if (parent is RootView) {
+          return false
+        }
+        parent = parent.parent
+      }
+      return false
+    }
+  }
+}

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

@@ -0,0 +1,34 @@
+package com.swmansion.gesturehandler.react
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+
+/**
+ * React native's view manager used for creating instances of []RNGestureHandlerRootView}. It
+ * is being used by projects using react-native-navigation where for each screen new root view need
+ * to be provided.
+ */
+@ReactModule(name = RNGestureHandlerRootViewManager.REACT_CLASS)
+class RNGestureHandlerRootViewManager : ViewGroupManager<RNGestureHandlerRootView>() {
+  override fun getName() = REACT_CLASS
+  override fun createViewInstance(reactContext: ThemedReactContext) = RNGestureHandlerRootView(reactContext)
+
+  override fun onDropViewInstance(view: RNGestureHandlerRootView) {
+    view.tearDown()
+  }
+
+  /**
+   * The following event configuration is necessary even if you are not using
+   * GestureHandlerRootView component directly.
+   */
+  override fun getExportedCustomDirectEventTypeConstants(): Map<String, Map<String, String>> = mutableMapOf(
+    RNGestureHandlerEvent.EVENT_NAME to
+      mutableMapOf("registrationName" to RNGestureHandlerEvent.EVENT_NAME),
+    RNGestureHandlerStateChangeEvent.EVENT_NAME to
+      mutableMapOf("registrationName" to RNGestureHandlerStateChangeEvent.EVENT_NAME))
+
+  companion object {
+    const val REACT_CLASS = "GestureHandlerRootView"
+  }
+}

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

@@ -0,0 +1,66 @@
+package com.swmansion.gesturehandler.react
+
+import androidx.core.util.Pools
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.swmansion.gesturehandler.GestureHandler
+
+class RNGestureHandlerStateChangeEvent private constructor() : Event<RNGestureHandlerStateChangeEvent>() {
+  private var extraData: WritableMap? = null
+  private fun <T : GestureHandler<T>> init(
+    handler: T,
+    newState: Int,
+    oldState: Int,
+    dataExtractor: RNGestureHandlerEventDataExtractor<T>?,
+  ) {
+    super.init(handler.view!!.id)
+    extraData = createEventData(handler, dataExtractor, newState, oldState)
+  }
+
+  override fun onDispose() {
+    extraData = null
+    EVENTS_POOL.release(this)
+  }
+
+  override fun getEventName() = EVENT_NAME
+
+  // TODO: coalescing
+  override fun canCoalesce() = false
+
+  // TODO: coalescing
+  override fun getCoalescingKey(): Short = 0
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    rctEventEmitter.receiveEvent(viewTag, EVENT_NAME, extraData)
+  }
+
+  companion object {
+    const val EVENT_NAME = "onGestureHandlerStateChange"
+    private const val TOUCH_EVENTS_POOL_SIZE = 7 // magic
+    private val EVENTS_POOL = Pools.SynchronizedPool<RNGestureHandlerStateChangeEvent>(TOUCH_EVENTS_POOL_SIZE)
+
+    fun <T : GestureHandler<T>> obtain(
+      handler: T,
+      newState: Int,
+      oldState: Int,
+      dataExtractor: RNGestureHandlerEventDataExtractor<T>?,
+    ): RNGestureHandlerStateChangeEvent =
+      (EVENTS_POOL.acquire() ?: RNGestureHandlerStateChangeEvent()).apply {
+        init(handler, newState, oldState, dataExtractor)
+      }
+
+    fun <T: GestureHandler<T>> createEventData(
+      handler: T,
+      dataExtractor: RNGestureHandlerEventDataExtractor<T>?,
+      newState: Int,
+      oldState: Int,
+    ): WritableMap = Arguments.createMap().apply {
+        dataExtractor?.extractEventData(handler, this)
+        putInt("handlerTag", handler.tag)
+        putInt("state", newState)
+        putInt("oldState", oldState)
+      }
+  }
+}

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

@@ -0,0 +1,69 @@
+package com.swmansion.gesturehandler.react
+
+import androidx.core.util.Pools
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.swmansion.gesturehandler.GestureHandler
+
+class RNGestureHandlerTouchEvent private constructor() : Event<RNGestureHandlerTouchEvent>() {
+  private var extraData: WritableMap? = null
+  private var coalescingKey: Short = 0
+  private fun <T : GestureHandler<T>> init(handler: T) {
+    super.init(handler.view!!.id)
+    extraData = createEventData(handler)
+    coalescingKey = handler.eventCoalescingKey
+  }
+
+  override fun onDispose() {
+    extraData = null
+    EVENTS_POOL.release(this)
+  }
+
+  override fun getEventName() = EVENT_NAME
+
+  override fun canCoalesce() = true
+
+  override fun getCoalescingKey() = coalescingKey
+
+  override fun dispatch(rctEventEmitter: RCTEventEmitter) {
+    rctEventEmitter.receiveEvent(viewTag, EVENT_NAME, extraData)
+  }
+
+  companion object {
+    const val EVENT_UNDETERMINED = 0
+    const val EVENT_TOUCH_DOWN = 1
+    const val EVENT_TOUCH_MOVE = 2
+    const val EVENT_TOUCH_UP = 3
+    const val EVENT_TOUCH_CANCELLED = 4
+
+    const val EVENT_NAME = "onGestureHandlerEvent"
+    private const val TOUCH_EVENTS_POOL_SIZE = 7 // magic
+    private val EVENTS_POOL = Pools.SynchronizedPool<RNGestureHandlerTouchEvent>(TOUCH_EVENTS_POOL_SIZE)
+
+    fun <T : GestureHandler<T>> obtain(handler: T): RNGestureHandlerTouchEvent =
+        (EVENTS_POOL.acquire() ?: RNGestureHandlerTouchEvent()).apply {
+          init(handler)
+        }
+
+    fun <T: GestureHandler<T>> createEventData(handler: T,): WritableMap = Arguments.createMap().apply {
+      putInt("handlerTag", handler.tag)
+      putInt("state", handler.state)
+      putInt("numberOfTouches", handler.trackedPointersCount)
+      putInt("eventType", handler.touchEventType)
+
+      handler.consumeChangedTouchesPayload()?.let {
+        putArray("changedTouches", it)
+      }
+
+      handler.consumeAllTouchesPayload()?.let {
+        putArray("allTouches", it)
+      }
+
+      if (handler.isAwaiting && handler.state == GestureHandler.STATE_ACTIVE) {
+        putInt("state", GestureHandler.STATE_BEGAN)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+package com.swmansion.gesturehandler.react
+
+import android.view.View
+import android.view.ViewGroup
+import com.facebook.react.uimanager.PointerEvents
+import com.facebook.react.uimanager.ReactPointerEventsView
+import com.facebook.react.views.view.ReactViewGroup
+import com.swmansion.gesturehandler.PointerEventsConfig
+import com.swmansion.gesturehandler.ViewConfigurationHelper
+
+class RNViewConfigurationHelper : ViewConfigurationHelper {
+  override fun getPointerEventsConfigForView(view: View): PointerEventsConfig {
+    val pointerEvents: PointerEvents =
+      if (view is ReactPointerEventsView) {
+        (view as ReactPointerEventsView).pointerEvents
+      } else PointerEvents.AUTO
+
+    // Views that are disabled should never be the target of pointer events. However, their children
+    // can be because some views (SwipeRefreshLayout) use enabled but still have children that can
+    // be valid targets.
+    if (!view.isEnabled) {
+      if (pointerEvents == PointerEvents.AUTO) {
+        return PointerEventsConfig.BOX_NONE
+      } else if (pointerEvents == PointerEvents.BOX_ONLY) {
+        return PointerEventsConfig.NONE
+      }
+    }
+
+    return when (pointerEvents) {
+      PointerEvents.BOX_ONLY -> PointerEventsConfig.BOX_ONLY
+      PointerEvents.BOX_NONE -> PointerEventsConfig.BOX_NONE
+      PointerEvents.NONE -> PointerEventsConfig.NONE
+      PointerEvents.AUTO -> PointerEventsConfig.AUTO
+    }
+  }
+
+  override fun getChildInDrawingOrderAtIndex(parent: ViewGroup, index: Int): View {
+    return if (parent is ReactViewGroup) {
+      parent.getChildAt(parent.getZIndexMappedChildIndex(index))
+    } else parent.getChildAt(index)
+  }
+
+  override fun isViewClippingChildren(view: ViewGroup): Boolean {
+    if (view.clipChildren) {
+      return true
+    }
+    return if (view is ReactViewGroup) {
+      "hidden" == view.overflow
+    } else false
+  }
+}

package/ios/Handlers/RNFlingHandler.m

@@ -1,14 +1,78 @@
 #import "RNFlingHandler.h"
 
+@interface RNBetterSwipeGestureRecognizer : UISwipeGestureRecognizer
+
+- (id)initWithGestureHandler:(RNGestureHandler*)gestureHandler;
+
+@end
+
+@implementation RNBetterSwipeGestureRecognizer {
+  __weak RNGestureHandler* _gestureHandler;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:gestureHandler action:@selector(handleGesture:)])) {
+    _gestureHandler = gestureHandler;
+  }
+  return self;
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [_gestureHandler reset];
+  [self triggerAction];
+  [super touchesBegan:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesBegan:touches withEvent:event];
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesEnded:touches withEvent:event];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+  [_gestureHandler.pointerTracker touchesCancelled:touches withEvent:event];
+}
+
+- (void)triggerAction
+{
+  [_gestureHandler handleGesture:self];
+}
+
+- (void)reset
+{
+  [self triggerAction];
+  [_gestureHandler.pointerTracker reset];
+  [super reset];
+}
+
+@end
+
 @implementation RNFlingGestureHandler
 
 - (instancetype)initWithTag:(NSNumber *)tag
 {
-    if ((self = [super initWithTag:tag])) {
-        _recognizer = [[UISwipeGestureRecognizer alloc] initWithTarget:self action:@selector(handleGesture:)];
-        
-    }
-    return self;
+  if ((self = [super initWithTag:tag])) {
+    _recognizer = [[RNBetterSwipeGestureRecognizer alloc] initWithGestureHandler:self];
+  }
+  return self;
+}
+- (void)resetConfig
+{
+  [super resetConfig];
+  UISwipeGestureRecognizer *recognizer = (UISwipeGestureRecognizer *)_recognizer;
+  recognizer.direction = UISwipeGestureRecognizerDirectionRight;
+  recognizer.numberOfTouchesRequired = 1;
 }
 
 - (void)configure:(NSDictionary *)config
@@ -29,5 +93,14 @@
 #endif
 }
 
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)gestureRecognizer
+{
+    RNGestureHandlerState savedState = _lastState;
+    BOOL shouldBegin = [super gestureRecognizerShouldBegin:gestureRecognizer];
+    _lastState = savedState;
+    
+    return shouldBegin;
+}
+
 @end