@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

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

@@ -0,0 +1,100 @@
+package com.swmansion.gesturehandler.react
+
+import android.util.SparseArray
+import android.view.View
+import com.facebook.react.bridge.UiThreadUtil
+import com.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.core.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, actionType: Int): Boolean {
+    val handler = handlers[handlerTag]
+    return handler?.let {
+      detachHandler(handler)
+      handler.actionType = actionType
+      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 {
+      synchronized(listToAdd) {
+        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) {
+        synchronized(attachedHandlers) {
+          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,142 @@
+package com.swmansion.gesturehandler.react
+
+import android.os.SystemClock
+import android.util.Log
+import android.view.MotionEvent
+import android.view.View
+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.swmansion.gesturehandler.core.GestureHandler
+import com.swmansion.gesturehandler.core.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, GestureHandler.ACTION_TYPE_JS_FUNCTION_OLD_API)
+    }
+    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, sourceEvent: MotionEvent) {
+      val currentState = state
+      // we shouldn't stop intercepting events when there is an active handler already, which could happen when
+      // adding a new pointer to the screen after a handler activates
+      if (currentState == STATE_UNDETERMINED && (!shouldIntercept || orchestrator?.isAnyHandlerActive() != true)) {
+        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)
+      }
+      event.recycle()
+    }
+  }
+
+  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() }
+    }
+  }
+
+  fun activateNativeHandlers(view: View) {
+    orchestrator?.activateNativeHandlersForView(view)
+  }
+
+  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,78 @@
+package com.swmansion.gesturehandler.react
+
+import android.content.Context
+import android.util.Log
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+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.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 dispatchGenericMotionEvent(event: MotionEvent) =
+    if (_enabled && rootHelper!!.dispatchTouchEvent(event)) {
+      true
+    } else super.dispatchGenericMotionEvent(event)
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    if (_enabled) {
+      rootHelper!!.requestDisallowInterceptTouchEvent(disallowIntercept)
+    }
+    super.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  fun activateNativeHandlers(view: View) {
+    rootHelper?.activateNativeHandlers(view)
+  }
+
+  companion object {
+    private fun hasGestureHandlerEnabledRootView(viewGroup: ViewGroup): Boolean {
+      UiThreadUtil.assertOnUiThread()
+
+      var parent = viewGroup.parent
+      while (parent != null) {
+        // our own deprecated root view
+        @Suppress("DEPRECATION")
+        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,51 @@
+package com.swmansion.gesturehandler.react
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.RNGestureHandlerRootViewManagerDelegate
+import com.facebook.react.viewmanagers.RNGestureHandlerRootViewManagerInterface
+
+/**
+ * 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>(),
+  RNGestureHandlerRootViewManagerInterface<RNGestureHandlerRootView> {
+  private val mDelegate: ViewManagerDelegate<RNGestureHandlerRootView>
+
+  init {
+    mDelegate = RNGestureHandlerRootViewManagerDelegate<RNGestureHandlerRootView, RNGestureHandlerRootViewManager>(this)
+  }
+
+  override fun getDelegate(): ViewManagerDelegate<RNGestureHandlerRootView> {
+    return mDelegate
+  }
+
+  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 = "RNGestureHandlerRootView"
+  }
+}

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

@@ -0,0 +1,78 @@
+// 1. RCTEventEmitter was deprecated in favor of RCTModernEventEmitter interface
+// 2. Event#init() with only viewTag was deprecated in favor of two arg c-tor
+// 3. Event#receiveEvent() with 3 args was deprecated in favor of 4 args version
+// ref: https://github.com/facebook/react-native/commit/2fbbdbb2ce897e8da3f471b08b93f167d566db1d
+@file:Suppress("DEPRECATION")
+
+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.core.GestureHandler
+import com.swmansion.gesturehandler.react.eventbuilders.GestureHandlerEventDataBuilder
+
+class RNGestureHandlerStateChangeEvent private constructor() : Event<RNGestureHandlerStateChangeEvent>() {
+  private var dataBuilder: GestureHandlerEventDataBuilder<*>? = null
+  private var newState: Int = GestureHandler.STATE_UNDETERMINED
+  private var oldState: Int = GestureHandler.STATE_UNDETERMINED
+
+  private fun <T : GestureHandler<T>> init(
+    handler: T,
+    newState: Int,
+    oldState: Int,
+    dataBuilder: GestureHandlerEventDataBuilder<T>,
+  ) {
+    super.init(handler.view!!.id)
+    this.dataBuilder = dataBuilder
+    this.newState = newState
+    this.oldState = oldState
+  }
+
+  override fun onDispose() {
+    dataBuilder = null
+    newState = GestureHandler.STATE_UNDETERMINED
+    oldState = GestureHandler.STATE_UNDETERMINED
+    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, createEventData(dataBuilder!!, newState, oldState))
+  }
+
+  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,
+      dataBuilder: GestureHandlerEventDataBuilder<T>,
+    ): RNGestureHandlerStateChangeEvent =
+      (EVENTS_POOL.acquire() ?: RNGestureHandlerStateChangeEvent()).apply {
+        init(handler, newState, oldState, dataBuilder)
+      }
+
+    fun createEventData(
+      dataBuilder: GestureHandlerEventDataBuilder<*>,
+      newState: Int,
+      oldState: Int,
+    ): WritableMap = Arguments.createMap().apply {
+      dataBuilder.buildEventData(this)
+      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.core.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.core.PointerEventsConfig
+import com.swmansion.gesturehandler.core.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/android/src/main/java/com/swmansion/gesturehandler/react/eventbuilders/FlingGestureHandlerEventDataBuilder.kt

@@ -0,0 +1,30 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.FlingGestureHandler
+
+class FlingGestureHandlerEventDataBuilder(handler: FlingGestureHandler) : GestureHandlerEventDataBuilder<FlingGestureHandler>(handler) {
+  private val x: Float
+  private val y: Float
+  private val absoluteX: Float
+  private val absoluteY: Float
+
+  init {
+    x = handler.lastRelativePositionX
+    y = handler.lastRelativePositionY
+    absoluteX = handler.lastPositionInWindowX
+    absoluteY = handler.lastPositionInWindowY
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("x", PixelUtil.toDIPFromPixel(x).toDouble())
+      putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
+      putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
+      putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.swmansion.gesturehandler.core.GestureHandler
+
+abstract class GestureHandlerEventDataBuilder<T : GestureHandler<T>>(handler: T) {
+  private val numberOfPointers: Int
+  private val handlerTag: Int
+  private val state: Int
+
+  init {
+    numberOfPointers = handler.numberOfPointers
+    handlerTag = handler.tag
+    state = handler.state
+  }
+
+  open fun buildEventData(eventData: WritableMap) {
+    eventData.putInt("numberOfPointers", numberOfPointers)
+    eventData.putInt("handlerTag", handlerTag)
+    eventData.putInt("state", state)
+  }
+}

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

@@ -0,0 +1,30 @@
+package com.swmansion.gesturehandler.react.eventbuilders
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.PixelUtil
+import com.swmansion.gesturehandler.core.HoverGestureHandler
+
+class HoverGestureHandlerEventDataBuilder(handler: HoverGestureHandler) : GestureHandlerEventDataBuilder<HoverGestureHandler>(handler) {
+  private val x: Float
+  private val y: Float
+  private val absoluteX: Float
+  private val absoluteY: Float
+
+  init {
+    x = handler.lastRelativePositionX
+    y = handler.lastRelativePositionY
+    absoluteX = handler.lastPositionInWindowX
+    absoluteY = handler.lastPositionInWindowY
+  }
+
+  override fun buildEventData(eventData: WritableMap) {
+    super.buildEventData(eventData)
+
+    with(eventData) {
+      putDouble("x", PixelUtil.toDIPFromPixel(x).toDouble())
+      putDouble("y", PixelUtil.toDIPFromPixel(y).toDouble())
+      putDouble("absoluteX", PixelUtil.toDIPFromPixel(absoluteX).toDouble())
+      putDouble("absoluteY", PixelUtil.toDIPFromPixel(absoluteY).toDouble())
+    }
+  }
+}