@react-native-oh-tpl/react-native-gesture-handler 2.14.7 → 2.14.13

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

@@ -0,0 +1,182 @@
+// Implementation taken from Flutter's LeastSquareSolver
+// https://github.com/flutter/flutter/blob/master/packages/flutter/lib/src/gestures/lsq_solver.dart
+
+class Vector {
+  private offset: number;
+  private length: number;
+  private elements: number[];
+
+  constructor(length: number) {
+    this.offset = 0;
+    this.length = length;
+    this.elements = new Array<number>(length);
+  }
+
+  public static fromVOL(
+    values: number[],
+    offset: number,
+    length: number
+  ): Vector {
+    const result = new Vector(0);
+
+    result.offset = offset;
+    result.length = length;
+    result.elements = values;
+
+    return result;
+  }
+
+  public get(index: number): number {
+    return this.elements[this.offset + index];
+  }
+
+  public set(index: number, value: number): void {
+    this.elements[this.offset + index] = value;
+  }
+
+  public dot(other: Vector): number {
+    let result = 0;
+    for (let i = 0; i < this.length; i++) {
+      result += this.get(i) * other.get(i);
+    }
+    return result;
+  }
+
+  public norm() {
+    return Math.sqrt(this.dot(this));
+  }
+}
+
+class Matrix {
+  private columns: number;
+  private elements: number[];
+
+  constructor(rows: number, columns: number) {
+    this.columns = columns;
+    this.elements = new Array<number>(rows * columns);
+  }
+
+  public get(row: number, column: number): number {
+    return this.elements[row * this.columns + column];
+  }
+
+  public set(row: number, column: number, value: number): void {
+    this.elements[row * this.columns + column] = value;
+  }
+
+  public getRow(row: number): Vector {
+    return Vector.fromVOL(this.elements, row * this.columns, this.columns);
+  }
+}
+
+/// An nth degree polynomial fit to a dataset.
+class PolynomialFit {
+  /// The polynomial coefficients of the fit.
+  ///
+  /// For each `i`, the element `coefficients[i]` is the coefficient of
+  /// the `i`-th power of the variable.
+  public coefficients: number[];
+
+  /// Creates a polynomial fit of the given degree.
+  ///
+  /// There are n + 1 coefficients in a fit of degree n.
+  constructor(degree: number) {
+    this.coefficients = new Array<number>(degree + 1);
+  }
+}
+
+const precisionErrorTolerance = 1e-10;
+
+/// Uses the least-squares algorithm to fit a polynomial to a set of data.
+export class LeastSquareSolver {
+  /// The x-coordinates of each data point.
+  private x: number[];
+  /// The y-coordinates of each data point.
+  private y: number[];
+  /// The weight to use for each data point.
+  private w: number[];
+
+  /// Creates a least-squares solver.
+  ///
+  /// The [x], [y], and [w] arguments must not be null.
+  constructor(x: number[], y: number[], w: number[]) {
+    this.x = x;
+    this.y = y;
+    this.w = w;
+  }
+
+  /// Fits a polynomial of the given degree to the data points.
+  ///
+  /// When there is not enough data to fit a curve null is returned.
+  public solve(degree: number): PolynomialFit | null {
+    if (degree > this.x.length) {
+      // Not enough data to fit a curve.
+      return null;
+    }
+
+    const result = new PolynomialFit(degree);
+
+    // Shorthands for the purpose of notation equivalence to original C++ code.
+    const m = this.x.length;
+    const n = degree + 1;
+
+    // Expand the X vector to a matrix A, pre-multiplied by the weights.
+    const a = new Matrix(n, m);
+    for (let h = 0; h < m; h++) {
+      a.set(0, h, this.w[h]);
+
+      for (let i = 1; i < n; i++) {
+        a.set(i, h, a.get(i - 1, h) * this.x[h]);
+      }
+    }
+
+    // Apply the Gram-Schmidt process to A to obtain its QR decomposition.
+
+    // Orthonormal basis, column-major ordVectorer.
+    const q = new Matrix(n, m);
+    // Upper triangular matrix, row-major order.
+    const r = new Matrix(n, m);
+
+    for (let j = 0; j < n; j += 1) {
+      for (let h = 0; h < m; h += 1) {
+        q.set(j, h, a.get(j, h));
+      }
+      for (let i = 0; i < j; i += 1) {
+        const dot = q.getRow(j).dot(q.getRow(i));
+        for (let h = 0; h < m; h += 1) {
+          q.set(j, h, q.get(j, h) - dot * q.get(i, h));
+        }
+      }
+
+      const norm = q.getRow(j).norm();
+      if (norm < precisionErrorTolerance) {
+        // Vectors are linearly dependent or zero so no solution.
+        return null;
+      }
+
+      const inverseNorm = 1.0 / norm;
+      for (let h = 0; h < m; h += 1) {
+        q.set(j, h, q.get(j, h) * inverseNorm);
+      }
+      for (let i = 0; i < n; i += 1) {
+        r.set(j, i, i < j ? 0.0 : q.getRow(j).dot(a.getRow(i)));
+      }
+    }
+
+    // Solve R B = Qt W Y to find B. This is easy because R is upper triangular.
+    // We just work from bottom-right to top-left calculating B's coefficients.
+    const wy = new Vector(m);
+    for (let h = 0; h < m; h += 1) {
+      wy.set(h, this.y[h] * this.w[h]);
+    }
+    for (let i = n - 1; i >= 0; i -= 1) {
+      result.coefficients[i] = q.getRow(i).dot(wy);
+      for (let j = n - 1; j > i; j -= 1) {
+        result.coefficients[i] -= r.get(i, j) * result.coefficients[j];
+      }
+      result.coefficients[i] /= r.get(i, i);
+    }
+
+    return result;
+  }
+}

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

@@ -0,0 +1,34 @@
+import { State } from "./State"
+import { TouchEventType } from "./IncomingEvent"
+
+export interface GestureEventPayload {
+  handlerTag: number;
+  numberOfPointers: number;
+  state: State;
+}
+
+export interface HandlerStateChangeEventPayload extends GestureEventPayload {
+  oldState: State;
+}
+
+export type GestureUpdateEvent<GestureEventPayloadT = Record<string, unknown>> = GestureEventPayload
+  & GestureEventPayloadT
+
+export type GestureStateChangeEvent<GestureStateChangeEventPayloadT = Record<string, unknown>> = HandlerStateChangeEventPayload & GestureStateChangeEventPayloadT
+
+export type TouchData = {
+  id: number;
+  x: number;
+  y: number;
+  absoluteX: number;
+  absoluteY: number;
+};
+
+export type GestureTouchEvent = {
+  handlerTag: number;
+  numberOfTouches: number;
+  state: State;
+  eventType: TouchEventType;
+  allTouches: TouchData[];
+  changedTouches: TouchData[];
+};

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/core/PointerTracker.ts

@@ -0,0 +1,239 @@
+import { VelocityTracker, TrackerElement } from './VelocityTracker';
+import { IncomingEvent } from "./IncomingEvent"
+import { Vector2D } from './Vector2D';
+
+const MAX_POINTERS = 20;
+
+export class PointerTracker {
+  private velocityTracker = new VelocityTracker();
+  private trackedPointers: Map<number, TrackerElement> = new Map<
+  number,
+  TrackerElement
+  >();
+
+  private touchEventsIds: Map<number, number> = new Map<number, number>();
+
+  private lastMovedPointerId: number;
+
+  private cachedAverages: { x: number; y: number } = { x: 0, y: 0 };
+
+  public constructor() {
+    this.lastMovedPointerId = NaN;
+
+    for (let i = 0; i < MAX_POINTERS; ++i) {
+      this.touchEventsIds.set(i, NaN);
+    }
+  }
+
+  public addToTracker(event: IncomingEvent): void {
+    if (this.trackedPointers.has(event.pointerId)) {
+      return;
+    }
+
+    this.lastMovedPointerId = event.pointerId;
+
+    const newElement: TrackerElement = {
+      lastX: event.x,
+      lastY: event.y,
+      timeStamp: event.time,
+      velocityX: 0,
+      velocityY: 0,
+    };
+
+    this.trackedPointers.set(event.pointerId, newElement);
+    this.mapTouchEventId(event.pointerId);
+
+    this.cachedAverages = {
+      x: this.getLastAvgX(),
+      y: this.getLastAvgY(),
+    };
+  }
+
+  public removeFromTracker(pointerId: number): void {
+    this.trackedPointers.delete(pointerId);
+    this.removeMappedTouchId(pointerId);
+  }
+
+  public track(event: IncomingEvent): void {
+    const element: TrackerElement = this.trackedPointers.get(
+      event.pointerId
+    ) as TrackerElement;
+
+    if (!element) {
+      return;
+    }
+
+    this.lastMovedPointerId = event.pointerId;
+
+    this.velocityTracker.add(event);
+    const [velocityX, velocityY] = this.velocityTracker.getVelocity();
+
+    element.velocityX = velocityX;
+    element.velocityY = velocityY;
+
+    element.lastX = event.x;
+    element.lastY = event.y;
+
+    this.trackedPointers.set(event.pointerId, element);
+
+    const avgX: number = this.getLastAvgX();
+    const avgY: number = this.getLastAvgY();
+
+    this.cachedAverages = {
+      x: avgX,
+      y: avgY,
+    };
+  }
+
+  //Mapping TouchEvents ID
+  private mapTouchEventId(id: number): void {
+    for (const [mappedId, touchId] of this.touchEventsIds) {
+      if (isNaN(touchId)) {
+        this.touchEventsIds.set(mappedId, id);
+        break;
+      }
+    }
+  }
+
+  private removeMappedTouchId(id: number): void {
+    const mappedId: number = this.getMappedTouchEventId(id);
+    if (!isNaN(mappedId)) {
+      this.touchEventsIds.set(mappedId, NaN);
+    }
+  }
+
+  public getMappedTouchEventId(touchEventId: number): number {
+    for (const [key, value] of this.touchEventsIds.entries()) {
+      if (value === touchEventId) {
+        return key;
+      }
+    }
+
+    return NaN;
+  }
+
+  public getVelocity(pointerId: number) {
+    return new Vector2D({x: this.getVelocityX(pointerId), y: this.getVelocityY(pointerId)})
+  }
+
+  public getVelocityX(pointerId: number): number {
+    return this.trackedPointers.get(pointerId)?.velocityX as number;
+  }
+  public getVelocityY(pointerId: number): number {
+    return this.trackedPointers.get(pointerId)?.velocityY as number;
+  }
+
+  /**
+   * Returns X coordinate of last moved pointer
+   */
+  public getLastX(): number;
+
+  /**
+   *
+   * @param pointerId
+   * Returns X coordinate of given pointer
+   */
+  // eslint-disable-next-line @typescript-eslint/unified-signatures
+  public getLastX(pointerId: number): number;
+
+  public getLastX(pointerId?: number): number {
+    if (pointerId !== undefined) {
+      return this.trackedPointers.get(pointerId)?.lastX as number;
+    } else {
+      return this.trackedPointers.get(this.lastMovedPointerId)?.lastX as number;
+    }
+  }
+
+  /**
+   * Returns Y coordinate of last moved pointer
+   */
+  public getLastY(): number;
+
+  /**
+   *
+   * @param pointerId
+   * Returns Y coordinate of given pointer
+   */
+  // eslint-disable-next-line @typescript-eslint/unified-signatures
+  public getLastY(pointerId: number): number;
+
+  public getLastY(pointerId?: number): number {
+    if (pointerId !== undefined) {
+      return this.trackedPointers.get(pointerId)?.lastY as number;
+    } else {
+      return this.trackedPointers.get(this.lastMovedPointerId)?.lastY as number;
+    }
+  }
+
+  public getLastAvgPos() {
+    return new Vector2D({x: this.getLastAvgX(), y: this.getLastAvgY()})
+  }
+
+  // Some handlers use these methods to send average values in native event.
+  // This may happen when pointers have already been removed from tracker (i.e. pointerup event).
+  // In situation when NaN would be sent as a response, we return cached value.
+  // That prevents handlers from crashing
+  public getLastAvgX(): number {
+    const avgX: number = this.getSumX() / this.trackedPointers.size;
+    return isNaN(avgX) ? this.cachedAverages.x : avgX;
+  }
+  public getLastAvgY(): number {
+    const avgY: number = this.getSumY() / this.trackedPointers.size;
+    return isNaN(avgY) ? this.cachedAverages.y : avgY;
+  }
+  public getSumX(ignoredPointer?: number): number {
+    let sumX = 0;
+
+    this.trackedPointers.forEach((value, key) => {
+      if (key !== ignoredPointer) {
+        sumX += value.lastX;
+      }
+    });
+
+    return sumX;
+  }
+  public getSumY(ignoredPointer?: number): number {
+    let sumY = 0;
+
+    this.trackedPointers.forEach((value, key) => {
+      if (key !== ignoredPointer) {
+        sumY += value.lastY;
+      }
+    });
+
+    return sumY;
+  }
+  public getTrackedPointersCount(): number {
+    return this.trackedPointers.size;
+  }
+  public getTrackedPointersID(): number[] {
+    const keys: number[] = [];
+
+    this.trackedPointers.forEach((_value, key) => {
+      keys.push(key);
+    });
+
+    return keys;
+  }
+
+  public getData(): Map<number, TrackerElement> {
+    return this.trackedPointers;
+  }
+
+  public resetTracker(): void {
+    this.velocityTracker.reset();
+    this.trackedPointers.clear();
+    this.lastMovedPointerId = NaN;
+
+    for (let i = 0; i < MAX_POINTERS; ++i) {
+      this.touchEventsIds.set(i, NaN);
+    }
+  }
+
+  public static shareCommonPointers(
+    stPointers: number[],
+    ndPointers: number[]
+  ): boolean {
+    return stPointers.some((pointerId) => ndPointers.includes(pointerId));
+  }
+}

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

@@ -0,0 +1,5 @@
+export class RNGHError extends Error {
+  constructor(message: string) {
+    super("rnoh-gesture-handler: " + message)
+  }
+}

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/State.ts

@@ -0,0 +1,47 @@
+export enum State {
+  /** This is the initial state of each handler and it goes into this state after it's done recognizing a gesture. */
+  UNDETERMINED,
+
+  /** A handler received some touches but for some reason didn't recognize them. For example, if a finger travels more
+   * distance than a defined maxDist property allows, then the handler won't become active but will fail instead.
+   * Afterwards, it's state will be reset to UNDETERMINED. */
+  FAILED,
+
+  /** Handler has started receiving touch stream but hasn't yet received enough data to either fail or activate. */
+  BEGAN,
+
+  /** The gesture recognizer has received a signal (possibly new touches or a command from the touch system controller)
+   * resulting in the cancellation of a continuous gesture. The gesture's state will become CANCELLED until it is
+   * finally reset to the initial state, UNDETERMINED. */
+  CANCELLED,
+
+  /** Handler has recognized a gesture. It will become and stay in the ACTIVE state until the gesture finishes
+   * (e.g. when user lifts the finger) or gets cancelled by the touch system. Under normal circumstances the state will
+   * then turn into END. In the case that a gesture is cancelled by the touch system, its state would then become
+   * CANCELLED. Learn about discrete and continuous handlers here to understand how long a handler can be kept in the
+   * ACTIVE state.
+   * */
+  ACTIVE,
+
+  /** The gesture recognizer has received touches signalling the end of a gesture. Its state will become END until it is
+   * reset to UNDETERMINED.
+   * */
+  END,
+}
+
+export function getStateName(state: State): string {
+  switch (state) {
+    case State.UNDETERMINED:
+      return "UNDETERMINED"
+    case State.FAILED:
+      return "FAILED"
+    case State.BEGAN:
+      return "BEGAN"
+    case State.CANCELLED:
+      return "CANCELLED"
+    case State.ACTIVE:
+      return "ACTIVE"
+    case State.END:
+      return "END"
+  }
+}

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);
+  }
+}