@react-native-oh-tpl/react-native-gesture-handler 2.12.9 → 2.14.1-2.14.12

package/harmony/gesture_handler/src/main/ets/gesture-handlers/FlingGestureHandler.ts

@@ -0,0 +1,211 @@
+import {
+  GestureHandler,
+  State,
+  DiagonalDirections,
+  Directions,
+  Vector2D,
+  IncomingEvent,
+  GestureHandlerDependencies
+} from '../core';
+
+const DEFAULT_MAX_DURATION_MS = 800;
+const DEFAULT_MIN_VELOCITY = 700;
+/**
+ * DEFAULT_ALIGNMENT_CONE defines the angular tolerance for fling gestures in degrees.
+ *               *
+ *           *
+ *       *
+ *   *------------>
+ *       *
+ *           *
+ *               *
+ */
+const DEFAULT_ALIGNMENT_CONE = 30;
+const DEFAULT_DIRECTION: Directions = Directions.RIGHT;
+const DEFAULT_NUMBER_OF_TOUCHES_REQUIRED = 1;
+const AXIAL_DEVIATION_COSINE = coneToDeviation(DEFAULT_ALIGNMENT_CONE);
+const DIAGONAL_DEVIATION_COSINE = coneToDeviation(90 - DEFAULT_ALIGNMENT_CONE);
+
+export class FlingGestureHandler extends GestureHandler {
+  constructor(deps: GestureHandlerDependencies) {
+    super({ ...deps, logger: deps.logger.cloneWithPrefix("FlingGestureHandler") })
+  }
+
+  getDefaultConfig() {
+    return {}
+  }
+
+  private get direction(): Directions {
+    return this.config.direction ?? DEFAULT_DIRECTION
+  }
+
+  private get numberOfPointersRequired() {
+    return this.config.numberOfPointers ?? DEFAULT_NUMBER_OF_TOUCHES_REQUIRED
+  }
+
+  private get maxDurationMs() {
+    return this.config.maxDurationMs ?? DEFAULT_MAX_DURATION_MS
+  }
+
+  private get minVelocity() {
+    return this.config.minVelocity ?? DEFAULT_MIN_VELOCITY
+  }
+
+  private delayTimeout!: number;
+  private maxNumberOfPointersSimultaneously = 0;
+  private keyPointer = NaN;
+
+  private startFling(): void {
+    this.logger.info("startFling")
+    this.begin();
+
+    this.maxNumberOfPointersSimultaneously = 1;
+
+    this.delayTimeout = setTimeout(() => this.fail(), this.maxDurationMs);
+  }
+
+  private tryEndFling(): boolean {
+    const logger = this.logger.cloneWithPrefix("tryEndFling")
+    const velocityVector = this.tracker.getVelocity(this.keyPointer);
+
+    const getAlignment = (
+      direction: Directions | DiagonalDirections,
+      minimalAlignmentCosine: number
+    ) => {
+      return (
+        (direction & this.direction) === direction &&
+          velocityVector.computeCosine(
+            Vector2D.fromDirection(direction),
+          ) > minimalAlignmentCosine
+      );
+    };
+
+    const axialDirectionsList = Object.values(Directions);
+    const diagonalDirectionsList = Object.values(DiagonalDirections);
+
+    // list of alignments to all activated directions
+    const axialAlignmentList = axialDirectionsList.map((direction) =>
+    getAlignment(direction, AXIAL_DEVIATION_COSINE)
+    );
+
+    const diagonalAlignmentList = diagonalDirectionsList.map((direction) =>
+    getAlignment(direction, DIAGONAL_DEVIATION_COSINE)
+    );
+
+    const isAligned =
+      axialAlignmentList.some(Boolean) || diagonalAlignmentList.some(Boolean);
+
+    const isFast = velocityVector.magnitude > this.minVelocity;
+
+    if (
+      this.maxNumberOfPointersSimultaneously ===
+      this.numberOfPointersRequired &&
+        isAligned &&
+        isFast
+    ) {
+      clearTimeout(this.delayTimeout);
+      this.activate();
+
+      return true;
+    }
+
+    return false;
+  }
+
+  private endFling() {
+    this.logger.info("endFling")
+    if (!this.tryEndFling()) {
+      this.fail();
+    }
+  }
+
+  public onPointerDown(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    this.keyPointer = event.pointerId;
+
+    super.onPointerDown(event);
+    this.newPointerAction();
+  }
+
+  public onAdditionalPointerAdd(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onAdditionalPointerAdd(event);
+    this.newPointerAction();
+  }
+
+  private newPointerAction(): void {
+    if (this.currentState === State.UNDETERMINED) {
+      this.startFling();
+    }
+
+    if (this.currentState !== State.BEGAN) {
+      return;
+    }
+
+    this.tryEndFling();
+
+    if (
+      this.tracker.getTrackedPointersCount() >
+      this.maxNumberOfPointersSimultaneously
+    ) {
+      this.maxNumberOfPointersSimultaneously =
+        this.tracker.getTrackedPointersCount();
+    }
+  }
+
+  private pointerMoveAction(event: IncomingEvent): void {
+    this.logger.cloneWithPrefix("pointerMoveAction").info(JSON.stringify(event))
+    this.tracker.track(event);
+
+    if (this.currentState !== State.BEGAN) {
+      return;
+    }
+
+    this.tryEndFling();
+  }
+
+  public onPointerMove(event: IncomingEvent): void {
+    this.pointerMoveAction(event);
+    super.onPointerMove(event);
+  }
+
+  public onPointerOutOfBounds(event: IncomingEvent): void {
+    this.pointerMoveAction(event);
+    super.onPointerOutOfBounds(event);
+  }
+
+  public onPointerUp(event: IncomingEvent): void {
+    super.onPointerUp(event);
+    this.onUp(event);
+
+    this.keyPointer = NaN;
+  }
+
+  public onAdditionalPointerRemove(event: IncomingEvent): void {
+    super.onAdditionalPointerRemove(event);
+    this.onUp(event);
+  }
+
+  private onUp(event: IncomingEvent): void {
+    const logger = this.logger.cloneWithPrefix("onUp")
+    logger.info("start")
+    if (this.currentState === State.BEGAN) {
+      this.endFling();
+    }
+    logger.info(`removeFromTracker: pointerId=${event.pointerId}`)
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+
+  public activate(): void {
+    super.activate();
+    this.end();
+  }
+}
+
+function coneToDeviation(degrees: number) {
+  return Math.cos(degToRad(degrees / 2));
+}
+
+function degToRad(degrees: number) {
+  return (degrees * Math.PI) / 180;
+}

package/harmony/gesture_handler/src/main/ets/gesture-handlers/GestureHandlerFactory.ts

@@ -0,0 +1,64 @@
+import {
+  RNGHLogger,
+  InteractionManager,
+  RNGHError,
+  PointerTracker,
+  GestureHandler,
+  GestureHandlerDependencies,
+  ScrollLocker,
+  GestureHandlerOrchestrator,
+  RNGestureResponder
+} from "../core"
+import { TapGestureHandler } from './TapGestureHandler';
+import { PanGestureHandler } from "./PanGestureHandler"
+import { PinchGestureHandler } from "./PinchGestureHandler"
+import { NativeViewGestureHandler } from "./NativeViewGestureHandler"
+import { ManualGestureHandler } from './ManualGestureHandler';
+import { LongPressGestureHandler } from "./LongPressGestureHandler"
+import { FlingGestureHandler } from "./FlingGestureHandler"
+import { RotationGestureHandler } from "./RotationGestureHandler"
+
+export class GestureHandlerFactory {
+  private orchestrator: GestureHandlerOrchestrator
+  private logger: RNGHLogger
+
+  constructor(private cleanLogger: RNGHLogger, private scrollLocker: ScrollLocker, private interactionManager: InteractionManager, private rnGestureResponder: RNGestureResponder) {
+    this.logger = cleanLogger.cloneWithPrefix("Factory")
+    this.orchestrator = new GestureHandlerOrchestrator(cleanLogger.cloneWithPrefix("Orchestrator"))
+  }
+
+  create(handlerName: string, handlerTag: number): GestureHandler {
+    this.logger.info(`create ${handlerName} with handlerTag: ${handlerTag}`)
+    const deps: GestureHandlerDependencies = {
+      tracker: new PointerTracker(),
+      orchestrator: this.orchestrator,
+      handlerTag,
+      interactionManager: this.interactionManager,
+      logger: this.cleanLogger.cloneWithPrefix("GestureHandler"),
+      scrollLocker: this.scrollLocker,
+      rnGestureResponder: this.rnGestureResponder,
+    }
+    switch (handlerName) {
+      case "TapGestureHandler":
+        return new TapGestureHandler(deps)
+      case "PanGestureHandler":
+        return new PanGestureHandler(deps)
+      case "PinchGestureHandler":
+        return new PinchGestureHandler(deps)
+      case "NativeViewGestureHandler":
+        return new NativeViewGestureHandler(deps)
+      case "ManualGestureHandler":
+        return new ManualGestureHandler(deps)
+      case "LongPressGestureHandler":
+        return new LongPressGestureHandler(deps)
+      case "FlingGestureHandler":
+        return new FlingGestureHandler(deps)
+      case "RotationGestureHandler":
+        return new RotationGestureHandler(deps)
+      default:
+        const msg = `Unknown handler type: ${handlerName}`
+        this.logger.info(msg)
+        throw new RNGHError(msg)
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/gesture-handlers/LongPressGestureHandler.ts

@@ -0,0 +1,127 @@
+import { GestureHandler, IncomingEvent, GestureConfig, State, GestureHandlerDependencies } from '../core';
+
+const DEFAULT_MIN_DURATION_MS = 500;
+const DEFAULT_MAX_DIST_DP = 10;
+const SCALING_FACTOR = 10;
+
+export class LongPressGestureHandler extends GestureHandler {
+  private minDurationMs = DEFAULT_MIN_DURATION_MS;
+  private defaultMaxDistSq = DEFAULT_MAX_DIST_DP * SCALING_FACTOR;
+
+  private maxDistSq = this.defaultMaxDistSq;
+  private startX = 0;
+  private startY = 0;
+
+  private startTime = 0;
+  private previousTime = 0;
+
+  private activationTimeout: number | undefined;
+
+  constructor(deps: GestureHandlerDependencies) {
+    super({...deps, logger: deps.logger.cloneWithPrefix("LongPressGestureHandler")})
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  protected transformNativeEvent() {
+    return {
+      ...super.transformNativeEvent(),
+      duration: Date.now() - this.startTime,
+    };
+  }
+
+  public updateGestureConfig({ enabled = true, ...props }: GestureConfig): void {
+    super.updateGestureConfig({ enabled: enabled, ...props });
+
+    if (this.config.minDurationMs !== undefined) {
+      this.minDurationMs = this.config.minDurationMs;
+    }
+
+    if (this.config.maxDist !== undefined) {
+      this.maxDistSq = this.config.maxDist * this.config.maxDist;
+    }
+  }
+
+
+
+  protected resetConfig(): void {
+    super.resetConfig();
+    this.minDurationMs = DEFAULT_MIN_DURATION_MS;
+    this.maxDistSq = this.defaultMaxDistSq;
+  }
+
+  protected onStateChange(newState: State, oldState: State): void {
+    super.onStateChange(newState, oldState)
+    clearTimeout(this.activationTimeout);
+  }
+
+  public onPointerDown(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.tryBegin(event);
+    this.tryActivate();
+    this.checkDistanceFail(event);
+  }
+
+  public onPointerMove(event: IncomingEvent): void {
+    super.onPointerMove(event);
+    this.tracker.track(event);
+    this.checkDistanceFail(event);
+  }
+
+  public onPointerUp(event: IncomingEvent): void {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.currentState === State.ACTIVE) {
+      this.end();
+    } else {
+      this.fail();
+    }
+  }
+
+  private tryBegin(event: IncomingEvent): void {
+    if (this.currentState !== State.UNDETERMINED) {
+      return;
+    }
+
+    this.previousTime = Date.now();
+    this.startTime = this.previousTime;
+
+    this.begin();
+
+    this.startX = event.x;
+    this.startY = event.y;
+  }
+
+  private tryActivate(): void {
+    if (this.minDurationMs > 0) {
+      if (this.activationTimeout) {
+        clearTimeout(this.activationTimeout)
+      }
+      this.activationTimeout = setTimeout(() => {
+        this.activate();
+      }, this.minDurationMs);
+    } else if (this.minDurationMs === 0) {
+      this.activate();
+    }
+  }
+
+  private checkDistanceFail(event: IncomingEvent): void {
+    const dx = event.x - this.startX;
+    const dy = event.y - this.startY;
+    const distSq = dx * dx + dy * dy;
+
+    if (distSq <= this.maxDistSq) {
+      return;
+    }
+
+    if (this.currentState === State.ACTIVE) {
+      this.cancel();
+    } else {
+      this.fail();
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/gesture-handlers/ManualGestureHandler.ts

@@ -0,0 +1,42 @@
+import { GestureHandler, GestureHandlerDependencies, IncomingEvent } from '../core';
+
+export class ManualGestureHandler extends GestureHandler {
+  constructor(deps: GestureHandlerDependencies) {
+    super({...deps, logger: deps.logger.cloneWithPrefix("ManualGestureHandler")})
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  public onPointerDown(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.begin();
+  }
+
+  public onAdditionalPointerAdd(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onAdditionalPointerAdd(event);
+  }
+
+  public onPointerMove(event: IncomingEvent): void {
+    this.tracker.track(event);
+    super.onPointerMove(event);
+  }
+
+  public onPointerOutOfBounds(event: IncomingEvent): void {
+    this.tracker.track(event);
+    super.onPointerOutOfBounds(event);
+  }
+
+  public onPointerUp(event: IncomingEvent): void {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+
+  public onAdditionalPointerRemove(event: IncomingEvent): void {
+    super.onAdditionalPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+}

package/harmony/gesture_handler/src/main/ets/{NativeViewGestureHandler.ts → gesture-handlers/NativeViewGestureHandler.ts}

@@ -1,7 +1,5 @@
-import { GestureHandler, GestureHandlerDependencies, DEFAULT_TOUCH_SLOP } from "./GestureHandler"
-import { Vector2D } from './Vector2D';
-import { State } from "./State"
-import { AdaptedEvent } from './Event';
+import { GestureHandler, GestureHandlerDependencies, DEFAULT_TOUCH_SLOP, Vector2D, State, IncomingEvent } from "../core"
+
 
 export class NativeViewGestureHandler extends GestureHandler {
   private minDistSq = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
@@ -20,7 +18,7 @@ export class NativeViewGestureHandler extends GestureHandler {
     return {}
   }
 
-  public onPointerDown(e: AdaptedEvent) {
+  public onPointerDown(e: IncomingEvent) {
     this.tracker.addToTracker(e);
     super.onPointerDown(e);
     this.onNewPointer();
@@ -31,24 +29,26 @@ export class NativeViewGestureHandler extends GestureHandler {
     if (this.currentState !== State.UNDETERMINED)
       return;
     this.begin();
-    this.activate();
+    if(this.view.hasButtonRole()) {
+      this.activate();
+    }
   }
 
-  public onAdditionalPointerAdd(e: AdaptedEvent) {
+  public onAdditionalPointerAdd(e: IncomingEvent) {
     this.tracker.addToTracker(e);
     super.onPointerDown(e);
     this.onNewPointer();
   }
 
-  public onPointerMove(e: AdaptedEvent): void {
+  public onPointerMove(e: IncomingEvent): void {
     this.tracker.track(e);
     const {x: dx, y: dy} = this.startPos.clone().subtract(this.tracker.getLastAvgPos()).value
     const distSq = dx * dx + dy * dy;
 
     if (distSq >= this.minDistSq) {
-      if (this.currentState === State.ACTIVE) {
+      if (this.view.hasButtonRole() && this.currentState === State.ACTIVE) {
         this.cancel();
-      } else if (this.currentState === State.BEGAN) {
+      } else if (!this.view.hasButtonRole() && this.currentState === State.BEGAN) {
         this.activate();
       }
     }
@@ -61,12 +61,12 @@ export class NativeViewGestureHandler extends GestureHandler {
     }
   }
 
-  public onPointerUp(event: AdaptedEvent): void {
+  public onPointerUp(event: IncomingEvent): void {
     super.onPointerUp(event);
     this.onAnyPointerUp(event);
   }
 
-  private onAnyPointerUp(e: AdaptedEvent) {
+  private onAnyPointerUp(e: IncomingEvent) {
     this.tracker.removeFromTracker(e.pointerId);
     if (this.tracker.getTrackedPointersCount() === 0) {
       if (this.currentState === State.ACTIVE) {
@@ -77,7 +77,7 @@ export class NativeViewGestureHandler extends GestureHandler {
     }
   }
 
-  public onAdditionalPointerRemove(e: AdaptedEvent) {
+  public onAdditionalPointerRemove(e: IncomingEvent) {
     super.onAdditionalPointerRemove(e)
     this.onAnyPointerUp(e)
   }
@@ -97,14 +97,14 @@ export class NativeViewGestureHandler extends GestureHandler {
     if (
       this.currentState === State.ACTIVE &&
         handler.getState() === State.ACTIVE &&
-        this.canBeInterrupted()
+      this.canBeInterrupted()
     ) {
       return false;
     }
 
     return (
       this.currentState === State.ACTIVE &&
-        this.canBeInterrupted() &&
+      this.canBeInterrupted() &&
         handler.getTag() > 0
     );
   }

package/harmony/gesture_handler/src/main/ets/{PanGestureHandler.ts → gesture-handlers/PanGestureHandler.ts}

@@ -1,7 +1,14 @@
-import { GestureHandler, GestureConfig, GestureHandlerDependencies, DEFAULT_TOUCH_SLOP } from "./GestureHandler"
-import { AdaptedEvent } from "./Event"
-import { State } from "./State"
-import { Vector2D } from "./Vector2D"
+import {
+  GestureHandler,
+  GestureConfig,
+  GestureHandlerDependencies,
+  DEFAULT_TOUCH_SLOP,
+  IncomingEvent,
+  State,
+  Vector2D,
+  getStateName
+} from "../core"
+
 
 const DEFAULT_MIN_DIST_SQ = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
 
@@ -82,6 +89,7 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
   }
 
   private unlockScrolls: (() => void) | undefined
+  private unlockRNGestureResponder: (() => void) | undefined
 
   public constructor(deps: GestureHandlerDependencies) {
     super({ ...deps, logger: deps.logger.cloneWithPrefix("PanGestureHandler") })
@@ -174,9 +182,10 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
     clearTimeout(this.activationTimeout);
   }
 
-  private tryBegin(e: AdaptedEvent): void {
+  private tryBegin(e: IncomingEvent): void {
+    this.logger.cloneWithPrefix("tryBegin").debug({currentState: getStateName(this.currentState), trackedPointersCount: this.tracker.getTrackedPointersCount(), minPointers: this.minPointers})
     if (
-      this.currentState === State.UNDETERMINED &&
+      (this.currentState === State.UNDETERMINED) &&
         this.tracker.getTrackedPointersCount() >= this.minPointers
     ) {
       this.resetProgress();
@@ -233,7 +242,7 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
     return false
   }
 
-  public onAdditionalPointerAdd(event: AdaptedEvent): void {
+  public onAdditionalPointerAdd(event: IncomingEvent): void {
     this.tracker.addToTracker(event);
     super.onAdditionalPointerAdd(event);
     this.tryBegin(event);
@@ -251,7 +260,7 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
     }
   }
 
-  public onPointerUp(event: AdaptedEvent): void {
+  public onPointerUp(event: IncomingEvent): void {
     super.onPointerUp(event);
     if (this.currentState === State.ACTIVE) {
       this.lastPos = this.tracker.getLastAvgPos();
@@ -265,7 +274,7 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
     }
   }
 
-  public onAdditionalPointerRemove(event: AdaptedEvent): void {
+  public onAdditionalPointerRemove(event: IncomingEvent): void {
     super.onAdditionalPointerRemove(event);
     this.tracker.removeFromTracker(event.pointerId);
     this.offset.add(this.lastPos).subtract(this.startPos)
@@ -281,7 +290,7 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
     }
   }
 
-  public onPointerMove(event: AdaptedEvent): void {
+  public onPointerMove(event: IncomingEvent): void {
     this.tracker.track(event);
     this.lastPos = this.tracker.getLastAvgPos()
     this.velocity = this.tracker.getVelocity(event.pointerId)
@@ -289,7 +298,7 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
     super.onPointerMove(event);
   }
 
-  public onPointerOutOfBounds(event: AdaptedEvent): void {
+  public onPointerOutOfBounds(event: IncomingEvent): void {
     if (this.shouldCancelWhenOutside) {
       return;
     }
@@ -317,12 +326,17 @@ export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
     };
   }
 
-  protected stateDidChange(newState: State, oldState: State) {
-    super.stateDidChange(newState, oldState)
+  protected onStateChange(newState: State, oldState: State) {
+    super.onStateChange(newState, oldState)
     if (newState === State.BEGAN) {
       this.unlockScrolls = this.scrollLocker.lockScrollContainingViewTag(this.view.getTag())
     } else if (newState !== State.ACTIVE) {
       this.unlockScrolls?.()
     }
+    if (newState === State.ACTIVE) {
+      this.unlockRNGestureResponder = this.rnGestureResponder.lock(this.view.getTag())
+    } else {
+      this.unlockRNGestureResponder?.()
+    }
   }
 }