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

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

@@ -1,203 +0,0 @@
-import { Point } from "@rnoh/react-native-openharmony/ts"
-import { GestureHandler } from "./GestureHandler"
-import { AdaptedEvent, EventType, PointerType, TouchEventType, Touch } from "./Event"
-import { View } from "./View"
-import { RNGHLogger } from "./RNGHLogger"
-import { TouchEvent, TouchType, TouchObject } from "./types"
-
-export class GestureHandlerArkUIAdapter {
-  private activePointerIds = new Set<number>()
-  private pointersIdInBounds = new Set<number>()
-  private gestureHandler: GestureHandler
-  private view: View
-  private logger: RNGHLogger
-
-  constructor(gestureHandler: GestureHandler, view: View, logger: RNGHLogger) {
-    logger.info("constructor")
-    this.gestureHandler = gestureHandler
-    this.view = view
-    this.logger = logger
-  }
-
-  handleTouch(e: TouchEvent) {
-    for (const changedTouch of e.changedTouches) {
-      if (this.shouldSkipTouch(changedTouch)) continue;
-      const wasInBounds = this.pointersIdInBounds.has(changedTouch.id)
-      const isInBounds = this.isInBounds({ x: changedTouch.windowX, y: changedTouch.windowY })
-      this.logger.info(`handleTouch: ${JSON.stringify({ type: changedTouch.type, wasInBounds, isInBounds })}`)
-      const adaptedEvent = this.adaptTouchEvent(e, changedTouch)
-      switch (adaptedEvent.eventType) {
-        case EventType.DOWN:
-          this.gestureHandler.onPointerDown(adaptedEvent)
-          break;
-        case EventType.ADDITIONAL_POINTER_DOWN:
-          this.gestureHandler.onAdditionalPointerAdd(adaptedEvent)
-          break;
-        case EventType.UP:
-          this.gestureHandler.onPointerUp(adaptedEvent)
-          break;
-        case EventType.ADDITIONAL_POINTER_UP:
-          this.gestureHandler.onAdditionalPointerRemove(adaptedEvent)
-          break;
-        case EventType.MOVE:
-          if (!wasInBounds && !isInBounds)
-            this.gestureHandler.onPointerOutOfBounds(adaptedEvent)
-          else
-            this.gestureHandler.onPointerMove(adaptedEvent)
-          break;
-        case EventType.ENTER:
-          this.gestureHandler.onPointerEnter(adaptedEvent)
-          break;
-        case EventType.OUT:
-          this.gestureHandler.onPointerOut(adaptedEvent)
-          break;
-        case EventType.CANCEL:
-          this.gestureHandler.onPointerCancel(adaptedEvent)
-          break;
-      }
-    }
-  }
-
-  private shouldSkipTouch(changedTouch: TouchObject): boolean {
-    return changedTouch.type === TouchType.Down && !this.isInBounds({
-      x: changedTouch.windowX,
-      y: changedTouch.windowY
-    })
-  }
-
-  private adaptTouchEvent(e: TouchEvent, changedTouch: TouchObject): AdaptedEvent {
-    const xAbsolute = changedTouch.windowX
-    const yAbsolute = changedTouch.windowY
-
-    const eventType = this.mapTouchTypeToEventType(
-      changedTouch.type,
-      this.activePointerIds.size,
-      this.isInBounds({ x: xAbsolute, y: yAbsolute }),
-      this.pointersIdInBounds.has(changedTouch.id)
-    )
-    this.updateIsInBoundsByPointerId(
-      changedTouch.type,
-      changedTouch.id,
-      xAbsolute,
-      yAbsolute
-    )
-    this.updateActivePointers(changedTouch.type, changedTouch.id)
-    return {
-      x: xAbsolute,
-      y: yAbsolute,
-      offsetX: xAbsolute - this.view.getBoundingRect().x,
-      offsetY: yAbsolute - this.view.getBoundingRect().y,
-      pointerId: changedTouch.id,
-      eventType: eventType,
-      pointerType: PointerType.TOUCH,
-      buttons: 0,
-      time: e.timestamp,
-      allTouches: e.touches.map((touch) => this.mapTouchObjectToTouch(touch)),
-      changedTouches: e.changedTouches.map((touch) => this.mapTouchObjectToTouch(touch)),
-      touchEventType: this.mapTouchTypeToTouchEventType(changedTouch.type)
-    }
-  }
-
-  private updateIsInBoundsByPointerId(
-    touchType: TouchType,
-    pointerId: number,
-    x: number,
-    y: number
-  ) {
-    switch (touchType) {
-      case TouchType.Down:
-        if (this.isInBounds({ x, y }))
-          this.pointersIdInBounds.add(pointerId)
-        break;
-      case TouchType.Move:
-        if (this.isInBounds({ x, y }))
-          this.pointersIdInBounds.add(pointerId)
-        else
-          this.pointersIdInBounds.delete(pointerId)
-        break;
-      case TouchType.Up:
-        this.pointersIdInBounds.delete(pointerId)
-        break;
-      case TouchType.Cancel:
-        this.pointersIdInBounds.delete(pointerId)
-        break;
-    }
-  }
-
-  private isInBounds(point: Point): boolean {
-    const x = point.x
-    const y = point.y
-    const rect = this.view.getBoundingRect()
-    const result = x >= rect.x && x <= (rect.x + rect.width) && y >= rect.y && y <= (rect.y + rect.height)
-    return result;
-  }
-
-  private updateActivePointers(touchType: TouchType, pointerId: number): void {
-    switch (touchType) {
-      case TouchType.Down:
-        this.activePointerIds.add(pointerId)
-      case TouchType.Up:
-        this.activePointerIds.delete(pointerId)
-      case TouchType.Cancel:
-        this.activePointerIds.clear()
-      default:
-        return
-    }
-  }
-
-  private mapTouchObjectToTouch(touchObject: TouchObject): Touch {
-    return {
-      id: touchObject.id,
-      x: touchObject.x,
-      y: touchObject.y,
-      absoluteX: touchObject.windowX,
-      absoluteY: touchObject.windowY
-    }
-  }
-
-  private mapTouchTypeToEventType(
-    touchType: TouchType,
-    activePointersCounter: number,
-    isCurrentlyInBounds: boolean,
-    wasInBounds: boolean
-  ): EventType {
-    switch (touchType) {
-      case TouchType.Down:
-        if (activePointersCounter > 0)
-          return EventType.ADDITIONAL_POINTER_DOWN
-        else
-          return EventType.DOWN
-      case TouchType.Up:
-        if (activePointersCounter > 1)
-          return EventType.ADDITIONAL_POINTER_UP
-        else
-          return EventType.UP
-      case TouchType.Move:
-        if (isCurrentlyInBounds) {
-          return wasInBounds ? EventType.MOVE : EventType.ENTER
-        } else {
-          return wasInBounds ? EventType.OUT : EventType.MOVE
-        }
-      case TouchType.Cancel:
-        return EventType.CANCEL
-      default:
-        console.error("RNGH", "Unknown touchType:", touchType)
-        throw new Error("Unknown touchType")
-    }
-  }
-
-  private mapTouchTypeToTouchEventType(touchType: TouchType): TouchEventType {
-    switch (touchType) {
-      case TouchType.Down:
-        return TouchEventType.DOWN
-      case TouchType.Up:
-        return TouchEventType.UP
-      case TouchType.Move:
-        return TouchEventType.MOVE
-      case TouchType.Cancel:
-        return TouchEventType.CANCELLED
-      default:
-        return TouchEventType.UNDETERMINED
-    }
-  }
-}

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

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

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

@@ -1,28 +0,0 @@
-import { GestureHandler } from "./GestureHandler"
-import { View } from "./View"
-
-export class GestureHandlerRegistry {
-  private gestureHandlerByHandlerTag: Map<number, GestureHandler> = new Map()
-  private gestureHandlersByViewTag: Map<number, Set<GestureHandler>> = new Map()
-
-  public addGestureHandler(gestureHandler: GestureHandler) {
-    this.gestureHandlerByHandlerTag.set(gestureHandler.getTag(), gestureHandler)
-  }
-
-  public bindGestureHandlerWithView(gestureHandlerTag: number, view: View) {
-    const viewTag = view.getTag()
-    if (!this.gestureHandlersByViewTag.has(viewTag))
-      this.gestureHandlersByViewTag.set(viewTag, new Set())
-    const gestureHandler = this.gestureHandlerByHandlerTag.get(gestureHandlerTag)
-    this.gestureHandlersByViewTag.get(viewTag).add(gestureHandler)
-    gestureHandler.onViewAttached(view)
-  }
-
-  public getGestureHandlersByViewTag(viewTag: number): GestureHandler[] {
-    return Array.from(this.gestureHandlersByViewTag.get(viewTag) ?? [])
-  }
-
-  public getGestureHandlerByHandlerTag(handlerTag: number): GestureHandler {
-    return this.gestureHandlerByHandlerTag.get(handlerTag)
-  }
-}

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

@@ -1,109 +0,0 @@
-import { GestureHandler, Handler, GestureConfig as Config } from "./GestureHandler"
-
-export class InteractionManager {
-  private readonly waitForRelations: Map<number, number[]> = new Map()
-  private readonly simultaneousRelations: Map<number, number[]> = new Map()
-
-  public configureInteractions(handler: GestureHandler, config: Config) {
-    this.dropRelationsForHandlerWithTag(handler.getTag());
-
-    if (config.waitFor) {
-      const waitFor: number[] = [];
-      config.waitFor.forEach((otherHandler: Handler): void => {
-        // New API reference
-        if (typeof otherHandler === 'number') {
-          waitFor.push(otherHandler);
-        } else {
-          // Old API reference
-          waitFor.push(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);
-    }
-  }
-
-  public shouldWaitForHandlerFailure(
-    handler: GestureHandler,
-    otherHandler: GestureHandler
-  ): boolean {
-    const waitFor: number[] | undefined = this.waitForRelations.get(
-      handler.getTag()
-    );
-    if (!waitFor) {
-      return false;
-    }
-
-    let shouldWait = false;
-
-    waitFor.forEach((tag: number): void => {
-      if (tag === otherHandler.getTag()) {
-        shouldWait = true;
-        return; //Returns from callback
-      }
-    });
-
-    return shouldWait;
-  }
-
-  public shouldRecognizeSimultaneously(
-    handler: GestureHandler,
-    otherHandler: GestureHandler
-  ): boolean {
-    const simultaneousHandlers: number[] | undefined =
-    this.simultaneousRelations.get(handler.getTag());
-    if (!simultaneousHandlers) {
-      return false;
-    }
-
-    let shouldRecognizeSimultaneously = false;
-
-    simultaneousHandlers.forEach((tag: number): void => {
-      if (tag === otherHandler.getTag()) {
-        shouldRecognizeSimultaneously = true;
-        return;
-      }
-    });
-
-    return shouldRecognizeSimultaneously;
-  }
-
-  public shouldRequireHandlerToWaitForFailure(
-    _handler: GestureHandler,
-    _otherHandler: GestureHandler
-  ): boolean {
-    //TODO: Implement logic
-    return false;
-  }
-
-  public shouldHandlerBeCancelledBy(
-    _handler: GestureHandler,
-    _otherHandler: GestureHandler
-  ): boolean {
-    //TODO: Implement logic
-    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/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/RNOHScrollLocker.ts

@@ -1,23 +0,0 @@
-import { RNInstance } from "@rnoh/react-native-openharmony/ts"
-import { ScrollLocker } from "./GestureHandler"
-
-export class RNOHScrollLockerArkTS implements ScrollLocker {
-  constructor(private rnInstance: RNInstance) {
-  }
-
-  lockScrollContainingViewTag(viewTag: number) {
-    return this.rnInstance.blockComponentsGestures(viewTag)
-  }
-}
-
-export class RNOHScrollLockerCAPI implements ScrollLocker {
-  constructor(private rnInstance: RNInstance) {
-  }
-
-  lockScrollContainingViewTag(viewTag: number) {
-    this.rnInstance.postMessageToCpp("RNGH::SET_NATIVE_RESPONDERS_BLOCK", { targetTag: viewTag, shouldBlock: true });
-    return () => {
-      this.rnInstance.postMessageToCpp("RNGH::SET_NATIVE_RESPONDERS_BLOCK", { targetTag: viewTag, shouldBlock: false });
-    }
-  }
-}

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

@@ -1,36 +0,0 @@
-export class Vector2D {
-  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;
-  }
-}