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

package/harmony/gesture_handler/src/main/ets/gesture-handlers/LongPressGestureHandler.ts

@@ -0,0 +1,127 @@
+import { GestureHandler, IncomingEvent, GestureConfig, State, GestureHandlerDependencies } from '../core';
+
+const DEFAULT_MIN_DURATION_MS = 500;
+const DEFAULT_MAX_DIST_DP = 10;
+const SCALING_FACTOR = 10;
+
+export class LongPressGestureHandler extends GestureHandler {
+  private minDurationMs = DEFAULT_MIN_DURATION_MS;
+  private defaultMaxDistSq = DEFAULT_MAX_DIST_DP * SCALING_FACTOR;
+
+  private maxDistSq = this.defaultMaxDistSq;
+  private startX = 0;
+  private startY = 0;
+
+  private startTime = 0;
+  private previousTime = 0;
+
+  private activationTimeout: number | undefined;
+
+  constructor(deps: GestureHandlerDependencies) {
+    super({...deps, logger: deps.logger.cloneWithPrefix("LongPressGestureHandler")})
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  protected transformNativeEvent() {
+    return {
+      ...super.transformNativeEvent(),
+      duration: Date.now() - this.startTime,
+    };
+  }
+
+  public updateGestureConfig({ enabled = true, ...props }: GestureConfig): void {
+    super.updateGestureConfig({ enabled: enabled, ...props });
+
+    if (this.config.minDurationMs !== undefined) {
+      this.minDurationMs = this.config.minDurationMs;
+    }
+
+    if (this.config.maxDist !== undefined) {
+      this.maxDistSq = this.config.maxDist * this.config.maxDist;
+    }
+  }
+
+
+
+  protected resetConfig(): void {
+    super.resetConfig();
+    this.minDurationMs = DEFAULT_MIN_DURATION_MS;
+    this.maxDistSq = this.defaultMaxDistSq;
+  }
+
+  protected onStateChange(newState: State, oldState: State): void {
+    super.onStateChange(newState, oldState)
+    clearTimeout(this.activationTimeout);
+  }
+
+  public onPointerDown(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.tryBegin(event);
+    this.tryActivate();
+    this.checkDistanceFail(event);
+  }
+
+  public onPointerMove(event: IncomingEvent): void {
+    super.onPointerMove(event);
+    this.tracker.track(event);
+    this.checkDistanceFail(event);
+  }
+
+  public onPointerUp(event: IncomingEvent): void {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+
+    if (this.currentState === State.ACTIVE) {
+      this.end();
+    } else {
+      this.fail();
+    }
+  }
+
+  private tryBegin(event: IncomingEvent): void {
+    if (this.currentState !== State.UNDETERMINED) {
+      return;
+    }
+
+    this.previousTime = Date.now();
+    this.startTime = this.previousTime;
+
+    this.begin();
+
+    this.startX = event.x;
+    this.startY = event.y;
+  }
+
+  private tryActivate(): void {
+    if (this.minDurationMs > 0) {
+      if (this.activationTimeout) {
+        clearTimeout(this.activationTimeout)
+      }
+      this.activationTimeout = setTimeout(() => {
+        this.activate();
+      }, this.minDurationMs);
+    } else if (this.minDurationMs === 0) {
+      this.activate();
+    }
+  }
+
+  private checkDistanceFail(event: IncomingEvent): void {
+    const dx = event.x - this.startX;
+    const dy = event.y - this.startY;
+    const distSq = dx * dx + dy * dy;
+
+    if (distSq <= this.maxDistSq) {
+      return;
+    }
+
+    if (this.currentState === State.ACTIVE) {
+      this.cancel();
+    } else {
+      this.fail();
+    }
+  }
+}

package/harmony/gesture_handler/src/main/ets/gesture-handlers/ManualGestureHandler.ts

@@ -0,0 +1,42 @@
+import { GestureHandler, GestureHandlerDependencies, IncomingEvent } from '../core';
+
+export class ManualGestureHandler extends GestureHandler {
+  constructor(deps: GestureHandlerDependencies) {
+    super({...deps, logger: deps.logger.cloneWithPrefix("ManualGestureHandler")})
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  public onPointerDown(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onPointerDown(event);
+    this.begin();
+  }
+
+  public onAdditionalPointerAdd(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onAdditionalPointerAdd(event);
+  }
+
+  public onPointerMove(event: IncomingEvent): void {
+    this.tracker.track(event);
+    super.onPointerMove(event);
+  }
+
+  public onPointerOutOfBounds(event: IncomingEvent): void {
+    this.tracker.track(event);
+    super.onPointerOutOfBounds(event);
+  }
+
+  public onPointerUp(event: IncomingEvent): void {
+    super.onPointerUp(event);
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+
+  public onAdditionalPointerRemove(event: IncomingEvent): void {
+    super.onAdditionalPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+  }
+}

package/harmony/gesture_handler/src/main/ets/gesture-handlers/NativeViewGestureHandler.ts

@@ -0,0 +1,115 @@
+import { GestureHandler, GestureHandlerDependencies, DEFAULT_TOUCH_SLOP, Vector2D, State, IncomingEvent } from "../core"
+
+
+export class NativeViewGestureHandler extends GestureHandler {
+  private minDistSq = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
+
+  protected startPos = new Vector2D()
+
+  public canBeInterrupted() {
+    return !(this.config.disallowInterruption ?? false)
+  }
+
+  constructor(deps: GestureHandlerDependencies) {
+    super({ ...deps, logger: deps.logger.cloneWithPrefix("NativeViewGestureHandler") })
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  public onPointerDown(e: IncomingEvent) {
+    this.tracker.addToTracker(e);
+    super.onPointerDown(e);
+    this.onNewPointer();
+  }
+
+  protected onNewPointer() {
+    this.startPos = this.tracker.getLastAvgPos();
+    if (this.currentState !== State.UNDETERMINED)
+      return;
+    this.begin();
+    if(this.view.hasButtonRole()) {
+      this.activate();
+    }
+  }
+
+  public onAdditionalPointerAdd(e: IncomingEvent) {
+    this.tracker.addToTracker(e);
+    super.onPointerDown(e);
+    this.onNewPointer();
+  }
+
+  public onPointerMove(e: IncomingEvent): void {
+    this.tracker.track(e);
+    const {x: dx, y: dy} = this.startPos.clone().subtract(this.tracker.getLastAvgPos()).value
+    const distSq = dx * dx + dy * dy;
+
+    if (distSq >= this.minDistSq) {
+      if (this.view.hasButtonRole() && this.currentState === State.ACTIVE) {
+        this.cancel();
+      } else if (!this.view.hasButtonRole() && this.currentState === State.BEGAN) {
+        this.activate();
+      }
+    }
+  }
+
+  public onPointerLeave(): void {
+    // TODO: add this method to GestureHandler
+    if (this.currentState === State.BEGAN || this.currentState === State.ACTIVE) {
+      this.cancel();
+    }
+  }
+
+  public onPointerUp(event: IncomingEvent): void {
+    super.onPointerUp(event);
+    this.onAnyPointerUp(event);
+  }
+
+  private onAnyPointerUp(e: IncomingEvent) {
+    this.tracker.removeFromTracker(e.pointerId);
+    if (this.tracker.getTrackedPointersCount() === 0) {
+      if (this.currentState === State.ACTIVE) {
+        this.end();
+      } else {
+        this.fail();
+      }
+    }
+  }
+
+  public onAdditionalPointerRemove(e: IncomingEvent) {
+    super.onAdditionalPointerRemove(e)
+    this.onAnyPointerUp(e)
+  }
+
+  public shouldRecognizeSimultaneously(handler: GestureHandler): boolean {
+    if (super.shouldRecognizeSimultaneously(handler)) {
+      return true;
+    }
+    if (
+      handler instanceof NativeViewGestureHandler &&
+        handler.getState() === State.ACTIVE &&
+        !handler.canBeInterrupted()
+    ) {
+      return false;
+    }
+
+    if (
+      this.currentState === State.ACTIVE &&
+        handler.getState() === State.ACTIVE &&
+      this.canBeInterrupted()
+    ) {
+      return false;
+    }
+
+    return (
+      this.currentState === State.ACTIVE &&
+      this.canBeInterrupted() &&
+        handler.getTag() > 0
+    );
+  }
+
+  public shouldBeCancelledByOther(_handler: GestureHandler): boolean {
+    return this.canBeInterrupted();
+  }
+}

package/harmony/gesture_handler/src/main/ets/gesture-handlers/PanGestureHandler.ts

@@ -0,0 +1,342 @@
+import {
+  GestureHandler,
+  GestureConfig,
+  GestureHandlerDependencies,
+  DEFAULT_TOUCH_SLOP,
+  IncomingEvent,
+  State,
+  Vector2D,
+  getStateName
+} from "../core"
+
+
+const DEFAULT_MIN_DIST_SQ = DEFAULT_TOUCH_SLOP * DEFAULT_TOUCH_SLOP;
+
+type PanGestureHandlerConfig = GestureConfig
+
+export class PanGestureHandler extends GestureHandler<PanGestureHandlerConfig> {
+  private startPos = new Vector2D();
+  private offset = new Vector2D()
+  private lastPos = new Vector2D();
+  private velocity = new Vector2D();
+  private activationTimeout = 0;
+
+  private get failOffsetXStart() {
+    if (this.config.failOffsetXStart === undefined
+      && this.config.failOffsetXEnd === undefined)
+      return undefined
+    return this.config.failOffsetXStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get failOffsetXEnd() {
+    if (this.config.failOffsetXStart === undefined
+      && this.config.failOffsetXEnd === undefined)
+      return undefined
+    return this.config.failOffsetXEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get failOffsetYStart() {
+    if (this.config.failOffsetYStart === undefined
+      && this.config.failOffsetYEnd === undefined)
+      return undefined
+    return this.config.failOffsetYStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get failOffsetYEnd() {
+    return this.config.failOffsetYEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get activeOffsetXStart() {
+    if (this.config.activeOffsetXStart === undefined
+      && this.config.activeOffsetXEnd === undefined)
+      return undefined
+    return this.config.activeOffsetXStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get activeOffsetXEnd() {
+    if (this.config.activeOffsetXStart === undefined
+      && this.config.activeOffsetXEnd === undefined)
+      return undefined
+    return this.config.activeOffsetXEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get activeOffsetYStart() {
+    if (this.config.activeOffsetYStart === undefined
+      && this.config.activeOffsetYEnd === undefined)
+      return undefined
+    return this.config.activeOffsetYStart ?? Number.MIN_SAFE_INTEGER
+  }
+
+  private get activeOffsetYEnd() {
+    if (this.config.activeOffsetYStart === undefined
+      && this.config.activeOffsetYEnd === undefined)
+      return undefined
+    return this.config.activeOffsetYEnd ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get minVelocityX() {
+    return this.config.minVelocityX ?? this.config.minVelocity ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private get minVelocityY() {
+    return this.config.minVelocityY ?? this.config.minVelocityY ?? Number.MAX_SAFE_INTEGER
+  }
+
+  private minVelocitySq = Number.MAX_SAFE_INTEGER
+
+  private get minPointers() {
+    return this.config.minPointers ?? 1
+  }
+
+  private unlockScrolls: (() => void) | undefined
+  private unlockRNGestureResponder: (() => void) | undefined
+
+  public constructor(deps: GestureHandlerDependencies) {
+    super({ ...deps, logger: deps.logger.cloneWithPrefix("PanGestureHandler") })
+  }
+
+  public onPointerDown(e) {
+    this.tracker.addToTracker(e);
+    super.onPointerDown(e);
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.startPos = this.lastPos.clone()
+    this.tryBegin(e);
+    this.tryActivating();
+  }
+
+  private tryActivating(): void {
+    if (this.currentState === State.BEGAN) {
+      if (this.shouldFail()) {
+        this.fail();
+      } else if (this.shouldActivate()) {
+        this.activate();
+      }
+    }
+  }
+
+  private shouldFail(): boolean {
+    const {x: dx, y: dy} = this.getTranslation().value;
+    const distanceSq = dx * dx + dy * dy;
+    if (this.activateAfterLongPress > 0 && distanceSq > DEFAULT_MIN_DIST_SQ) {
+      this.clearActivationTimeout();
+      return true;
+    }
+    if (this.failOffsetXStart !== Number.MIN_SAFE_INTEGER && dx < this.failOffsetXStart) {
+      return true;
+    }
+    if (this.failOffsetXEnd !== Number.MAX_SAFE_INTEGER && dx > this.failOffsetXEnd) {
+      return true;
+    }
+    if (this.failOffsetYStart !== Number.MIN_SAFE_INTEGER && dy < this.failOffsetYStart) {
+      return true;
+    }
+    return (this.failOffsetYEnd !== Number.MAX_SAFE_INTEGER && dy > this.failOffsetYEnd);
+  }
+
+  private getTranslation() {
+    return this.lastPos.clone().subtract(this.startPos).add(this.offset)
+  }
+
+  private shouldActivate(): boolean {
+    const {x: dx, y: dy} = this.getTranslation().value;
+    if (this.activeOffsetXStart !== Number.MAX_SAFE_INTEGER && dx < this.activeOffsetXStart
+    ) {
+      return true;
+    }
+    if (this.activeOffsetXEnd !== Number.MIN_SAFE_INTEGER && dx > this.activeOffsetXEnd) {
+      return true;
+    }
+    if (this.activeOffsetYStart !== Number.MAX_SAFE_INTEGER && dy < this.activeOffsetYStart) {
+      return true;
+    }
+    if (this.activeOffsetYEnd !== Number.MIN_SAFE_INTEGER && dy > this.activeOffsetYEnd) {
+      return true;
+    }
+    const distanceSq: number = dx * dx + dy * dy;
+    if (this.minDistSq !== Number.MAX_SAFE_INTEGER && distanceSq >= this.minDistSq) {
+      return true;
+    }
+    const {x: vx, y: vy} = this.velocity
+    if (
+      this.minVelocityX !== Number.MAX_SAFE_INTEGER &&
+        ((this.minVelocityX < 0 && vx <= this.minVelocityX) ||
+          (this.minVelocityX >= 0 && this.minVelocityX <= vx))
+    ) {
+      return true;
+    }
+    if (
+      this.minVelocityY !== Number.MAX_SAFE_INTEGER &&
+        ((this.minVelocityY < 0 && vy <= this.minVelocityY) ||
+          (this.minVelocityY >= 0 && this.minVelocityY <= vy))
+    ) {
+      return true;
+    }
+    const velocitySq: number = vx * vx + vy * vy;
+    return (
+      this.minVelocitySq !== Number.MAX_SAFE_INTEGER &&
+        velocitySq >= this.minVelocitySq
+    );
+  }
+
+  private clearActivationTimeout(): void {
+    clearTimeout(this.activationTimeout);
+  }
+
+  private tryBegin(e: IncomingEvent): void {
+    this.logger.cloneWithPrefix("tryBegin").debug({currentState: getStateName(this.currentState), trackedPointersCount: this.tracker.getTrackedPointersCount(), minPointers: this.minPointers})
+    if (
+      (this.currentState === State.UNDETERMINED) &&
+        this.tracker.getTrackedPointersCount() >= this.minPointers
+    ) {
+      this.resetProgress();
+      this.offset = new Vector2D();
+      this.velocity = new Vector2D();
+
+      this.begin();
+
+      if (this.activateAfterLongPress > 0) {
+        this.activationTimeout = setTimeout(() => {
+          this.activate();
+        }, this.activateAfterLongPress);
+      }
+    } else {
+      this.velocity = this.tracker.getVelocity(e.pointerId)
+    }
+  }
+
+  public getDefaultConfig() {
+    return {}
+  }
+
+  private get activateAfterLongPress() {
+    return this.config.activateAfterLongPress ?? 0
+  }
+
+  private get minDistSq() {
+    if (this.config.minDist !== undefined) {
+      return this.config.minDist * this.config.minDist;
+    } else if (this.hasCustomActivationCriteria()) {
+      return Number.MAX_SAFE_INTEGER;
+    }
+    return DEFAULT_MIN_DIST_SQ
+  }
+
+  private hasCustomActivationCriteria() {
+    const criterias: (keyof PanGestureHandlerConfig)[] = [
+      'activeOffsetXStart',
+      'activeOffsetXEnd',
+      'failOffsetXStart',
+      'failOffsetXEnd',
+      'activeOffsetYStart',
+      'activeOffsetYEnd',
+      'failOffsetYStart',
+      'failOffsetYEnd',
+      'minVelocityX',
+      'minVelocityY',
+    ]
+    for (const key in this.config) {
+      if (criterias.indexOf(key as keyof PanGestureHandlerConfig) >= 0) {
+        return true
+      }
+    }
+    return false
+  }
+
+  public onAdditionalPointerAdd(event: IncomingEvent): void {
+    this.tracker.addToTracker(event);
+    super.onAdditionalPointerAdd(event);
+    this.tryBegin(event);
+    this.offset.add(this.lastPos).subtract(this.startPos)
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.startPos = this.lastPos.clone()
+    if (this.tracker.getTrackedPointersCount() > (this.config.maxPointers ?? 10)) {
+      if (this.currentState === State.ACTIVE) {
+        this.cancel();
+      } else {
+        this.fail();
+      }
+    } else {
+      this.tryActivating();
+    }
+  }
+
+  public onPointerUp(event: IncomingEvent): void {
+    super.onPointerUp(event);
+    if (this.currentState === State.ACTIVE) {
+      this.lastPos = this.tracker.getLastAvgPos();
+    }
+    this.tracker.removeFromTracker(event.pointerId);
+    if (this.currentState === State.ACTIVE) {
+      this.end();
+    } else {
+      this.resetProgress();
+      this.fail();
+    }
+  }
+
+  public onAdditionalPointerRemove(event: IncomingEvent): void {
+    super.onAdditionalPointerRemove(event);
+    this.tracker.removeFromTracker(event.pointerId);
+    this.offset.add(this.lastPos).subtract(this.startPos)
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.startPos = this.lastPos.clone()
+    if (
+      !(
+        this.currentState === State.ACTIVE &&
+          this.tracker.getTrackedPointersCount() < this.minPointers
+      )
+    ) {
+      this.tryActivating();
+    }
+  }
+
+  public onPointerMove(event: IncomingEvent): void {
+    this.tracker.track(event);
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.velocity = this.tracker.getVelocity(event.pointerId)
+    this.tryActivating();
+    super.onPointerMove(event);
+  }
+
+  public onPointerOutOfBounds(event: IncomingEvent): void {
+    if (this.shouldCancelWhenOutside) {
+      return;
+    }
+    this.tracker.track(event);
+    this.lastPos = this.tracker.getLastAvgPos()
+    this.velocity = this.tracker.getVelocity(event.pointerId)
+    this.tryActivating();
+    if (this.currentState === State.ACTIVE) {
+      super.onPointerOutOfBounds(event);
+    }
+  }
+
+  protected transformNativeEvent() {
+    const rect = this.view.getBoundingRect();
+    const translation = this.getTranslation()
+    return {
+      translationX: translation.x,
+      translationY: translation.y,
+      absoluteX: this.tracker.getLastAvgX(),
+      absoluteY: this.tracker.getLastAvgY(),
+      velocityX: this.velocity.x,
+      velocityY: this.velocity.y,
+      x: this.tracker.getLastAvgX() - rect.x,
+      y: this.tracker.getLastAvgY() - rect.y,
+    };
+  }
+
+  protected onStateChange(newState: State, oldState: State) {
+    super.onStateChange(newState, oldState)
+    if (newState === State.BEGAN) {
+      this.unlockScrolls = this.scrollLocker.lockScrollContainingViewTag(this.view.getTag())
+    } else if (newState !== State.ACTIVE) {
+      this.unlockScrolls?.()
+    }
+    if (newState === State.ACTIVE) {
+      this.unlockRNGestureResponder = this.rnGestureResponder.lock(this.view.getTag())
+    } else {
+      this.unlockRNGestureResponder?.()
+    }
+  }
+}