@react-native-oh-tpl/react-native-gesture-handler 2.12.9 → 2.14.4-1

package/harmony/gesture_handler/src/main/ets/PointerTracker.ts

@@ -1,239 +0,0 @@
-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

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

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

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

package/harmony/gesture_handler/src/main/ets/RNGHRootTouchHandlerArkTS.ts

@@ -1,60 +0,0 @@
-import { Tag } from "@rnoh/react-native-openharmony/ts"
-import { GestureHandlerRegistry } from "./GestureHandlerRegistry"
-import { GestureHandlerArkUIAdapter } from "./GestureHandlerArkUIAdapter"
-import { ViewRegistry } from "./ViewRegistry"
-import { RNGHLogger } from './RNGHLogger'
-import { TouchEvent, TouchType } from "./types"
-
-
-export class RNGHRootTouchHandlerArkTS {
-  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(touchEvent: any) {
-    const e = touchEvent as 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/RNGHRootTouchHandlerCAPI.ts

@@ -1,87 +0,0 @@
-import { RNGHRootTouchHandlerArkTS } from "./RNGHRootTouchHandlerArkTS"
-import { TouchEvent as TouchEventArkTS, TouchType, TouchObject } from "./types"
-import { RNGHLogger } from "./RNGHLogger"
-
-type RawTouchPoint = {
-  contactAreaHeight: number
-  contactAreaWidth: number
-  id: number
-  nodeX: number
-  nodeY: number
-  pressedTime: number
-  pressure: number
-  rawX: number
-  rawY: number
-  screenX: number
-  screenY: number
-  tiltX: number
-  tiltY: number
-  toolHeight: number
-  toolType: number
-  toolWidth: number
-  toolX: number
-  toolY: number
-  windowX: number
-  windowY: number
-}
-
-export type RawTouchEvent = {
-  action: number,
-  actionTouch: RawTouchPoint,
-  touchPoints: RawTouchPoint[],
-  sourceType: number,
-  timestamp: number
-}
-
-class TouchEvent {
-  constructor(private raw: RawTouchEvent) {
-  }
-
-  asTouchEventArkTS(): TouchEventArkTS {
-    const touchType = this.touchTypeFromAction(this.raw.action)
-    return {
-      type: this.touchTypeFromAction(this.raw.action),
-      touches: this.raw.touchPoints.map(tp => this.touchObjectFromTouchPoint(tp, touchType)),
-      changedTouches: [this.touchObjectFromTouchPoint(this.raw.actionTouch, touchType)],
-      timestamp: this.raw.timestamp
-    }
-  }
-
-  private touchTypeFromAction(action: number): TouchType {
-    switch (action) {
-      case 1:
-        return TouchType.Down
-      case 2:
-        return TouchType.Move
-      case 3:
-        return TouchType.Up
-      default:
-        return TouchType.Cancel
-    }
-  }
-
-  private touchObjectFromTouchPoint(touchPoint: RawTouchPoint, touchType: TouchType): TouchObject {
-    return {
-      id: touchPoint.id,
-      windowX: touchPoint.windowX,
-      windowY: touchPoint.windowY,
-      x: touchPoint.windowX,
-      y: touchPoint.windowY,
-      type: touchType
-    }
-  }
-}
-
-export class RNGHRootTouchHandlerCAPI {
-  private logger: RNGHLogger
-
-  constructor(logger: RNGHLogger, private touchHandlerArkTS: RNGHRootTouchHandlerArkTS) {
-    this.logger = logger.cloneWithPrefix("RNGHRootTouchHandlerCAPI")
-  }
-
-  handleTouch(rawTouchEvent: RawTouchEvent) {
-    this.logger.cloneWithPrefix("handleTouch").debug(JSON.stringify(rawTouchEvent))
-    this.touchHandlerArkTS.handleTouch(new TouchEvent(rawTouchEvent).asTouchEventArkTS())
-  }
-}
-

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

@@ -1,38 +0,0 @@
-import { RNOHContext, RNViewBase, ComponentBuilderContext, RNComponentFactory, Tag } from "@rnoh/react-native-openharmony"
-import { RNGestureHandlerButton as RNC } from "./namespace/RNGestureHandlerButton"
-
-export type RNGestureHandlerButtonDescriptor = RNC.Descriptor
-
-@Component
-export struct RNGestureHandlerButton {
-  static readonly NAME = RNC.NAME
-  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 })
-      })
-    }
-  }
-}

package/harmony/gesture_handler/src/main/ets/RNGestureHandlerModule.ts

@@ -1,183 +0,0 @@
-import { TurboModule, TurboModuleContext, Tag } from '@rnoh/react-native-openharmony/ts';
-// import { TM } from "rnoh/generated/ts"
-import { GestureHandlerRegistry } from './GestureHandlerRegistry';
-import { GestureHandlerFactory } from "./GestureHandlerFactory"
-import { ViewRegistry } from './ViewRegistry';
-import { RNGHLogger, StandardRNGHLogger, FakeRNGHLogger } from './RNGHLogger';
-import {
-  EventDispatcher,
-  JSEventDispatcher,
-  AnimatedEventDispatcher,
-  ReanimatedEventDispatcher
-} from './EventDispatcher'
-import { RNOHScrollLockerArkTS, RNOHScrollLockerCAPI } from "./RNOHScrollLocker"
-import { State } from './State';
-import { RNGHRootTouchHandlerCAPI, RawTouchEvent } from "./RNGHRootTouchHandlerCAPI"
-import { RNGHRootTouchHandlerArkTS } from './RNGHRootTouchHandlerArkTS';
-
-export enum ActionType {
-  REANIMATED_WORKLET = 1,
-  NATIVE_ANIMATED_EVENT = 2,
-  JS_FUNCTION_OLD_API = 3,
-  JS_FUNCTION_NEW_API = 4,
-}
-
-
-export class RNGestureHandlerModule extends TurboModule {
-// implements TM.RNGestureHandlerModule.Spec {
-  static NAME = "RNGestureHandlerModule"
-
-  private gestureHandlerRegistry = new GestureHandlerRegistry()
-  private gestureHandlerFactory: GestureHandlerFactory | undefined = undefined
-  private viewRegistry: ViewRegistry | undefined = undefined
-  private logger: RNGHLogger
-  private touchHandlerByRootTag = new Map<Tag, RNGHRootTouchHandlerCAPI>()
-
-  constructor(ctx: TurboModuleContext) {
-    super(ctx)
-    const debug = false
-    this.logger = debug ? new StandardRNGHLogger(ctx.logger, "RNGH") : new FakeRNGHLogger()
-    if (this.ctx.rnInstance.getArchitecture() === "C_API") {
-      this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::TOUCH_EVENT", (e: any) => {
-        this.onTouch(e)
-      })
-      this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::ROOT_CREATED", (rootTag: any) => {
-        this.onGHRootCreated(rootTag)
-      })
-    }
-  }
-
-  private onGHRootCreated(rootTag: Tag) {
-    this.touchHandlerByRootTag.set(rootTag, new RNGHRootTouchHandlerCAPI(this.logger, new RNGHRootTouchHandlerArkTS(rootTag, this.viewRegistry, this.gestureHandlerRegistry, this.logger)));
-  }
-
-  private onTouch(e: RawTouchEvent & { rootTag: Tag }) {
-    const touchHandler = this.touchHandlerByRootTag.get(e.rootTag)
-    if (touchHandler) {
-      touchHandler.handleTouch(e);
-    } else {
-      this.logger.info(`Couldn't find touch handler for root tag: ${e.rootTag}`)
-    }
-
-  }
-
-  public install() {
-    this.viewRegistry = new ViewRegistry(this.ctx.descriptorRegistry, this.ctx.componentManagerRegistry)
-    const scrollLocker = this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new RNOHScrollLockerArkTS(this.ctx.rnInstance) : new RNOHScrollLockerCAPI(this.ctx.rnInstance);
-    this.gestureHandlerFactory = new GestureHandlerFactory(this.logger, scrollLocker)
-    return true
-  }
-
-  public createGestureHandler(
-    handlerName: string,
-    handlerTag: number,
-    config: Readonly<Record<string, unknown>>
-  ) {
-    if (!this.gestureHandlerFactory) {
-      this.ctx.logger.error("Trying to create a gesture handler before creating gesture handler factory")
-      return
-    }
-    const gestureHandler = this.gestureHandlerFactory.create(handlerName, handlerTag)
-    this.gestureHandlerRegistry.addGestureHandler(gestureHandler)
-    gestureHandler.updateGestureConfig(config)
-  }
-
-  public attachGestureHandler(
-    handlerTag: number,
-    viewTag: number,
-    actionType: ActionType
-  ) {
-    const eventDispatcher = this.createEventDispatcher(actionType, viewTag)
-    if (!eventDispatcher) {
-      this.ctx.logger.error("RNGH: Couldn't create EventDispatcher")
-      return
-    }
-    const view = this.viewRegistry.getViewByTag(viewTag)
-    if (!view) {
-      this.ctx.logger.error(`RNGH: Couldn't attachGestureHandler to view ${viewTag}`)
-      return;
-    }
-    this.gestureHandlerRegistry.bindGestureHandlerWithView(handlerTag, view)
-    this.gestureHandlerRegistry
-      .getGestureHandlerByHandlerTag(handlerTag)
-      .setEventDispatcher(eventDispatcher)
-  }
-
-  private createEventDispatcher(actionType: ActionType, viewTag: number): EventDispatcher | null {
-    switch (actionType) {
-      case ActionType.REANIMATED_WORKLET:
-        return new ReanimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('ReanimatedEventDispatcher'), viewTag)
-      case ActionType.NATIVE_ANIMATED_EVENT:
-        return new AnimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('AnimatedEventDispatcher'), viewTag)
-      case ActionType.JS_FUNCTION_OLD_API:
-      case ActionType.JS_FUNCTION_NEW_API:
-        return new JSEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('JSEventDispatcher'));
-    }
-  }
-
-  public updateGestureHandler(
-    handlerTag: number,
-    newConfig: Readonly<Record<string, unknown>>
-  ) {
-    const gestureHandler = this.gestureHandlerRegistry.getGestureHandlerByHandlerTag(handlerTag)
-    gestureHandler.updateGestureConfig(newConfig)
-  }
-
-  public dropGestureHandler(handlerTag: number) {
-    this.warn("dropGestureHandler is not implemented")
-  }
-
-  public handleSetJSResponder(tag: number, blockNativeResponder: boolean) {
-    this.warn("handleSetJSResponder is not implemented")
-  }
-
-  public handleClearJSResponder() {
-    this.warn("handleClearJSResponder is not implemented")
-  }
-
-  public flushOperations() {
-    this.warn("flushOperations is not implemented")
-  }
-
-  // -------------------------------------------------------------------------------------------------------------------
-  protected warn(message: string) {
-    this.ctx.logger.warn("RNGH: " + message)
-  }
-
-  public getGestureHandlerRegistry() {
-    return this.gestureHandlerRegistry
-  }
-
-  public getLogger() {
-    return this.logger
-  }
-
-  public getViewRegistry() {
-    if (!this.viewRegistry) {
-      this.logger.info("Tried to get viewRegistry before it was initialized")
-      throw new Error("Tried to get viewRegistry before it was initialized")
-    }
-    return this.viewRegistry
-  }
-
-  public setGestureHandlerState(handlerTag: number, newState: State) {
-    const handler = this.getGestureHandlerRegistry().getGestureHandlerByHandlerTag(handlerTag);
-    switch (newState) {
-      case State.ACTIVE:
-        handler.activate();
-        break;
-      case State.BEGAN:
-        handler.begin();
-        break;
-      case State.END:
-        handler.end();
-        break;
-      case State.FAILED:
-        handler.fail();
-        break;
-      case State.CANCELLED:
-        handler.cancel();
-        break;
-    }
-  }
-}