What are the main features of software-mansion/react-native-gesture-handler?

The main features of software-mansion/react-native-gesture-handler are: Native Gesture Recognition Libraries, Multi-Touch Gesture Systems, Declarative Gesture Handlings, Native Gesture Delegation, Native Touch Component Bridging, UI Thread Gesture Animations, Gesture, Gesture State Machines.

React Native Gesture Handler

React Native Gesture Handler is a declarative library that exposes the platform's native touch and gesture system to React Native, enabling smooth, deterministic gesture handling on the UI thread. It manages gesture recognition through a native state machine with defined transitions between states like BEGAN, ACTIVE, END, and CANCELLED, routing touch events through platform-native gesture recognizers on both iOS and Android.

The library provides a comprehensive gesture composition framework that allows developers to combine multiple gestures into race, simultaneous, or exclusive sequences, controlling activation order and preventing conflicts across components. It supports a wide range of gesture types including pan, pinch, rotation, tap, long press, fling, hover, and force touch, all detected natively. Gesture callbacks can execute as worklets on the UI thread for synchronous processing, and the library includes tools for gesture testing and simulation.

Beyond gesture recognition, the library offers a collection of native touchable components with platform-specific visual feedback like Android ripples and iOS highlights, as well as swipeable rows and drawers built with Reanimated for performant animations. Gesture detectors can be attached to any component via hooks or wrappers without modifying the native view hierarchy, including support for SVG elements and text spans.

Features

Native Gesture Recognition Libraries - Exposes the platform's native touch and gesture system to React Native for smooth, deterministic gesture handling on the UI thread.
Multi-Touch Gesture Systems - Unified gesture recognition system handling touch, pen, and mouse input across iOS and Android.
Declarative Gesture Handlings - Defines gestures using a declarative API that maps touch events to gesture states on the native platform.
Native Gesture Delegation - Routes touch events through platform-native gesture recognizers that communicate state transitions back to JavaScript.
Native Touch Component Bridging - Bridges native touch-handling components with the gesture system for relation formation.
UI Thread Gesture Animations - Integrates with animation libraries to drive gesture-driven animations entirely on the UI thread for smooth performance.
Gesture - Executes gesture callbacks synchronously on the native UI thread via Reanimated worklets.
Gesture State Machines - Manages gesture recognition through a defined state machine with transitions between UNDETERMINED, BEGAN, ACTIVE, END, FAILED, and CANCELLED states.
Gesture State Change Callbacks - Provides specific callbacks that fire on gesture state transitions like begin, end, and cancel.
Gesture State Transition Callbacks - Exposes named callbacks for each gesture state transition including onBegin, onActivate, onUpdate, and onFinalize.
Interactive Gesture-Driven Animations - Provides interactive gesture-driven animations that react in real-time to touch input via the Animated API.
Animated Gesture Event Mappings - Ships a core mechanism for passing gesture event data to the Animated API to drive touch-synced animations.
Native UI Thread Gesture Processing - Processes touch events on the native UI thread to maintain high frame rates and avoid JS bottlenecks.
Gesture State Shared Values - Uses animated shared values to store and update gesture-driven data like position during drag interactions.
Cross-Component Gesture Coordination - Coordinates gestures across different views with simultaneous activation, failure-dependent blocking, and exclusive prioritization.
UI Thread Gesture Callbacks - Runs gesture callbacks as worklets on the main thread for synchronous, native-driven processing.
Gesture Failure Dependencies - Implements failure dependencies where a gesture waits for others to fail before activating.
Long Press Gestures - Provides native long press gesture detection with configurable duration and movement thresholds.
Declarative Gesture Composition - Provides a declarative API for composing gestures into race, simultaneous, or exclusive sequences resolved natively.
Gesture Relation Composition - Defines relations between gestures to prevent conflicts during simultaneous recognition.
Gesture Recognition Hooks - Recognizes dragging motion with minimum distance activation, tracking translation and velocity continuously.
Gesture Relation Hooks - Provides hooks to set up race, simultaneous, or exclusive gesture relationships.
External Gesture Blocking - Blocks external gestures like scroll from activating while a custom gesture is active.
Native Component Gesture Integration - Integrates native touch-handling components with gesture recognizers to control interaction flow.
Cross-Component Simultaneous Recognitions - Allows gestures attached to different components to activate simultaneously for coordinated multi-view interactions.
Native Animation Drivers - Animates opacity, underlay, or scale on press using platform-native implementations for smooth feedback.
Touch Event Interception - Overrides root view touch handling on Android and delegates to UIGestureRecognizers on iOS for deterministic gesture recognition.
Touch Gesture Detection - Detects multiple gestures simultaneously by composing base gestures into race, simultaneous, or exclusive sequences.
Hover Gesture Detections - Provides native hover gesture detection for pointer devices on iOS and web.
Pan Gesture Detections - Tracks finger movement across the screen and reports translation, velocity, and state changes during drags.
Pinch Gesture Detections - Recognizes two-finger pinch gestures and reports scale factor, velocity, and focal point for zooming.
Rotation Gesture Detections - Tracks the angle between two touch points and reports rotation deltas as the user twists their fingers.
Tap Gesture Detections - Recognizes one or more fingers briefly touching the screen without significant movement.
Touch Gesture Detectors - Accepts any base or composed gesture to define touch interactions on components.
Gesture Exclusion - Implements gesture exclusion through priority ordering to prevent simultaneous activation conflicts.
Delayed Gesture Activations - Delays gesture activation until specified external gestures fail or never begin, preventing premature triggering.
Exclusive Gesture Chains - Provides ordered gesture priority chains that block lower-priority gestures until higher ones fail.
Gesture Composition and Coordination - Defines relationships between multiple gestures such as race, simultaneous, and exclusive chains to control activation order.
Gesture Failure Waits - Blocks gesture activation until all specified gestures have failed to begin.
Gesture Racing - Activates the first gesture that meets criteria and cancels all others in a race.
Multiple Gesture Composition - Combines multiple gestures on the same component with simultaneous or exclusive behavior.
Native Gesture Composition - Composes native gestures as building blocks in gesture chains and cross-component interactions.
Race Gesture Composition - Activates only the first successful gesture in a set and cancels all others.
Simultaneous Gesture Execution - Allows multiple gestures to activate and process concurrently without cancellation.
Simultaneous Gesture Grouping - Groups gestures so all activate at once without canceling each other on the same component.
Gesture Event Data Bridges - Serializes native touch event properties like translation, velocity, and scale into JavaScript-accessible objects.
Pinch Gesture Trackings - Continuously tracks two-finger distance and reports scale factor, velocity, and focal point for zooming.
Simultaneous Gesture Composition - Activates all gestures in a set simultaneously without cancellation for multi-touch interactions.
Android Gesture Processings - Intercepts all touch events on Android via a root view orchestrator that activates or cancels gesture handlers.
Tap and Press Gesture Detections - Recognizes tap, press, and hover interactions on wrapped children with callbacks for each stage.
Native Touchable Components - Provides a unified, highly configurable touchable component with native-driven press animations.
Competing Gesture Compositions - Bundles multiple gestures so only the first to activate succeeds, canceling all others attached to the same component.
Automatic Gesture Activation Overrides - Prevents automatic activation of continuous gestures for manual lifecycle control.
Gesture Lifecycle Callbacks - Ships lifecycle callbacks that hook into every state transition of a gesture handler.
Ripple Effect Buttons - Provides native Android ripple animations on press with extensive customization options.
Event Stream Simulators - Simulates complete gesture event sequences triggering handler callbacks with filled event data.
Virtual Gesture Detectors - Adds gesture recognition via virtual detectors that do not alter the native view hierarchy.
Gesture-Driven Integration Tests - Provides tools for simulating gesture event streams and finding gesture handlers by test ID for programmatic testing.
Borderless Press Buttons - Ships borderless pressable buttons with native platform-specific visual feedback.
Swipe-Activated Drawers - Creates cross-platform swipe-activated drawer layouts with smooth Reanimated animations.
Drawer State Controllers - Opens or closes drawer panels programmatically via component refs with optional animation customization.
Multi-Touch Pan Handlers - Manages pan translation with multiple fingers and platform-specific pointer tracking behavior.
Custom Press Animation Integrations - Enables fully custom press animations through Reanimated and Animated API integration.
Scroll-Gesture Conflict Resolutions - Resolves scroll conflicts by applying CSS touch-action so vertical scrolling works during horizontal swipes.
Scroll-Gesture Synchronizations - Disables native scrollable components for the duration of a gesture to prevent scroll interference.
Native Scroll Blockings During Gestures - Blocks native scroll views from responding to touches while a custom gesture is active.
Hook-Based Gesture APIs - Provides hook-based gesture APIs with per-type configuration objects.
Hover Detections Over Views - Recognizes when a mouse or stylus hovers above a view to enable hover-based interactions.
Multi-Device Input Handlers - Supports gesture recognition from touch screens, pens, and mice through a unified system.
Multi-Touch Pointer Trackings - Tracks all active touch points on screen with real-time position and visibility state updates.
Pressure-Sensitive Interactions - Tracks touch force on iOS devices with configurable pressure thresholds for activation.
Rectangular Press Buttons - Provides rectangular pressable buttons with native platform-specific visual feedback.
Swipeable Layouts - Places children in a pannable container revealing configurable action panels when swiped left or right.
Scroll-Compatible Swipeable Components - Restricts touch handling to vertical pan gestures to avoid blocking scroll in parent ScrollViews.
Swipeable Action Panels - Builds swipeable rows revealing action buttons behind them with performant Reanimated gestures.
Fling Gesture Detections - Recognizes fast directional swipes that activate only after sufficient movement in the specified direction.
Gesture Interruption Detections - Provides a property on end-event objects to distinguish canceled gestures from completed ones.
Pan Detection Configurations - Configures pan gesture activation with minimum distance, direction, and finger count limits.
Two-Finger Rotation Detections - Ships native two-finger rotation gesture detection with angle and velocity reporting.
SharedValue Gesture Reactivity - Enables gesture configuration to react to SharedValue changes without re-rendering components.
Raw Touch Data Readings - Provides batched callbacks for raw pointer down, move, up, and cancel events with per-touch details.
Touch Event Phase Trackings - Fires callbacks for each finger down, move, up, and cancellation event during gesture handling.
Custom Gesture Builders - Provides raw touch event data and state transitions for implementing arbitrary custom gesture recognition logic.

GcsSloop/AndroidNote

9,332Auf GitHub ansehen

AndroidNote is a technical knowledge base and reference resource for Android development. It provides comprehensive guidance on application architecture, custom view development, and advanced graphics programming. The project is distinguished by its depth in visual implementation, covering pseudo-3D perspective projections via virtual cameras and complex 2D rendering using Bézier curves and PorterDuff color blending. It also provides detailed methodologies for app modularization and the management of internal libraries through private Maven repositories and JitPack. The reference surface ext

animatedjs/animated

1,845Auf GitHub ansehen

Animated is a declarative framework designed for creating high-performance, cross-platform interface movements. It provides a system for defining complex UI transitions through property interpolation, value mapping, and physics-based motion, allowing developers to orchestrate fluid visual effects without manual frame updates. The library distinguishes itself by offloading animation instructions to the native UI thread, ensuring consistent performance across mobile and web environments. It supports sophisticated motion design by linking multiple animation variables together, enabling coordinat

wcandillon/can-it-be-done-in-react-native

4,203Auf GitHub ansehen

This repository is a collection of reference implementations and sample projects that demonstrate high-fidelity animations and gesture-driven interface patterns for cross-platform mobile frameworks. It provides a library of demonstration code and interactive components to showcase advanced user interface patterns. The project focuses on mapping complex touch inputs to fluid visual animations and coordinated layout changes. These examples serve as prototypes for developing and testing complex interaction patterns to determine the feasibility of specific design behaviors in React Native. The i

motiondivision/motion-vue

2,185Auf GitHub ansehen

Motion-vue is a declarative animation library for Vue that provides a framework for building fluid, high-performance user interface motion. It enables developers to define complex animation states and transitions using code-based variants and spring-driven physics, ensuring that visual updates remain synchronized with component lifecycles and application state. The library distinguishes itself through a layout projection engine that tracks element coordinates to animate transitions between layout states, and a gesture-driven input pipeline that maps pointer and scroll interactions to animatio

software-mansionreact-native-gesture-handler

React Native Gesture Handler

Features