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

package/harmony/gesture_handler/src/main/ets/core/InteractionManager.ts

@@ -0,0 +1,144 @@
+import { GestureHandler, Handler, GestureConfig as Config, GHTag } from "./GestureHandler"
+import { RNGHLogger } from "./RNGHLogger"
+
+export class InteractionManager {
+  private readonly waitForRelations: Map<GHTag, Set<GHTag>> = new Map()
+  private readonly simultaneousRelations: Map<GHTag, GHTag[]> = new Map()
+  private readonly blocksHandlersRelations: Map<GHTag, GHTag[]> = new Map();
+
+  private logger: RNGHLogger
+
+  constructor(logger: RNGHLogger) {
+    this.logger = logger.cloneWithPrefix("InteractionManager")
+  }
+
+  public configureInteractions(handler: GestureHandler, config: Config) {
+    this.dropRelationsForHandlerWithTag(handler.getTag());
+
+    if (config.waitFor) {
+      const waitFor = new Set<GHTag>();
+      config.waitFor.forEach((otherHandler: Handler): void => {
+        // New API reference
+        if (typeof otherHandler === 'number') {
+          waitFor.add(otherHandler);
+        } else {
+          // Old API reference
+          waitFor.add(otherHandler.handlerTag);
+        }
+      });
+
+      this.waitForRelations.set(handler.getTag(), waitFor);
+    }
+
+    if (config.simultaneousHandlers) {
+      const simultaneousHandlers: number[] = [];
+      config.simultaneousHandlers.forEach((otherHandler: Handler): void => {
+        if (typeof otherHandler === 'number') {
+          simultaneousHandlers.push(otherHandler);
+        } else {
+          simultaneousHandlers.push(otherHandler.handlerTag);
+        }
+      });
+
+      this.simultaneousRelations.set(handler.getTag(), simultaneousHandlers);
+    }
+
+     if (config.blocksHandlers) {
+       const blocksHandlers: number[] = [];
+       config.blocksHandlers.forEach((otherHandler: Handler): void => {
+         if (typeof otherHandler === 'number') {
+           blocksHandlers.push(otherHandler);
+         } else {
+           blocksHandlers.push(otherHandler.handlerTag);
+         }
+       });
+       this.blocksHandlersRelations.set(handler.getTag(), blocksHandlers);
+     }
+  }
+
+  public shouldWaitForHandlerFailure(
+    handler: GestureHandler,
+    otherHandler: GestureHandler
+  ): boolean {
+    const logger = this.logger.cloneWithPrefix(`shouldWaitForHandlerFailure(${handler.getTag()}, ${otherHandler.getTag()})`)
+    const waitFor = this.waitForRelations.get(
+      handler.getTag()
+    );
+    logger.debug({waitFor: Array.from(waitFor ?? [])})
+    if (!waitFor) {
+      logger.debug("false")
+      return false;
+    }
+
+    let shouldWait = false;
+    waitFor.forEach((tag: number): void => {
+      if (tag === otherHandler.getTag()) {
+        shouldWait = true;
+        return; //Returns from callback
+      }
+    });
+    logger.debug(shouldWait)
+    return shouldWait;
+  }
+
+  public shouldRecognizeSimultaneously(
+    handler: GestureHandler,
+    otherHandler: GestureHandler
+  ): boolean {
+    const logger = this.logger.cloneWithPrefix(`shouldRecognizeSimultaneously(${handler.getTag()}, ${otherHandler.getTag()})`)
+    const simultaneousHandlers: number[] | undefined =
+      this.simultaneousRelations.get(handler.getTag());
+    if (!simultaneousHandlers) {
+      logger.debug(`false - Handler ${handler.getTag()} doesn't have simultaneousRelations specified`)
+      return false;
+    }
+    let shouldRecognizeSimultaneously = false;
+    simultaneousHandlers.forEach((tag: number): void => {
+      if (tag === otherHandler.getTag()) {
+        shouldRecognizeSimultaneously = true;
+        return;
+      }
+    });
+    logger.debug(`${shouldRecognizeSimultaneously} ${JSON.stringify({ simultaneousHandlers })}`)
+    return shouldRecognizeSimultaneously;
+  }
+
+  public shouldRequireHandlerToWaitForFailure(
+    handler: GestureHandler,
+    otherHandler: GestureHandler
+  ): boolean {
+    const waitFor: number[] | undefined = this.blocksHandlersRelations.get(
+      handler.getTag()
+    );
+
+    return (
+      waitFor?.find((tag: number) => {
+        return tag === otherHandler.getTag();
+      }) !== undefined
+    );
+  }
+
+  public shouldHandlerBeCancelledBy(
+    handler: GestureHandler,
+    otherHandler: GestureHandler
+  ): boolean {
+    const logger = this.logger.cloneWithPrefix(`shouldHandlerBeCancelledBy(handler=${handler.getTag()}, otherHandler=${otherHandler.getTag()})`)
+    // We check constructor name instead of using `instanceof` in order do avoid circular dependencies
+    // const isNativeHandler =
+    //   otherHandler.constructor.name === 'NativeViewGestureHandler';
+    // const isActive = otherHandler.getState() === State.ACTIVE;
+    // const isButton = otherHandler.isButton?.() === true;
+    // return isNativeHandler && isActive && !isButton;
+    return false
+  }
+
+  public dropRelationsForHandlerWithTag(handlerTag: number): void {
+    this.waitForRelations.delete(handlerTag);
+    this.simultaneousRelations.delete(handlerTag);
+  }
+
+  public reset() {
+    this.waitForRelations.clear();
+    this.simultaneousRelations.clear();
+  }
+}

package/harmony/gesture_handler/src/main/ets/{OutgoingEvent.ts → core/OutgoingEvent.ts}

@@ -1,5 +1,5 @@
 import { State } from "./State"
-import { TouchEventType } from "./Event"
+import { TouchEventType } from "./IncomingEvent"
 
 export interface GestureEventPayload {
   handlerTag: number;

package/harmony/gesture_handler/src/main/ets/core/OutgoingEventDispatcher.ts

@@ -0,0 +1,12 @@
+import {
+  GestureStateChangeEvent,
+  GestureUpdateEvent,
+  GestureTouchEvent,
+} from './OutgoingEvent';
+
+export interface OutgoingEventDispatcher {
+  onGestureHandlerStateChange(event: GestureStateChangeEvent): void;
+  onGestureHandlerEvent(
+    event: GestureStateChangeEvent | GestureUpdateEvent | GestureTouchEvent,
+  ): void;
+}

package/harmony/gesture_handler/src/main/ets/{PointerTracker.ts → core/PointerTracker.ts}

@@ -1,5 +1,5 @@
-import VelocityTracker from './VelocityTracker';
-import { TrackerElement, AdaptedEvent } from "./Event"
+import { VelocityTracker, TrackerElement } from './VelocityTracker';
+import { IncomingEvent } from "./IncomingEvent"
 import { Vector2D } from './Vector2D';
 
 const MAX_POINTERS = 20;
@@ -25,7 +25,7 @@ export class PointerTracker {
     }
   }
 
-  public addToTracker(event: AdaptedEvent): void {
+  public addToTracker(event: IncomingEvent): void {
     if (this.trackedPointers.has(event.pointerId)) {
       return;
     }
@@ -54,7 +54,7 @@ export class PointerTracker {
     this.removeMappedTouchId(pointerId);
   }
 
-  public track(event: AdaptedEvent): void {
+  public track(event: IncomingEvent): void {
     const element: TrackerElement = this.trackedPointers.get(
       event.pointerId
     ) as TrackerElement;

package/harmony/gesture_handler/src/main/ets/core/RNGHLogger.ts

@@ -0,0 +1,12 @@
+export type RNGHLoggerMessage = string | Object
+
+export interface RNGHLogger {
+  info(msg: string): void;
+
+  cloneWithPrefix(prefix: string): RNGHLogger;
+
+  debug(msg: RNGHLoggerMessage);
+
+  error(msg: string);
+}
+

package/harmony/gesture_handler/src/main/ets/core/Vector2D.ts

@@ -0,0 +1,80 @@
+import { Directions, DiagonalDirections } from "./IncomingEvent"
+
+type Cosine = number
+
+export class Vector2D {
+  private static VECTOR_BY_DIRECTION = new Map<
+      Directions | DiagonalDirections,
+      Vector2D
+    >([
+      [Directions.LEFT, new Vector2D({ x: -1, y: 0 })],
+      [Directions.RIGHT, new Vector2D({ x: 1, y: 0 })],
+      [Directions.UP, new Vector2D({ x: 0, y: -1 })],
+      [Directions.DOWN, new Vector2D({ x: 0, y: 1 })],
+      [DiagonalDirections.UP_RIGHT, new Vector2D({ x: 1, y: -1 })],
+      [DiagonalDirections.DOWN_RIGHT, new Vector2D({ x: 1, y: 1 })],
+      [DiagonalDirections.UP_LEFT, new Vector2D({ x: -1, y: -1 })],
+      [DiagonalDirections.DOWN_LEFT, new Vector2D({ x: -1, y: 1 })],
+    ]);
+
+  static fromDirection(direction: Directions | DiagonalDirections): Vector2D {
+    return Vector2D.VECTOR_BY_DIRECTION.get(direction)!;
+  }
+
+
+  constructor(
+    private val: {
+      x: number;
+      y: number;
+    } = {x: 0, y: 0},
+  ) {}
+
+  get x() {
+    return this.val.x;
+  }
+
+  get y() {
+    return this.val.y;
+  }
+
+  get value() {
+    return {...this.val};
+  }
+
+  public clone() {
+    return new Vector2D({...this.val});
+  }
+
+  public subtract(vec: Vector2D) {
+    this.val.x -= vec.x;
+    this.val.y -= vec.y;
+    return this;
+  }
+
+  public add(vec: Vector2D) {
+    this.val.x += vec.x;
+    this.val.y += vec.y;
+    return this;
+  }
+
+  public createUnitVector(): Vector2D {
+    const magnitude = this.magnitude
+    if (magnitude === 0) {
+      return new Vector2D({ x: 0, y: 0 });
+    }
+    return new Vector2D({
+      x: this.val.x / magnitude,
+      y: this.val.y / magnitude
+    });
+  }
+
+  public computeCosine(other: Vector2D): Cosine {
+    const thisUnit = this.createUnitVector();
+    const otherUnit = other.createUnitVector();
+    return thisUnit.val.x * otherUnit.val.x + thisUnit.val.y * otherUnit.val.y;
+  }
+
+  public get magnitude() {
+    return Math.hypot(this.x, this.y);
+  }
+}

package/harmony/gesture_handler/src/main/ets/{VelocityTracker.ts → core/VelocityTracker.ts}

@@ -1,20 +1,28 @@
-import { AdaptedEvent } from './Event';
+import { IncomingEvent } from './IncomingEvent';
 import { CircularBuffer } from './CircularBuffer';
 import { LeastSquareSolver } from './LeastSquareSolver';
 
-export default class VelocityTracker {
+export interface TrackerElement {
+  lastX: number;
+  lastY: number;
+  timeStamp: number;
+  velocityX: number;
+  velocityY: number;
+}
+
+export class VelocityTracker {
   private assumePointerMoveStoppedMilliseconds = 40;
   private historySize = 20;
   private horizonMilliseconds = 300;
   private minSampleSize = 3;
 
-  private samples: CircularBuffer<AdaptedEvent>;
+  private samples: CircularBuffer<IncomingEvent>;
 
   constructor() {
-    this.samples = new CircularBuffer<AdaptedEvent>(this.historySize);
+    this.samples = new CircularBuffer<IncomingEvent>(this.historySize);
   }
 
-  public add(event: AdaptedEvent): void {
+  public add(event: IncomingEvent): void {
     this.samples.push(event);
   }
 

package/harmony/gesture_handler/src/main/ets/core/View.ts

@@ -0,0 +1,19 @@
+export type Tag = number
+
+export type BoundingBox = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+export interface View {
+  getTag(): Tag
+
+  isPositionInBounds({x, y}: {
+    x: number;
+    y: number
+  }): boolean
+
+  getBoundingRect(): BoundingBox
+}

package/harmony/gesture_handler/src/main/ets/core/index.ts

@@ -0,0 +1,13 @@
+export * from "./OutgoingEventDispatcher"
+export * from "./OutgoingEvent"
+export * from "./RNGHLogger"
+export * from "./View"
+export * from "./Vector2D"
+export * from "./GestureHandler"
+export * from "./IncomingEvent"
+export * from "./GestureHandlerOrchestrator"
+export * from "./InteractionManager"
+export * from "./PointerTracker"
+export * from "./RNGHError"
+export * from "./State"
+export * from "./GestureHandlerRegistry"

package/harmony/gesture_handler/src/main/ets/detectors/ScaleGestureDetector.ts

@@ -0,0 +1,169 @@
+import { DEFAULT_TOUCH_SLOP, IncomingEvent, EventType, PointerTracker } from '../core';
+
+export interface ScaleGestureListener {
+  onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+  onScale: (detector: ScaleGestureDetector) => boolean;
+  onScaleEnd: (detector: ScaleGestureDetector) => void;
+}
+
+export default class ScaleGestureDetector implements ScaleGestureListener {
+  public onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+  public onScale: (detector: ScaleGestureDetector) => boolean;
+  public onScaleEnd: (detector: ScaleGestureDetector) => void;
+
+  private focusX!: number;
+  private focusY!: number;
+
+  private currentSpan!: number;
+  private prevSpan!: number;
+  private initialSpan!: number;
+
+  private currentTime!: number;
+  private prevTime!: number;
+
+  private inProgress = false;
+
+  private spanSlop: number;
+  private minSpan: number;
+
+  public constructor(callbacks: ScaleGestureListener) {
+    this.onScaleBegin = callbacks.onScaleBegin;
+    this.onScale = callbacks.onScale;
+    this.onScaleEnd = callbacks.onScaleEnd;
+
+    this.spanSlop = DEFAULT_TOUCH_SLOP * 2;
+    this.minSpan = 0;
+  }
+
+  public onTouchEvent(event: IncomingEvent, tracker: PointerTracker): boolean {
+    this.currentTime = event.time;
+
+    const action: EventType = event.eventType;
+    const numOfPointers = tracker.getTrackedPointersCount();
+
+    const streamComplete: boolean =
+      action === EventType.UP ||
+      action === EventType.ADDITIONAL_POINTER_UP ||
+      action === EventType.CANCEL;
+
+    if (action === EventType.DOWN || streamComplete) {
+      if (this.inProgress) {
+        this.onScaleEnd(this);
+        this.inProgress = false;
+        this.initialSpan = 0;
+      }
+
+      if (streamComplete) {
+        return true;
+      }
+    }
+
+    const configChanged: boolean =
+      action === EventType.DOWN ||
+      action === EventType.ADDITIONAL_POINTER_UP ||
+      action === EventType.ADDITIONAL_POINTER_DOWN;
+
+    const pointerUp = action === EventType.ADDITIONAL_POINTER_UP;
+
+    const ignoredPointer: number | undefined = pointerUp
+      ? event.pointerId
+      : undefined;
+
+    //Determine focal point
+
+    const div: number = pointerUp ? numOfPointers - 1 : numOfPointers;
+
+    const sumX = tracker.getSumX(ignoredPointer);
+    const sumY = tracker.getSumY(ignoredPointer);
+
+    const focusX = sumX / div;
+    const focusY = sumY / div;
+
+    //Determine average deviation from focal point
+
+    let devSumX = 0;
+    let devSumY = 0;
+
+    tracker.getData().forEach((value, key) => {
+      if (key === ignoredPointer) {
+        return;
+      }
+
+      devSumX += Math.abs(value.lastX - focusX);
+      devSumY += Math.abs(value.lastY - focusY);
+    });
+
+    const devX: number = devSumX / div;
+    const devY: number = devSumY / div;
+
+    const spanX: number = devX * 2;
+    const spanY: number = devY * 2;
+
+    const span = Math.hypot(spanX, spanY);
+
+    //Begin/end events
+    const wasInProgress: boolean = this.inProgress;
+    this.focusX = focusX;
+    this.focusY = focusY;
+
+    if (this.inProgress && (span < this.minSpan || configChanged)) {
+      this.onScaleEnd(this);
+      this.inProgress = false;
+      this.initialSpan = span;
+    }
+
+    if (configChanged) {
+      this.initialSpan = this.prevSpan = this.currentSpan = span;
+    }
+
+    if (
+      !this.inProgress &&
+      span >= this.minSpan &&
+      (wasInProgress || Math.abs(span - this.initialSpan) > this.spanSlop)
+    ) {
+      this.prevSpan = this.currentSpan = span;
+      this.prevTime = this.currentTime;
+      this.inProgress = this.onScaleBegin(this);
+    }
+
+    //Handle motion
+    if (action !== EventType.MOVE) {
+      return true;
+    }
+
+    this.currentSpan = span;
+
+    if (this.inProgress && !this.onScale(this)) {
+      return true;
+    }
+
+    this.prevSpan = this.currentSpan;
+    this.prevTime = this.currentTime;
+
+    return true;
+  }
+
+  public getCurrentSpan(): number {
+    return this.currentSpan;
+  }
+
+  public getFocusX(): number {
+    return this.focusX;
+  }
+
+  public getFocusY(): number {
+    return this.focusY;
+  }
+
+  public getTimeDelta(): number {
+    return this.currentTime - this.prevTime;
+  }
+
+  public getScaleFactor(numOfPointers: number): number {
+    if (numOfPointers < 2) {
+      return 1;
+    }
+
+    return this.prevSpan > 0 ? this.currentSpan / this.prevSpan : 1;
+  }
+}