react-native-gesture-handler 2.18.1 → 2.20.0

package/README.md

@@ -37,6 +37,7 @@ You will need to have an Android or iOS device or emulator connected.
 
 | version | react-native version |
 | ------- | -------------------- |
+| 2.18.0+ | 0.73.0+              |
 | 2.16.0+ | 0.68.0+              |
 | 2.14.0+ | 0.67.0+              |
 | 2.10.0+ | 0.64.0+              |

package/android/build.gradle

@@ -1,8 +1,5 @@
 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']
 
@@ -36,16 +33,10 @@ def resolveReactNativeDirectory() {
         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
+    // Fallback to node resolver for custom directory structures like monorepos.
+    def reactNativePackage = file(["node", "--print", "require.resolve('react-native/package.json')"].execute(null, rootDir).text.trim())
+    if (reactNativePackage.exists()) {
+        return reactNativePackage.parentFile
     }
 
     throw new Exception(
@@ -98,15 +89,11 @@ repositories {
 
 android {
     compileSdkVersion safeExtGet("compileSdkVersion", 33)
-    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
-    if (agpVersion.tokenize('.')[0].toInteger() >= 7) {
-        namespace "com.swmansion.gesturehandler"
-    }
 
-    if (agpVersion.tokenize('.')[0].toInteger() >= 8) {
-        buildFeatures {
-            buildConfig = true
-        }
+    namespace "com.swmansion.gesturehandler"
+    buildFeatures {
+        buildConfig = true
+        prefab = true
     }
 
     // Used to override the NDK path/version on internal CI or by allowing
@@ -118,12 +105,6 @@ android {
         ndkVersion rootProject.ext.ndkVersion
     }
 
-    if (REACT_NATIVE_MINOR_VERSION >= 71) {
-        buildFeatures {
-            prefab true
-        }
-    }
-
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 21)
         targetSdkVersion safeExtGet('targetSdkVersion', 33)
@@ -137,8 +118,7 @@ android {
             externalNativeBuild {
                 cmake {
                     cppFlags "-O2", "-frtti", "-fexceptions", "-Wall", "-Werror", "-std=c++20", "-DANDROID"
-                    arguments "-DAPP_BUILD_DIR=${appProject.buildDir}",
-                        "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
+                    arguments "-DREACT_NATIVE_DIR=${REACT_NATIVE_DIR}",
                         "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_STL=c++_shared"
                     abiFilters (*reactNativeArchitectures())
@@ -166,6 +146,8 @@ android {
         // 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"
+        exclude "**/libreactnative.so"
+        exclude "**/libjsi.so"
     }
 
     sourceSets.main {

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

@@ -8,5 +8,5 @@ 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)
+  fabricUIManager.getEventDispatcher().dispatchEvent(event)
 }

package/android/paper/src/main/java/com/swmansion/gesturehandler/ReactContextExtensions.kt

@@ -6,7 +6,7 @@ import com.facebook.react.uimanager.events.Event
 
 fun ReactContext.dispatchEvent(event: Event<*>) {
   try {
-    this.getNativeModule(UIManagerModule::class.java)!!.eventDispatcher.dispatchEvent(event)
+    this.getNativeModule(UIManagerModule::class.java)!!.getEventDispatcher().dispatchEvent(event)
   } catch (e: NullPointerException) {
     throw Exception("Couldn't get an instance of UIManagerModule. Gesture Handler is unable to send an event.", e)
   }

package/android/src/main/AndroidManifest.xml

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

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

@@ -397,19 +397,19 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
-  private fun dispatchTouchDownEvent(event: MotionEvent) {
+  private fun dispatchTouchDownEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_DOWN
     val pointerId = event.getPointerId(event.actionIndex)
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
 
     trackedPointers[pointerId] = PointerData(
       pointerId,
       event.getX(event.actionIndex),
       event.getY(event.actionIndex),
-      event.getX(event.actionIndex) + offsetX - windowOffset[0],
-      event.getY(event.actionIndex) + offsetY - windowOffset[1],
+      sourceEvent.getX(event.actionIndex) + offsetX - windowOffset[0],
+      sourceEvent.getY(event.actionIndex) + offsetY - windowOffset[1],
     )
     trackedPointersCount++
     addChangedPointer(trackedPointers[pointerId]!!)
@@ -418,20 +418,20 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     dispatchTouchEvent()
   }
 
-  private fun dispatchTouchUpEvent(event: MotionEvent) {
+  private fun dispatchTouchUpEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     extractAllPointersData()
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_UP
     val pointerId = event.getPointerId(event.actionIndex)
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
 
     trackedPointers[pointerId] = PointerData(
       pointerId,
       event.getX(event.actionIndex),
       event.getY(event.actionIndex),
-      event.getX(event.actionIndex) + offsetX - windowOffset[0],
-      event.getY(event.actionIndex) + offsetY - windowOffset[1],
+      sourceEvent.getX(event.actionIndex) + offsetX - windowOffset[0],
+      sourceEvent.getY(event.actionIndex) + offsetY - windowOffset[1],
     )
     addChangedPointer(trackedPointers[pointerId]!!)
     trackedPointers[pointerId] = null
@@ -440,11 +440,11 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     dispatchTouchEvent()
   }
 
-  private fun dispatchTouchMoveEvent(event: MotionEvent) {
+  private fun dispatchTouchMoveEvent(event: MotionEvent, sourceEvent: MotionEvent) {
     changedTouchesPayload = null
     touchEventType = RNGestureHandlerTouchEvent.EVENT_TOUCH_MOVE
-    val offsetX = event.rawX - event.x
-    val offsetY = event.rawY - event.y
+    val offsetX = sourceEvent.rawX - sourceEvent.x
+    val offsetY = sourceEvent.rawY - sourceEvent.y
     var pointersAdded = 0
 
     for (i in 0 until event.pointerCount) {
@@ -454,8 +454,8 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
       if (pointer.x != event.getX(i) || pointer.y != event.getY(i)) {
         pointer.x = event.getX(i)
         pointer.y = event.getY(i)
-        pointer.absoluteX = event.getX(i) + offsetX - windowOffset[0]
-        pointer.absoluteY = event.getY(i) + offsetY - windowOffset[1]
+        pointer.absoluteX = sourceEvent.getX(i) + offsetX - windowOffset[0]
+        pointer.absoluteY = sourceEvent.getY(i) + offsetY - windowOffset[1]
 
         addChangedPointer(pointer)
         pointersAdded++
@@ -471,15 +471,15 @@ open class GestureHandler<ConcreteGestureHandlerT : GestureHandler<ConcreteGestu
     }
   }
 
-  fun updatePointerData(event: MotionEvent) {
+  fun updatePointerData(event: MotionEvent, sourceEvent: MotionEvent) {
     if (event.actionMasked == MotionEvent.ACTION_DOWN || event.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
-      dispatchTouchDownEvent(event)
-      dispatchTouchMoveEvent(event)
+      dispatchTouchDownEvent(event, sourceEvent)
+      dispatchTouchMoveEvent(event, sourceEvent)
     } else if (event.actionMasked == MotionEvent.ACTION_UP || event.actionMasked == MotionEvent.ACTION_POINTER_UP) {
-      dispatchTouchMoveEvent(event)
-      dispatchTouchUpEvent(event)
+      dispatchTouchMoveEvent(event, sourceEvent)
+      dispatchTouchUpEvent(event, sourceEvent)
     } else if (event.actionMasked == MotionEvent.ACTION_MOVE) {
-      dispatchTouchMoveEvent(event)
+      dispatchTouchMoveEvent(event, sourceEvent)
     }
   }
 

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

@@ -270,7 +270,7 @@ class GestureHandlerOrchestrator(
     // the first `onTouchesDown` event after the handler processes it and changes state
     // to `BEGAN`.
     if (handler.needsPointerData && handler.state != 0) {
-      handler.updatePointerData(event)
+      handler.updatePointerData(event, sourceEvent)
     }
 
     if (!handler.isAwaiting || action != MotionEvent.ACTION_MOVE) {
@@ -292,7 +292,7 @@ class GestureHandlerOrchestrator(
       }
 
       if (handler.needsPointerData && isFirstEvent) {
-        handler.updatePointerData(event)
+        handler.updatePointerData(event, sourceEvent)
       }
 
       // if event was of type UP or POINTER_UP we request handler to stop tracking now that

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

@@ -45,6 +45,7 @@ object GestureUtils {
       event.getY(lastPointerIdx)
     }
   }
+
   fun coneToDeviation(angle: Double): Double =
     cos(Math.toRadians(angle / 2.0))
 }

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

@@ -5,11 +5,14 @@ import android.os.Looper
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
+import com.swmansion.gesturehandler.react.RNGestureHandlerRootHelper
 import com.swmansion.gesturehandler.react.RNViewConfigurationHelper
 
 class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
   private var handler: Handler? = null
   private var finishRunnable = Runnable { finish() }
+  var stylusData: StylusData = StylusData()
+    private set
 
   private infix fun isAncestorOf(other: GestureHandler<*>): Boolean {
     var current: View? = other.view
@@ -70,6 +73,10 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
       return true
     }
 
+    if (handler is RNGestureHandlerRootHelper.RootViewGestureHandler) {
+      return true
+    }
+
     return super.shouldRecognizeSimultaneously(handler)
   }
 
@@ -98,6 +105,10 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
         finish()
       }
 
+      this.state == STATE_ACTIVE && event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS -> {
+        stylusData = StylusData.fromEvent(event)
+      }
+
       this.state == STATE_UNDETERMINED &&
         (event.action == MotionEvent.ACTION_HOVER_MOVE || event.action == MotionEvent.ACTION_HOVER_ENTER) -> {
         begin()
@@ -106,6 +117,11 @@ class HoverGestureHandler : GestureHandler<HoverGestureHandler>() {
     }
   }
 
+  override fun onReset() {
+    super.onReset()
+    stylusData = StylusData()
+  }
+
   private fun finish() {
     when (this.state) {
       STATE_UNDETERMINED -> cancel()

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

@@ -12,11 +12,13 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     get() = (previousTime - startTime).toInt()
   private val defaultMaxDistSq: Float
   private var maxDistSq: Float
+  private var numberOfPointersRequired: Int
   private var startX = 0f
   private var startY = 0f
   private var startTime: Long = 0
   private var previousTime: Long = 0
   private var handler: Handler? = null
+  private var currentPointers = 0
 
   init {
     setShouldCancelWhenOutside(true)
@@ -24,6 +26,7 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     val defaultMaxDist = DEFAULT_MAX_DIST_DP * context.resources.displayMetrics.density
     defaultMaxDistSq = defaultMaxDist * defaultMaxDist
     maxDistSq = defaultMaxDistSq
+    numberOfPointersRequired = 1
   }
 
   override fun resetConfig() {
@@ -37,6 +40,37 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     return this
   }
 
+  fun setNumberOfPointers(numberOfPointers: Int): LongPressGestureHandler {
+    numberOfPointersRequired = numberOfPointers
+    return this
+  }
+
+  private fun getAverageCoords(ev: MotionEvent, excludePointer: Boolean = false): Pair<Float, Float> {
+    if (!excludePointer) {
+      val x = (0 until ev.pointerCount).map { ev.getX(it) }.average().toFloat()
+      val y = (0 until ev.pointerCount).map { ev.getY(it) }.average().toFloat()
+
+      return Pair(x, y)
+    }
+
+    var sumX = 0f
+    var sumY = 0f
+
+    for (i in 0 until ev.pointerCount) {
+      if (i == ev.actionIndex) {
+        continue
+      }
+
+      sumX += ev.getX(i)
+      sumY += ev.getY(i)
+    }
+
+    val x = sumX / (ev.pointerCount - 1)
+    val y = sumY / (ev.pointerCount - 1)
+
+    return Pair(x, y)
+  }
+
   override fun onHandle(event: MotionEvent, sourceEvent: MotionEvent) {
     if (!shouldActivateWithMouse(sourceEvent)) {
       return
@@ -46,8 +80,28 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       previousTime = SystemClock.uptimeMillis()
       startTime = previousTime
       begin()
-      startX = sourceEvent.rawX
-      startY = sourceEvent.rawY
+
+      val (x, y) = getAverageCoords(sourceEvent)
+      startX = x
+      startY = y
+
+      currentPointers++
+    }
+
+    if (sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN) {
+      currentPointers++
+
+      val (x, y) = getAverageCoords(sourceEvent)
+      startX = x
+      startY = y
+
+      if (currentPointers > numberOfPointersRequired) {
+        fail()
+        currentPointers = 0
+      }
+    }
+
+    if (state == STATE_BEGAN && currentPointers == numberOfPointersRequired && (sourceEvent.actionMasked == MotionEvent.ACTION_DOWN || sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_DOWN)) {
       handler = Handler(Looper.getMainLooper())
       if (minDurationMs > 0) {
         handler!!.postDelayed({ activate() }, minDurationMs)
@@ -56,20 +110,37 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
       }
     }
     if (sourceEvent.actionMasked == MotionEvent.ACTION_UP || sourceEvent.actionMasked == MotionEvent.ACTION_BUTTON_RELEASE) {
+      currentPointers--
+
       handler?.let {
         it.removeCallbacksAndMessages(null)
         handler = null
       }
+
       if (state == STATE_ACTIVE) {
         end()
       } else {
         fail()
       }
+    } else if (sourceEvent.actionMasked == MotionEvent.ACTION_POINTER_UP) {
+      currentPointers--
+
+      if (currentPointers < numberOfPointersRequired && state != STATE_ACTIVE) {
+        fail()
+        currentPointers = 0
+      } else {
+        val (x, y) = getAverageCoords(sourceEvent, true)
+        startX = x
+        startY = y
+      }
     } else {
       // calculate distance from start
-      val deltaX = sourceEvent.rawX - startX
-      val deltaY = sourceEvent.rawY - startY
+      val (x, y) = getAverageCoords(sourceEvent)
+
+      val deltaX = x - startX
+      val deltaY = y - startY
       val distSq = deltaX * deltaX + deltaY * deltaY
+
       if (distSq > maxDistSq) {
         if (state == STATE_ACTIVE) {
           cancel()
@@ -97,6 +168,11 @@ class LongPressGestureHandler(context: Context) : GestureHandler<LongPressGestur
     super.dispatchHandlerUpdate(event)
   }
 
+  override fun onReset() {
+    super.onReset()
+    currentPointers = 0
+  }
+
   companion object {
     private const val DEFAULT_MIN_DURATION_MS: Long = 500
     private const val DEFAULT_MAX_DIST_DP = 10f

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

@@ -45,6 +45,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
   private var activateAfterLongPress = DEFAULT_ACTIVATE_AFTER_LONG_PRESS
   private val activateDelayed = Runnable { activate() }
   private var handler: Handler? = null
+  var stylusData: StylusData = StylusData()
+    private set
 
   /**
    * On Android when there are multiple pointers on the screen pan gestures most often just consider
@@ -212,6 +214,10 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       return
     }
 
+    if (event.getToolType(0) == MotionEvent.TOOL_TYPE_STYLUS) {
+      stylusData = StylusData.fromEvent(event)
+    }
+
     val state = state
     val action = sourceEvent.actionMasked
     if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN) {
@@ -295,6 +301,8 @@ class PanGestureHandler(context: Context?) : GestureHandler<PanGestureHandler>()
       it.recycle()
       velocityTracker = null
     }
+
+    stylusData = StylusData()
   }
 
   override fun resetProgress() {

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

@@ -23,7 +23,8 @@ class PinchGestureHandler : GestureHandler<PinchGestureHandler>() {
     override fun onScale(detector: ScaleGestureDetector): Boolean {
       val prevScaleFactor: Double = scale
       scale *= detector.scaleFactor.toDouble()
-      val delta = detector.timeDelta
+      val delta = detector.timeDeltaSeconds
+
       if (delta > 0) {
         velocity = (scale - prevScaleFactor) / delta
       }

package/android/src/main/java/com/swmansion/gesturehandler/core/ScaleGestureDetector.java

@@ -547,6 +547,16 @@ public class ScaleGestureDetector {
         return mCurrTime - mPrevTime;
     }
 
+    /**
+     * Return the time difference in seconds between the previous
+     * accepted scaling event and the current scaling event.
+     *
+     * @return Time difference since the last scaling event in seconds.
+     */
+    public double getTimeDeltaSeconds() {
+        return (double)this.getTimeDelta() / 1000;
+    }
+
     /**
      * Return the event time of the current event being processed.
      *

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

@@ -0,0 +1,103 @@
+package com.swmansion.gesturehandler.core
+
+import android.view.MotionEvent
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import kotlin.math.PI
+import kotlin.math.abs
+import kotlin.math.atan
+import kotlin.math.cos
+import kotlin.math.round
+import kotlin.math.sin
+import kotlin.math.tan
+
+data class StylusData(
+  val tiltX: Double = 0.0,
+  val tiltY: Double = 0.0,
+  val altitudeAngle: Double = 0.0,
+  val azimuthAngle: Double = 0.0,
+  val pressure: Double = -1.0
+) {
+  fun toReadableMap(): ReadableMap {
+    val stylusDataObject = Arguments.createMap().apply {
+      putDouble("tiltX", tiltX)
+      putDouble("tiltY", tiltY)
+      putDouble("altitudeAngle", altitudeAngle)
+      putDouble("azimuthAngle", azimuthAngle)
+      putDouble("pressure", pressure)
+    }
+
+    val readableStylusData: ReadableMap = stylusDataObject
+
+    return readableStylusData
+  }
+
+  companion object {
+    // Source: https://w3c.github.io/pointerevents/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle
+    private fun spherical2tilt(altitudeAngle: Double, azimuthAngle: Double): Pair<Double, Double> {
+      val eps = 0.000000001
+      val radToDeg = 180 / PI
+
+      var tiltXrad = 0.0
+      var tiltYrad = 0.0
+
+      if (altitudeAngle < eps) {
+        // the pen is in the X-Y plane
+        if (azimuthAngle < eps || abs(azimuthAngle - 2 * PI) < eps) {
+          // pen is on positive X axis
+          tiltXrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI / 2) < eps) {
+          // pen is on positive Y axis
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI) < eps) {
+          // pen is on negative X axis
+          tiltXrad = -PI / 2
+        }
+        if (abs(azimuthAngle - (3 * PI) / 2) < eps) {
+          // pen is on negative Y axis
+          tiltYrad = -PI / 2
+        }
+        if (azimuthAngle > eps && abs(azimuthAngle - PI / 2) < eps) {
+          tiltXrad = PI / 2
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI / 2) > eps && abs(azimuthAngle - PI) < eps) {
+          tiltXrad = -PI / 2
+          tiltYrad = PI / 2
+        }
+        if (abs(azimuthAngle - PI) > eps && abs(azimuthAngle - (3 * PI) / 2) < eps) {
+          tiltXrad = -PI / 2
+          tiltYrad = -PI / 2
+        }
+        if (abs(azimuthAngle - (3 * PI) / 2) > eps && abs(azimuthAngle - 2 * PI) < eps) {
+          tiltXrad = PI / 2
+          tiltYrad = -PI / 2
+        }
+      } else {
+        val tanAlt = tan(altitudeAngle)
+
+        tiltXrad = atan(cos(azimuthAngle) / tanAlt)
+        tiltYrad = atan(sin(azimuthAngle) / tanAlt)
+      }
+
+      val tiltX = round(tiltXrad * radToDeg)
+      val tiltY = round(tiltYrad * radToDeg)
+
+      return Pair(tiltX, tiltY)
+    }
+
+    fun fromEvent(event: MotionEvent): StylusData {
+      // On web and iOS 0 degrees means that stylus is parallel to the surface. On android this value will be PI / 2.
+      val altitudeAngle = (PI / 2) - event.getAxisValue(MotionEvent.AXIS_TILT).toDouble()
+      val pressure = event.getPressure(0).toDouble()
+      val orientation = event.getOrientation(0).toDouble()
+      // To get azimuth angle, we need to use orientation property (https://developer.android.com/develop/ui/compose/touch-input/stylus-input/advanced-stylus-features#orientation).
+      val azimuthAngle = (orientation + PI / 2).mod(2 * PI)
+      val tilts = spherical2tilt(altitudeAngle, azimuthAngle)
+
+      return StylusData(tilts.first, tilts.second, altitudeAngle, azimuthAngle, pressure)
+    }
+  }
+}

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

@@ -13,7 +13,7 @@ class Vector(val x: Double, val y: Double) {
   val magnitude = hypot(x, y)
 
   init {
-    val isMagnitudeSufficient = magnitude > MINIMAL_MAGNITUDE
+    val isMagnitudeSufficient = magnitude > MINIMAL_RECOGNIZABLE_MAGNITUDE
 
     unitX = if (isMagnitudeSufficient) x / magnitude else 0.0
     unitY = if (isMagnitudeSufficient) y / magnitude else 0.0
@@ -39,7 +39,7 @@ class Vector(val x: Double, val y: Double) {
     private val VECTOR_LEFT_DOWN: Vector = Vector(-1.0, 1.0)
 
     private val VECTOR_ZERO: Vector = Vector(0.0, 0.0)
-    private const val MINIMAL_MAGNITUDE = 0.1
+    private const val MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1
 
     fun fromDirection(direction: Int): Vector =
       when (direction) {

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

@@ -286,22 +286,11 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       return false
     }
 
-    private fun updateBackgroundColor(backgroundColor: Int, selectable: Drawable?) {
+    private fun updateBackgroundColor(backgroundColor: Int, borderDrawable: Drawable, selectable: Drawable?) {
       val colorDrawable = PaintDrawable(backgroundColor)
-      val borderDrawable = PaintDrawable(Color.TRANSPARENT)
 
       if (hasBorderRadii) {
         colorDrawable.setCornerRadii(buildBorderRadii())
-        borderDrawable.setCornerRadii(buildBorderRadii())
-      }
-
-      if (borderWidth > 0f) {
-        borderDrawable.paint.apply {
-          style = Paint.Style.STROKE
-          strokeWidth = borderWidth
-          color = borderColor ?: Color.BLACK
-          pathEffect = buildBorderStyle()
-        }
       }
 
       val layerDrawable = LayerDrawable(if (selectable != null) arrayOf(colorDrawable, selectable, borderDrawable) else arrayOf(colorDrawable, borderDrawable))
@@ -324,6 +313,7 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       }
 
       val selectable = createSelectableDrawable()
+      val borderDrawable = createBorderDrawable()
 
       if (hasBorderRadii && selectable is RippleDrawable) {
         val mask = PaintDrawable(Color.WHITE)
@@ -334,13 +324,32 @@ class RNGestureHandlerButtonViewManager : ViewGroupManager<ButtonViewGroup>(), R
       if (useDrawableOnForeground && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
         foreground = selectable
         if (_backgroundColor != Color.TRANSPARENT) {
-          updateBackgroundColor(_backgroundColor, null)
+          updateBackgroundColor(_backgroundColor, borderDrawable, null)
         }
       } else if (_backgroundColor == Color.TRANSPARENT && rippleColor == null) {
-        background = selectable
+        background = LayerDrawable(arrayOf(selectable, borderDrawable))
       } else {
-        updateBackgroundColor(_backgroundColor, selectable)
+        updateBackgroundColor(_backgroundColor, borderDrawable, selectable)
+      }
+    }
+
+    private fun createBorderDrawable(): Drawable {
+      val borderDrawable = PaintDrawable(Color.TRANSPARENT)
+
+      if (hasBorderRadii) {
+        borderDrawable.setCornerRadii(buildBorderRadii())
+      }
+
+      if (borderWidth > 0f) {
+        borderDrawable.paint.apply {
+          style = Paint.Style.STROKE
+          strokeWidth = borderWidth
+          color = borderColor ?: Color.BLACK
+          pathEffect = buildBorderStyle()
+        }
       }
+
+      return borderDrawable
     }
 
     private fun createSelectableDrawable(): Drawable? {