@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1 → 2.12.6-2

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

@@ -1,240 +1,239 @@
-import { AdaptedEvent } from '../interfaces';
-import VelocityTracker from './VelocityTracker';
-
-export interface TrackerElement {
-  lastX: number;
-  lastY: number;
-
-  timeStamp: number;
-
-  velocityX: number;
-  velocityY: number;
-}
-
-const MAX_POINTERS = 20;
-
-export default 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: AdaptedEvent): 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: AdaptedEvent): 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 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;
-    }
-  }
-
-  // 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));
-  }
-}
+import VelocityTracker from './VelocityTracker';
+import { TrackerElement, AdaptedEvent } from "./Event"
+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: AdaptedEvent): 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: AdaptedEvent): 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/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/RNGHLogger.ts

@@ -0,0 +1,29 @@
+import { RNOHContext } from "rnoh/ts"
+
+export interface RNGHLogger {
+  info(msg: string): void
+
+  cloneWithPrefix(prefix: string): RNGHLogger
+}
+
+export class StandardRNGHLogger implements RNGHLogger {
+  constructor(private rnohLogger: RNOHContext["logger"], private prefix: string) {
+  }
+
+  info(msg: string) {
+    this.rnohLogger.info(`${this.prefix}::${msg}`)
+  }
+
+  cloneWithPrefix(prefix: string) {
+    return new StandardRNGHLogger(this.rnohLogger, `${this.prefix}::${prefix}`)
+  }
+}
+
+export class FakeRNGHLogger implements RNGHLogger {
+  info(msg: string) {
+  }
+
+  cloneWithPrefix(prefix: string) {
+    return new FakeRNGHLogger()
+  }
+}

package/harmony/gesture_handler/src/main/ets/RNGHRootTouchHandler.ets

@@ -0,0 +1,58 @@
+import { Tag } from "rnoh"
+import { GestureHandlerRegistry } from "./GestureHandlerRegistry"
+import { GestureHandlerArkUIAdapter } from "./GestureHandlerArkUIAdapter"
+import { ViewRegistry } from "./ViewRegistry"
+import { RNGHLogger } from './RNGHLogger'
+
+
+export class RNGHRootTouchHandler {
+  private adapterByViewTag: Map<number, GestureHandlerArkUIAdapter> = new Map() // TODO: remove an adapter when a view or gesture handler is removed
+  private activeViewTags: number[] = []
+  private viewRegistry: ViewRegistry
+  private gestureHandlerRegistry: GestureHandlerRegistry
+  private logger: RNGHLogger
+  private rootTag: Tag
+
+  constructor(rootTag: Tag, viewRegistry: ViewRegistry, gestureHandlerRegistry: GestureHandlerRegistry, logger: RNGHLogger) {
+    this.rootTag = rootTag
+    this.viewRegistry = viewRegistry
+    this.gestureHandlerRegistry = gestureHandlerRegistry
+    this.logger = logger
+  }
+
+  public handleTouch(e: TouchEvent) {
+    if (e.type === TouchType.Down) {
+      this.activeViewTags = []
+    }
+    for (const changedTouch of e.changedTouches) {
+      const views = this.viewRegistry.getTouchableViewsAt({
+        x: changedTouch.windowX,
+        y: changedTouch.windowY
+      }, this.rootTag)
+      for (const view of views) {
+        for (const handler of this.gestureHandlerRegistry.getGestureHandlersByViewTag(view.getTag())) {
+          this.logger.info(`Found GestureHandler ${handler.getTag()} for view ${view.getTag()}`)
+          if (!this.adapterByViewTag.has(view.getTag()))
+            this.adapterByViewTag.set(view.getTag(), new GestureHandlerArkUIAdapter(handler, view, this.logger.cloneWithPrefix("ArkUIAdapter")))
+          if (!this.activeViewTags.includes(view.getTag())) {
+            const adapter = this.adapterByViewTag.get(view.getTag())
+            if (adapter) {
+              adapter.handleTouch(e)
+            } else {
+              console.warn("RNGH: Couldn't find adapter")
+            }
+          }
+          if (e.type === TouchType.Down) {
+            this.activeViewTags.push(view.getTag())
+          }
+        }
+      }
+      for (const viewTag of this.activeViewTags) {
+        const adapter = this.adapterByViewTag.get(viewTag)
+        if (adapter) {
+          adapter.handleTouch(e)
+        }
+      }
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/RNGestureHandlerButton.ets

@@ -0,0 +1,37 @@
+import { Descriptor, RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "rnoh"
+
+export type RNGestureHandlerButtonDescriptor = Descriptor<"RNGestureHandlerButton">
+
+@Component
+export struct RNGestureHandlerButton {
+  static readonly DESCRIPTOR_TYPE = "RNGestureHandlerButton"
+  public ctx!: RNOHContext
+  public tag: number = -1
+  @BuilderParam public buildCustomComponent: (componentBuilderContext: ComponentBuilderContext) => void
+
+  @State private descriptor: RNGestureHandlerButtonDescriptor = {} as RNGestureHandlerButtonDescriptor
+  private unsubscribes: (() => void)[] = []
+
+  aboutToAppear() {
+    this.handleDescriptorChange(this.ctx.descriptorRegistry.getDescriptor<RNGestureHandlerButtonDescriptor>(this.tag))
+    this.unsubscribes.push(this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag, (d) => {
+      this.handleDescriptorChange(d as RNGestureHandlerButtonDescriptor)
+    }))
+  }
+
+  aboutToDisappear() {
+    this.unsubscribes.forEach(unsubscribe => unsubscribe())
+  }
+
+  handleDescriptorChange(newDescriptor: RNGestureHandlerButtonDescriptor) {
+    this.descriptor = newDescriptor
+  }
+
+  build() {
+    RNViewBase({ ctx: this.ctx, tag: this.tag }) {
+      ForEach(this.descriptor.childrenTags, (childrenTag: Tag) => {
+        RNComponentFactory({ ctx: this.ctx, tag: childrenTag, buildCustomComponent: this.buildCustomComponent })
+      })
+    }
+  }
+}