@react-native-oh-tpl/react-native-gesture-handler 2.14.1-2.14.8 → 2.14.1-2.14.9

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,113 @@
+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();
+    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.currentState === State.ACTIVE) {
+        this.cancel();
+      } else if (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?.()
+    }
+  }
+}

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

@@ -0,0 +1,159 @@
+import { GestureHandler, DEFAULT_TOUCH_SLOP, IncomingEvent, GestureConfig, State, GestureHandlerDependencies } from "../core"
+import ScaleGestureDetector, { ScaleGestureListener } from "../detectors/ScaleGestureDetector";
+
+
+
+export class PinchGestureHandler extends GestureHandler {
+    private scale = 1;
+    private velocity = 0;
+
+    private startingSpan = 0;
+    private spanSlop = DEFAULT_TOUCH_SLOP;
+
+    private scaleDetectorListener: ScaleGestureListener = {
+      onScaleBegin: (detector: ScaleGestureDetector): boolean => {
+        this.startingSpan = detector.getCurrentSpan();
+        return true;
+      },
+      onScale: (detector: ScaleGestureDetector): boolean => {
+        const prevScaleFactor: number = this.scale;
+        this.scale *= detector.getScaleFactor(
+          this.tracker.getTrackedPointersCount()
+        );
+
+        const delta = detector.getTimeDelta();
+        if (delta > 0) {
+          this.velocity = (this.scale - prevScaleFactor) / delta;
+        }
+
+        if (
+          Math.abs(this.startingSpan - detector.getCurrentSpan()) >=
+            this.spanSlop &&
+          this.currentState === State.BEGAN
+        ) {
+          this.activate();
+        }
+        return true;
+      },
+      onScaleEnd: (
+        _detector: ScaleGestureDetector
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+      ): void => {},
+    };
+
+    private scaleGestureDetector: ScaleGestureDetector = new ScaleGestureDetector(
+      this.scaleDetectorListener
+    );
+
+
+    public constructor(deps: GestureHandlerDependencies) {
+        super({ ...deps, logger: deps.logger.cloneWithPrefix("PinchGestureHandler") })
+        this.setShouldCancelWhenOutside(false);
+    }
+
+    public getDefaultConfig() {
+      return {}
+    }
+
+    public updateGestureConfig({ enabled = true, ...props }: GestureConfig): void {
+      super.updateGestureConfig({ enabled: enabled, ...props });
+    }
+
+    protected transformNativeEvent() {
+      return {
+        focalX: this.scaleGestureDetector.getFocusX(),
+        focalY: this.scaleGestureDetector.getFocusY(),
+        velocity: this.velocity,
+        scale: this.scale,
+      };
+    }
+
+    public onPointerDown(event: IncomingEvent): void {
+      this.tracker.addToTracker(event);
+      super.onPointerDown(event);
+    }
+
+    public onAdditionalPointerAdd(event: IncomingEvent): void {
+      this.tracker.addToTracker(event);
+      super.onAdditionalPointerAdd(event);
+      this.tryBegin();
+      this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+    }
+
+    public onPointerUp(event: IncomingEvent): void {
+      super.onPointerUp(event);
+      this.tracker.removeFromTracker(event.pointerId);
+      if (this.currentState !== State.ACTIVE) {
+        return;
+      }
+      this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+
+      if (this.currentState === State.ACTIVE) {
+        this.end();
+      } else {
+        this.fail();
+      }
+    }
+
+    public onAdditionalPointerRemove(event: IncomingEvent): void {
+      super.onAdditionalPointerRemove(event);
+      this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+      this.tracker.removeFromTracker(event.pointerId);
+
+      if (
+        this.currentState === State.ACTIVE &&
+        this.tracker.getTrackedPointersCount() < 2
+      ) {
+        this.end();
+      }
+    }
+
+    public onPointerMove(event: IncomingEvent): void {
+        if (this.tracker.getTrackedPointersCount() < 2) {
+        return;
+      }
+      this.tracker.track(event);
+
+      this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+      super.onPointerMove(event);
+    }
+
+    public onPointerOutOfBounds(event: IncomingEvent): void {
+      if (this.tracker.getTrackedPointersCount() < 2) {
+        return;
+      }
+      this.tracker.track(event);
+
+      this.scaleGestureDetector.onTouchEvent(event, this.tracker);
+      super.onPointerOutOfBounds(event);
+    }
+
+    private tryBegin(): void {
+        if (this.currentState !== State.UNDETERMINED) {
+        return;
+      }
+
+      this.resetProgress();
+      this.begin();
+    }
+
+    public activate(force?: boolean): void {
+        if (this.currentState !== State.ACTIVE) {
+        this.resetProgress();
+      }
+
+      super.activate();
+    }
+
+    protected onReset(): void {
+      this.resetProgress();
+    }
+
+    protected resetProgress(): void {
+      if (this.currentState === State.ACTIVE) {
+        return;
+      }
+      this.velocity = 0;
+      this.scale = 1;
+    }
+}