@react-native-oh-tpl/react-native-gesture-handler 2.14.15 → 2.14.17-rc.0

package/harmony/gesture_handler/src/main/ets/rnoh/RNGHRootViewController.ts

@@ -1,196 +0,0 @@
-import { TouchEvent as TouchEventArkTS, TouchType, TouchObject } from './types';
-import { RNGHLogger, View, Multiset, GestureHandlerRegistry } from '../core';
-import { RawTouchableView, RNGHView } from "./RNGHView"
-import { RNGHViewController } from './RNGHViewController';
-
-type RawTouchPoint = {
-  pointerId: number;
-  windowX: number;
-  windowY: number;
-};
-
-export type RawTouchEvent = {
-  action: number;
-  actionTouch: RawTouchPoint;
-  touchPoints: RawTouchPoint[];
-  sourceType: number;
-  timestamp: number;
-  /** TouchableViews is a list of views from the root to the leaf which contain within their boundaries the touch point specified by `actionTouch`. */
-  touchableViews: RawTouchableView[]
-};
-
-
-const areRawTouchPointsEqual = (a: RawTouchPoint, b: RawTouchPoint) =>
-a.pointerId === b.pointerId &&
-  a.windowX === b.windowX &&
-  a.windowY === b.windowY;
-
-
-export class RNGHRootViewController {
-  private logger: RNGHLogger;
-  // This multiset keeps track of touchable views that were detected
-  // at the beginning of the gesture to ensure they aren't overridden
-  // during move touch events, which could prevent the gesture handler
-  // from updating its state correctly.
-  private touchableViewsMultiset: Multiset<View> = new Multiset();
-  private viewControllerByViewTag: Map<number, RNGHViewController> =
-    new Map(); // TODO: remove entry when view is removed
-  /**
-   * A view is ACTIVE, if it recently received POINTER_DOWN event
-   */
-  private activeViewTags = new Set<number>();
-
-  constructor(
-    logger: RNGHLogger,
-    private gestureHandlerRegistry: GestureHandlerRegistry
-  ) {
-    this.logger = logger.cloneAndJoinPrefix('RNGHRootTouchHandlerCAPI');
-  }
-
-  handleTouch(rawTouchEvent: RawTouchEvent, touchableViews: View[]) {
-    /**
-     * NOTE: TouchEventArkTS was used in ArkTS RNOH architecture. Currently only C-API architecture is supported.
-     */
-    const touchEvent = rawTouchEventToTouchEventArkTS(rawTouchEvent);
-    if (touchEvent.type === TouchType.Down) {
-      touchableViews.forEach(view => this.touchableViewsMultiset.add(view));
-    }
-    const e = touchEvent;
-    if (e.type === TouchType.Down) {
-      this.activeViewTags.clear();
-    }
-    const views = touchableViews as RNGHView[]
-    for (let i = 0; i < views.length; i++) {
-      const view = views[i];
-      for (const handler of this.gestureHandlerRegistry.getGestureHandlersByViewTag(
-        view.getTag(),
-      )) {
-        this.logger.info(
-          `Found GestureHandler ${handler.getTag()} for view ${view.getTag()}`,
-        );
-
-        // create view touch handler if necessary
-        if (!this.viewControllerByViewTag.has(view.getTag())) {
-          this.viewControllerByViewTag.set(
-            view.getTag(),
-            new RNGHViewController(
-              view,
-              this.logger,
-            ),
-          );
-        }
-
-        // attach handler (there might be multiple handlers per view)
-        this.viewControllerByViewTag.get(view.getTag())!.attachGestureHandler(handler) // TODO: detachGestureHandler
-
-        // register active view tag
-        if (e.type === TouchType.Down) {
-          this.activeViewTags.add(view.getTag());
-        }
-      }
-
-      // If the pointer is inside the view but it overflows its parent, handlers attached to the parent
-      // might not have been called correctly (wrong bounding box). Extending the parent bounding box 
-      // with the child bounding box ensures that the parent handlers are called correctly.
-      // This approach is slightly different from Android RNGH implementation (extracting parent gesture handlers), 
-      // however, the outcome is the same.
-      for (let j = i; j > 1; j--) {
-        const currentView = views[j];
-        const parentView = views[j-1];
-        if (parentView.intersectsWith(currentView)) {
-          parentView.attachChildrenBoundingRects(currentView);
-        }
-      }
-    }
-
-    // send touch to gesture handlers, prioritize handling touch events for child components
-    if (this.activeViewTags.size > 0) {
-      const tags = Array.from(this.activeViewTags);
-      for (let i = tags.length - 1; i >= 0; i--) {
-        const tag = tags[i];
-        const viewController = this.viewControllerByViewTag.get(tag);
-        if (viewController) {
-          viewController.handleTouch(e);
-        }
-      }
-    }
-
-
-    if (touchEvent.type === TouchType.Up || touchEvent.type === TouchType.Cancel) {
-      touchableViews.forEach(view => this.touchableViewsMultiset.remove(view));
-    }
-  }
-
-  cancelTouches() {
-    for (const activeViewTag of this.activeViewTags) {
-      this.gestureHandlerRegistry.getGestureHandlersByViewTag(activeViewTag).forEach(gh => {
-        gh.cancel()
-        gh.reset()
-      })
-    }
-  }
-}
-
-
-const CACHED_RAW_TOUCH_POINT_BY_POINTER_ID = new Map<number, RawTouchPoint>();
-let LAST_CHANGED_POINTER_ID: number | null = null;
-const MAX_CACHE_SIZE = 10;
-
-function rawTouchEventToTouchEventArkTS(raw: RawTouchEvent): TouchEventArkTS {
-  const touchType = touchTypeFromAction(raw.action);
-  const actionTouch = raw.actionTouch;
-
-  let lastChangedTouch: RawTouchPoint = actionTouch;
-  if (CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.has(actionTouch.pointerId)) {
-    if (!areRawTouchPointsEqual(actionTouch,
-      CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.get(actionTouch.pointerId) as RawTouchPoint)) {
-      LAST_CHANGED_POINTER_ID = actionTouch.pointerId;
-      CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.set(actionTouch.pointerId, actionTouch);
-    }
-  } else {
-    // remove first element if the cache is full
-    if (CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.size >= MAX_CACHE_SIZE) {
-      CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.delete(CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.keys().next().value);
-    }
-    LAST_CHANGED_POINTER_ID = actionTouch.pointerId;
-    CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.set(actionTouch.pointerId, actionTouch);
-  }
-  lastChangedTouch = CACHED_RAW_TOUCH_POINT_BY_POINTER_ID.get(LAST_CHANGED_POINTER_ID as number) as RawTouchPoint
-  return {
-    type: touchTypeFromAction(raw.action),
-    touches: raw.touchPoints.map(tp =>
-    touchObjectFromTouchPoint(tp, touchType),
-    ),
-    changedTouches: [
-      touchObjectFromTouchPoint(lastChangedTouch, touchType),
-    ],
-    timestamp: raw.timestamp / Math.pow(10, 6),
-  };
-}
-
-function 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;
-  }
-}
-
-function touchObjectFromTouchPoint(
-  touchPoint: RawTouchPoint,
-  touchType: TouchType,
-): TouchObject {
-  return {
-    id: touchPoint.pointerId,
-    windowX: touchPoint.windowX,
-    windowY: touchPoint.windowY,
-    x: touchPoint.windowX,
-    y: touchPoint.windowY,
-    type: touchType,
-  };
-}

package/harmony/gesture_handler/src/main/ets/rnoh/RNGHView.ts

@@ -1,85 +0,0 @@
-import { View, BoundingBox } from "../core"
-
-
-export type RawTouchableView = {
-  tag: number,
-  /**
-   * Relative to application window.
-   */
-  x: number,
-  /**
-   * Relative to application window.
-   */
-  y: number,
-  width: number,
-  height: number,
-  buttonRole: boolean,
-}
-
-export class RNGHView implements View {
-  private tag: number
-  private buttonRole: boolean
-  private boundingBox: BoundingBox
-  private childrenBoundingBoxes: Set<BoundingBox> = new Set()
-
-  constructor({ tag, buttonRole, ...boundingBox }: RawTouchableView) {
-    this.tag = tag
-    this.buttonRole = buttonRole
-    this.boundingBox = boundingBox
-  }
-
-  getTag(): number {
-    return this.tag
-  }
-
-  getBoundingRect(): BoundingBox {
-    return { ...this.boundingBox }
-  }
-
-  getChildrenBoundingRects(): BoundingBox[] {
-    return Array.from(this.childrenBoundingBoxes)
-  }
-
-  isPositionInBounds({ x, y }: {
-    x: number;
-    y: number
-  }): boolean {
-    const rects = [this.boundingBox, ...this.childrenBoundingBoxes]
-    return rects.some(rect => (
-      x >= rect.x &&
-        x <= rect.x + rect.width &&
-        y >= rect.y &&
-        y <= rect.y + rect.height
-    ))
-  }
-
-  updateBoundingBox(boundingBox: BoundingBox) {
-    this.boundingBox = boundingBox
-  }
-
-  attachChildrenBoundingRects(view: RNGHView) {
-    this.childrenBoundingBoxes.add(view.getBoundingRect())
-    for (const childBoundingBox of view.getChildrenBoundingRects()) {
-      this.childrenBoundingBoxes.add(childBoundingBox)
-    }
-  }
-
-  intersectsWith(view: RNGHView): boolean {
-    const rect1 = this.getBoundingRect()
-    const rect2 = view.getBoundingRect()
-    return (
-      rect1.x < rect2.x + rect2.width &&
-      rect1.x + rect1.width > rect2.x &&
-      rect1.y < rect2.y + rect2.height &&
-      rect1.y + rect1.height > rect2.y
-    )
-  }
-
-  setButtonRole(buttonRole: boolean) {
-    this.buttonRole = buttonRole
-  }
-
-  hasButtonRole(): boolean {
-    return this.buttonRole
-  }
-}

package/harmony/gesture_handler/src/main/ets/rnoh/RNGHViewController.ts

@@ -1,255 +0,0 @@
-import { Point } from '@rnoh/react-native-openharmony/ts';
-import {
-  GestureHandler,
-  IncomingEvent,
-  EventType,
-  PointerType,
-  TouchEventType,
-  Touch,
-  RNGHLogger,
-  View
-} from '../core';
-import { TouchEvent, TouchType, TouchObject } from './types';
-
-
-export class RNGHViewController {
-  private activePointerIds = new Set<number>();
-  private pointerIdsInBounds = new Set<number>();
-  private gestureHandlers = new Set<GestureHandler>();
-  private view: View;
-  private logger: RNGHLogger;
-
-  constructor(view: View, logger: RNGHLogger) {
-    this.logger = logger.cloneAndJoinPrefix(`RNGHViewTouchHandler`)
-    this.view = view;
-  }
-
-  attachGestureHandler(gestureHandler: GestureHandler) {
-    this.gestureHandlers.add(gestureHandler)
-  }
-
-  handleTouch(e: TouchEvent) {
-    const logger = this.logger.cloneAndJoinPrefix("handleTouch")
-    for (const changedTouch of e.changedTouches) {
-      if (this.shouldSkipTouch(changedTouch)) {
-        continue;
-      }
-      const wasInBounds = this.pointerIdsInBounds.has(changedTouch.id);
-      const isInBounds = this.isInBounds({
-        x: changedTouch.windowX,
-        y: changedTouch.windowY,
-      });
-      logger.debug(
-        {
-          viewTag: this.view.getTag(),
-          type: changedTouch.type,
-          wasInBounds,
-          isInBounds,
-        },
-      );
-      const adaptedEvent = this.adaptTouchEvent(e, changedTouch);
-      this.gestureHandlers.forEach(gh => {
-        switch (adaptedEvent.eventType) {
-          case EventType.DOWN:
-            gh.onPointerDown(adaptedEvent);
-            break;
-          case EventType.ADDITIONAL_POINTER_DOWN:
-            gh.onAdditionalPointerAdd(adaptedEvent);
-            break;
-          case EventType.UP:
-            gh.onPointerUp(adaptedEvent);
-            break;
-          case EventType.ADDITIONAL_POINTER_UP:
-            gh.onAdditionalPointerRemove(adaptedEvent);
-            break;
-          case EventType.MOVE:
-            if (!wasInBounds && !isInBounds) {
-              gh.onPointerOutOfBounds(adaptedEvent);
-            } else {
-              gh.onPointerMove(adaptedEvent);
-            }
-            break;
-          case EventType.ENTER:
-            gh.onPointerEnter(adaptedEvent);
-            break;
-          case EventType.OUT:
-            gh.onPointerOut(adaptedEvent);
-            break;
-          case EventType.CANCEL:
-            gh.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,
-  ): IncomingEvent {
-    const xAbsolute = changedTouch.windowX;
-    const yAbsolute = changedTouch.windowY;
-
-    const eventType = this.mapTouchTypeToEventType(
-      changedTouch.type,
-      this.isInBounds({ x: xAbsolute, y: yAbsolute }),
-      changedTouch.id,
-      this.pointerIdsInBounds.has(changedTouch.id),
-    );
-    this.logger.cloneAndJoinPrefix("adaptTouchEvent")
-      .debug({ eventType, activePointersCount: this.activePointerIds.size })
-    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.pointerIdsInBounds.add(pointerId);
-        }
-        break;
-      case TouchType.Move:
-        if (this.isInBounds({
-          x,
-          y
-        })) {
-          this.pointerIdsInBounds.add(pointerId);
-        } else {
-          this.pointerIdsInBounds.delete(pointerId);
-        }
-        break;
-      case TouchType.Up:
-        this.pointerIdsInBounds.delete(pointerId);
-        break;
-      case TouchType.Cancel:
-        this.pointerIdsInBounds.delete(pointerId);
-        break;
-    }
-  }
-
-  private isInBounds(point: Point): boolean {
-    const rect = this.view.getBoundingRect();
-    this.logger.cloneAndJoinPrefix("isInBounds").debug({ rect })
-    return this.view.isPositionInBounds(point);
-  }
-
-  private updateActivePointers(touchType: TouchType, pointerId: number): void {
-    switch (touchType) {
-      case TouchType.Down:
-        this.activePointerIds.add(pointerId);
-        break;
-      case TouchType.Up:
-        this.activePointerIds.delete(pointerId);
-        break;
-      case TouchType.Cancel:
-        this.activePointerIds.clear();
-        break;
-      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,
-    isCurrentlyInBounds: boolean,
-    pointerId: number,
-    wasInBounds: boolean,
-  ): EventType {
-    /**
-     * If user manages to drag finger out of GestureHandlerRootView,
-     * we don't receive UP event.
-     */
-    let activePointersCount = this.activePointerIds.size
-    if (this.activePointerIds.has(pointerId)) {
-      activePointersCount--;
-    }
-
-    switch (touchType) {
-      case TouchType.Down:
-        if (activePointersCount > 0) {
-          return EventType.ADDITIONAL_POINTER_DOWN;
-        } else {
-          return EventType.DOWN;
-        }
-      case TouchType.Up:
-        if (activePointersCount > 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/rnoh/RNGHViewRegistry.ts

@@ -1,19 +0,0 @@
-import { Tag, } from '@rnoh/react-native-openharmony/ts';
-import { View, ViewRegistry } from '../core';
-
-
-export class RNGHViewRegistry implements ViewRegistry {
-  private viewByTag = new Map<Tag, View>()
-
-  save(view: View) {
-    this.viewByTag.set(view.getTag(), view)
-  }
-
-  deleteByTag(viewTag: Tag) {
-    this.viewByTag.delete(viewTag)
-  }
-
-  getViewByTag(viewTag: Tag) {
-    return this.viewByTag.get(viewTag);
-  }
-}