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

package/harmony/gesture_handler/src/main/ets/{GestureHandler.ts → core/GestureHandler.ts}

@@ -1,24 +1,28 @@
 import type { GestureHandlerOrchestrator } from "./GestureHandlerOrchestrator"
 import type { PointerTracker } from "./PointerTracker"
 import type { View } from "./View"
-import type { EventDispatcher } from "./EventDispatcher"
 import type { InteractionManager } from "./InteractionManager"
 import type { RNGHLogger } from './RNGHLogger'
+import { OutgoingEventDispatcher } from "./OutgoingEventDispatcher"
 import { State, getStateName } from "./State"
-import { HitSlop, Directions, AdaptedEvent, PointerType, TouchEventType, EventType } from "./Event"
+import { HitSlop, Directions, IncomingEvent, PointerType, TouchEventType, EventType } from "./IncomingEvent"
 import { GestureStateChangeEvent, GestureTouchEvent, TouchData } from "./OutgoingEvent"
 
 
+export type GHTag = number
+
 export interface Handler {
-  handlerTag: number;
+  handlerTag: GHTag;
 }
 
 export const DEFAULT_TOUCH_SLOP = 15;
 
 export interface GestureConfig {
   enabled?: boolean;
+  manualActivation?: boolean;
   simultaneousHandlers?: Handler[] | null;
   waitFor?: Handler[] | null;
+  blocksHandlers?: Handler[] | null;
   hitSlop?: HitSlop;
   shouldCancelWhenOutside?: boolean;
   activateAfterLongPress?: number;
@@ -49,7 +53,7 @@ export interface GestureConfig {
   maxDeltaY?: number;
   shouldActivateOnStart?: boolean;
   disallowInterruption?: boolean;
-  direction?: typeof Directions;
+  direction?: Directions;
   needsPointerData?: boolean
   // --- Tap
   minNumberOfPointers?: number
@@ -61,6 +65,10 @@ export interface ScrollLocker {
   lockScrollContainingViewTag(viewTag: number): () => void
 }
 
+export interface RNGestureResponder {
+  lock: (viewTag: number) => () => void
+}
+
 export type GestureHandlerDependencies = {
   handlerTag: number
   orchestrator: GestureHandlerOrchestrator
@@ -68,6 +76,7 @@ export type GestureHandlerDependencies = {
   interactionManager: InteractionManager
   logger: RNGHLogger
   scrollLocker: ScrollLocker
+  rnGestureResponder: RNGestureResponder
 }
 
 export abstract class GestureHandler<TGestureConfig extends GestureConfig = GestureConfig> {
@@ -86,10 +95,11 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   protected handlerTag: number
   protected orchestrator: GestureHandlerOrchestrator
   protected tracker: PointerTracker
-  protected eventDispatcher: EventDispatcher
+  protected eventDispatcher: OutgoingEventDispatcher
   protected interactionManager: InteractionManager
   protected logger: RNGHLogger
   protected scrollLocker: ScrollLocker
+  protected rnGestureResponder: RNGestureResponder
 
   constructor(deps: GestureHandlerDependencies
   ) {
@@ -99,15 +109,16 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     this.interactionManager = deps.interactionManager
     this.logger = deps.logger
     this.scrollLocker = deps.scrollLocker
+    this.rnGestureResponder = deps.rnGestureResponder
   }
 
-  public setEventDispatcher(eventDispatcher: EventDispatcher) {
+  public setEventDispatcher(eventDispatcher: OutgoingEventDispatcher) {
     // TurboModule provides info about kind of event dispatcher when attaching GH to a view, not when GH is created.
     // This method must be called before any other
     this.eventDispatcher = eventDispatcher
   }
 
-  public onPointerDown(e: AdaptedEvent) {
+  public onPointerDown(e: IncomingEvent) {
     this.logger.info("onPointerDown")
     this.orchestrator.registerHandlerIfNotPresent(this);
     this.pointerType = e.pointerType;
@@ -119,7 +130,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     }
   }
 
-  protected sendTouchEvent(e: AdaptedEvent) {
+  protected sendTouchEvent(e: IncomingEvent) {
     if (!this.config.enabled) {
       return;
     }
@@ -133,7 +144,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     }
   }
 
-  protected transformToTouchEvent(event: AdaptedEvent): GestureTouchEvent | undefined {
+  protected transformToTouchEvent(event: IncomingEvent): GestureTouchEvent | undefined {
     const rect = this.view.getBoundingRect();
 
     const all: TouchData[] = [];
@@ -226,22 +237,22 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     };
   }
 
-  public onPointerUp(e: AdaptedEvent): void {
+  public onPointerUp(e: IncomingEvent): void {
     this.logger.info("onPointerUp")
     if (this.config.needsPointerData) this.sendTouchEvent(e)
   }
 
-  public onAdditionalPointerAdd(e: AdaptedEvent): void {
+  public onAdditionalPointerAdd(e: IncomingEvent): void {
     this.logger.info("onAdditionalPointerAdd")
     if (this.config.needsPointerData) this.sendTouchEvent(e)
   }
 
-  public onAdditionalPointerRemove(e: AdaptedEvent): void {
+  public onAdditionalPointerRemove(e: IncomingEvent): void {
     this.logger.info("onAdditionalPointerRemove")
     if (this.config.needsPointerData) this.sendTouchEvent(e)
   }
 
-  public onPointerMove(e: AdaptedEvent): void {
+  public onPointerMove(e: IncomingEvent): void {
     this.logger.info("onPointerMove")
     this.tryToSendMoveEvent(false);
     if (this.config.needsPointerData) {
@@ -265,14 +276,14 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     }
   }
 
-  public onPointerEnter(e: AdaptedEvent): void {
+  public onPointerEnter(e: IncomingEvent): void {
     this.logger.info("onPointerEnter")
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e)
     }
   }
 
-  public onPointerOut(e: AdaptedEvent): void {
+  public onPointerOut(e: IncomingEvent): void {
     this.logger.info("onPointerOut")
     if (this.shouldCancelWhenOutside) {
       switch (this.currentState) {
@@ -290,7 +301,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     }
   }
 
-  public onPointerCancel(e: AdaptedEvent): void {
+  public onPointerCancel(e: IncomingEvent): void {
     this.logger.info("onPointerCancel")
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e);
@@ -299,7 +310,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     this.reset();
   }
 
-  public onPointerOutOfBounds(e: AdaptedEvent): void {
+  public onPointerOutOfBounds(e: IncomingEvent): void {
     this.logger.info("onPointerOutOfBounds")
     this.tryToSendMoveEvent(true);
     if (this.config.needsPointerData) {
@@ -403,7 +414,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
 
   public activate(): void {
     this.logger.info("activate")
-    if (this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
+    if (!this.config.manualActivation || this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
       this.moveToState(State.ACTIVE)
     }
   }
@@ -417,7 +428,11 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
       this.cancelTouches()
     }
     this.orchestrator.onHandlerStateChange(this, state, oldState)
-    this.stateDidChange(state, oldState)
+    this.onStateChange(state, oldState)
+
+    if (!this.isEnabled() && this.isFinished()) {
+      this.currentState = State.UNDETERMINED;
+    }
   }
 
   private isFinished() {
@@ -464,8 +479,8 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     this.eventDispatcher.onGestureHandlerEvent(cancelEvent)
   }
 
-  protected stateDidChange(newState: State, oldState: State) {
-    this.logger.info(`stateDidChange from ${getStateName(oldState)} to ${getStateName(newState)}`)
+  protected onStateChange(newState: State, oldState: State) {
+    this.logger.info(`onStateChange: from ${getStateName(oldState)} to ${getStateName(newState)}`)
   }
 
 
@@ -535,14 +550,16 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     oldState: State,
     newState: State
   }): void {
-    this.logger.info(`sendEvent`)
+    const logger = this.logger.cloneWithPrefix(`sendEvent(newState=${getStateName(newState)}, oldState=${getStateName(oldState)})`)
     const stateChangeEvent = this.createStateChangeEvent(newState, oldState);
     if (this.lastSentState !== newState) {
       this.lastSentState = newState;
+      logger.debug("calling onGestureHandlerStateChange")
       this.eventDispatcher.onGestureHandlerStateChange(stateChangeEvent);
     }
     if (this.currentState === State.ACTIVE) {
       stateChangeEvent.oldState = undefined;
+      logger.debug("calling onGestureHandlerEvent")
       this.eventDispatcher.onGestureHandlerEvent(stateChangeEvent);
     }
   }
@@ -562,8 +579,14 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     };
   }
 
-  protected transformNativeEvent() {
-    return {};
+  protected transformNativeEvent(): Record<string, unknown> {
+    const rect = this.view.getBoundingRect();
+    return {
+      x: this.tracker.getLastAvgX() - rect.x,
+      y: this.tracker.getLastAvgY() - rect.y,
+      absoluteX: this.tracker.getLastAvgX(),
+      absoluteY: this.tracker.getLastAvgY(),
+    };
   }
 
   setAwaiting(isAwaiting: boolean): void {
@@ -583,11 +606,14 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   shouldWaitFor(otherHandler: GestureHandler): boolean {
-    return (
+    const logger = this.logger.cloneWithPrefix(`shouldWaitFor(${otherHandler.getTag()})`)
+    const result = (
       this !== otherHandler &&
         (this.shouldWaitForHandlerFailure(otherHandler) ||
         otherHandler.shouldRequireToWaitForFailure(this))
     );
+    logger.debug(result)
+    return result
   }
 
   reset(): void {
@@ -595,7 +621,6 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     this.tracker.resetTracker();
     this.onReset();
     this.resetProgress();
-    // TODO: reset ArkUIAdapters
     // this.eventManagers.forEach((manager: EventManager) =>
     // manager.resetManager()
     // );
@@ -640,8 +665,10 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   shouldRecognizeSimultaneously(otherHandler: GestureHandler): boolean {
-    if (otherHandler === this)
+    this.logger.cloneWithPrefix(`shouldRecognizeSimultaneously(${otherHandler.getTag()})`).debug("")
+    if (otherHandler === this) {
       return true;
+    }
     return this.interactionManager.shouldRecognizeSimultaneously(this, otherHandler);
   }
 

package/harmony/gesture_handler/src/main/ets/{GestureHandlerOrchestrator.ts → core/GestureHandlerOrchestrator.ts}

@@ -1,6 +1,6 @@
 import { GestureHandler } from "./GestureHandler"
-import { State } from "./State"
-import { PointerType } from "./Event"
+import { State, getStateName } from "./State"
+import { PointerType } from "./IncomingEvent"
 import { RNGHLogger } from "./RNGHLogger"
 
 export class GestureHandlerOrchestrator {
@@ -13,92 +13,133 @@ export class GestureHandlerOrchestrator {
   }
 
   public onHandlerStateChange(handler: GestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean) {
-    this.logger.info("onHandlerStateChange")
-    if (this.shouldCancelStateChange(handler, sendIfDisabled)) return;
+    const logger = this.logger.cloneWithPrefix(`onHandlerStateChange(handler=${handler.getTag()}, newState=${getStateName(newState)}, oldState=${getStateName(oldState)})`)
+    logger.debug("start")
+
+    if (!handler.isEnabled() && !sendIfDisabled) {
+      return;
+    }
+
+    // this.handlingChangeSemaphore += 1;
+
     if (this.isFinishedState(newState)) {
-      this.handleChangingToFinishedState(handler, newState)
+      this.awaitingHandlers.forEach((otherHandler) => {
+        if (otherHandler.shouldWaitFor(handler)) {
+          if (newState === State.END) {
+            otherHandler?.cancel();
+            if (otherHandler.getState() === State.END) {
+              // Handle edge case, where discrete gestures end immediately after activation thus
+              // their state is set to END and when the gesture they are waiting for activates they
+              // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
+              // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
+              otherHandler.sendEvent({ newState: State.CANCELLED, oldState: State.BEGAN });
+            }
+            otherHandler?.setAwaiting(false);
+          } else {
+            this.tryActivate(otherHandler);
+          }
+        }
+      });
     }
+
     if (newState === State.ACTIVE) {
-      this.tryActivate(handler)
+      this.tryActivate(handler);
     } else if (oldState === State.ACTIVE || oldState === State.END) {
       if (handler.isActive()) {
-        handler.sendEvent({ newState, oldState })
-      } else if (oldState === State.ACTIVE && (newState === State.CANCELLED || newState === State.FAILED)) {
-        // Handle edge case where handler awaiting for another one tries to activate but finishes
-        // before the other would not send state change event upon ending. Note that we only want
-        // to do this if the newState is either CANCELLED or FAILED, if it is END we still want to
-        // wait for the other handler to finish as in that case synthetic events will be sent by the
-        // makeActive method.
-        handler.sendEvent({ newState, oldState: State.BEGAN })
+        handler.sendEvent({ newState, oldState });
+      } else if (
+        oldState === State.ACTIVE &&
+          (newState === State.CANCELLED || newState === State.FAILED)
+      ) {
+        handler.sendEvent({ newState, oldState: State.BEGAN });
       }
-    } else if (newState !== State.CANCELLED || oldState !== State.UNDETERMINED) {
-      // If handler is changing state from UNDETERMINED to CANCELLED, the state change event shouldn't
-      // be sent. Handler hasn't yet began so it may not be initialized which results in crashes.
-      // If it doesn't crash, there may be some weird behavior on JS side, as `onFinalize` will be
-      // called without calling `onBegin` first.
-      handler.sendEvent({ newState, oldState })
+    } else if (
+      oldState !== State.UNDETERMINED ||
+        newState !== State.CANCELLED
+    ) {
+      handler.sendEvent({ newState, oldState });
     }
-    this.cleanUpHandlers(handler)
-  }
 
-  private isFinishedState(state: State) {
-    return [State.END, State.FAILED, State.CANCELLED].includes(state)
-  }
+    // this.handlingChangeSemaphore -= 1;
 
-  private shouldCancelStateChange(handler: GestureHandler, sendIfDisabled?: boolean) {
-    const isHandlerDisabled = !handler.isEnabled()
-    return!sendIfDisabled && isHandlerDisabled
+    this.cleanUpFinishedHandlers();
+    if (!this.awaitingHandlers.has(handler)) {
+      this.cleanupAwaitingHandlers(handler);
+    }
   }
 
-  private handleChangingToFinishedState(handler: GestureHandler, newState: State) {
-    this.awaitingHandlers.forEach(awaitingHandler => {
-      if (handler.shouldWaitFor(awaitingHandler)) {
-        if (newState === State.END) {
-          awaitingHandler.cancel()
-          if (awaitingHandler.getState() === State.END) {
-            // Handle edge case, where discrete gestures end immediately after activation thus
-            // their state is set to END and when the gesture they are waiting for activates they
-            // should be cancelled, however `cancel` was never sent as gestures were already in the END state.
-            // Send synthetic BEGAN -> CANCELLED to properly handle JS logic
-            awaitingHandler.sendEvent({ newState: State.CANCELLED, oldState: State.BEGAN })
-          }
-          awaitingHandler.setAwaiting(false)
-        } else {
-          this.tryActivate(awaitingHandler)
-        }
-      }
-    })
+  private isFinishedState(state: State) {
+    return [State.END, State.FAILED, State.CANCELLED].includes(state)
   }
 
   private tryActivate(handler: GestureHandler): void {
+    const logger = this.logger.cloneWithPrefix(`tryActivate(${handler.getTag()})`)
+    logger.debug({
+      gestureHandlers: this.gestureHandlers.map(gh => gh.getTag()),
+      awaitingHandlers: Array.from(this.awaitingHandlers).map(gh => gh.getTag()),
+      handlersToCancel: this.handlersToCancel.map(gh => gh.getTag())
+    })
+    if (this.shouldBeCancelledByFinishedHandler(handler)) {
+      logger.debug("failed to activate - cancelling")
+      handler.cancel();
+      return;
+    }
     if (this.hasOtherHandlerToWaitFor(handler)) {
-      this.addAwaitingHandler(handler)
-    } else if (handler.getState() !== State.CANCELLED && handler.getState() !== State.FAILED) {
-      if (this.shouldActivate(handler)) {
-        this.makeActive(handler);
-      } else {
-        switch (handler.getState()) {
-          case State.ACTIVE:
-            handler.fail();
-            break;
-          case State.BEGAN:
-            handler.cancel();
-            break;
-        }
-      }
+      this.addAwaitingHandler(handler);
+      logger.debug("request ignored - has other handler waiting")
+      return;
+    }
+    const handlerState = handler.getState();
+    if (handlerState === State.CANCELLED || handlerState === State.FAILED) {
+      logger.debug("request ignored - handler is in cancelled or failed state")
+      return;
+    }
+    if (this.shouldActivate(handler)) {
+      logger.debug("activating")
+      this.makeActive(handler);
+      return;
+    }
+    if (handlerState === State.ACTIVE) {
+      logger.debug("failed to activate - handler is already active, marking as fail")
+      handler.fail();
+      return;
+    }
+    if (handlerState === State.BEGAN) {
+      logger.debug("handler is in BEGAN state but shouldActivate returned false - cancelling")
+      handler.cancel();
     }
   }
 
+  private shouldBeCancelledByFinishedHandler(
+    handler: GestureHandler
+  ): boolean {
+    const shouldBeCancelled = (otherHandler: GestureHandler) => {
+      return (
+        handler.shouldWaitFor(otherHandler) &&
+          otherHandler.getState() === State.END
+      );
+    };
+    return this.gestureHandlers.some(shouldBeCancelled);
+  }
+
   private hasOtherHandlerToWaitFor(handler: GestureHandler): boolean {
+    const logger = this.logger.cloneWithPrefix(`hasOtherHandlerToWaitFor(handler=${handler.getTag()})`)
     for (const otherHandler of this.gestureHandlers) {
-      if (!this.isFinishedState(otherHandler.getState()) && otherHandler.shouldWaitFor(handler)) {
+      if (otherHandler === handler) {
+        return false
+      }
+      if (!this.isFinishedState(otherHandler.getState()) && handler.shouldWaitFor(otherHandler)) {
+        logger.debug("true")
         return true
       }
     }
+    logger.debug("false")
     return false;
   }
 
   private addAwaitingHandler(handler: GestureHandler) {
+    const logger = this.logger.cloneWithPrefix(`addAwaitingHandler(handlerTag=${handler.getTag()})`)
+    logger.debug({ awaitingHandlers: this.awaitingHandlers })
     if (!this.awaitingHandlers.has(handler)) {
       this.awaitingHandlers.add(handler)
       handler.setAwaiting(true)
@@ -119,17 +160,29 @@ export class GestureHandlerOrchestrator {
     handler: GestureHandler,
     otherHandler: GestureHandler
   }): boolean {
-    if (this.canRunSimultaneously(handler, otherHandler))
+    const logger = this.logger.cloneWithPrefix(`shouldHandlerBeCancelledByOtherHandler(${handler.getTag()}, ${otherHandler.getTag()})`)
+    if (this.canRunSimultaneously(handler, otherHandler)) {
+      logger.debug("false")
       return false;
-    if (handler !== otherHandler && (handler.isAwaiting() || handler.getState() === State.ACTIVE))
-      return handler.shouldBeCancelledByOther(otherHandler)
-    return this.checkOverlap(handler, otherHandler)
+    }
+    if (handler !== otherHandler && (handler.isAwaiting() || handler.getState() === State.ACTIVE)) {
+      const result = handler.shouldBeCancelledByOther(otherHandler)
+      logger.debug(`${result} (1)`)
+      return result
+    }
+    const result = this.checkOverlap(handler, otherHandler)
+    logger.debug(`${result} (2)`)
+    return result;
   }
 
   private canRunSimultaneously(handlerA: GestureHandler, handlerB: GestureHandler) {
-    return handlerA === handlerB
+    const logger = this.logger.cloneWithPrefix("canRunSimultaneously")
+    const result = handlerA === handlerB
       || handlerA.shouldRecognizeSimultaneously(handlerB)
       || handlerB.shouldRecognizeSimultaneously(handlerA)
+
+    logger.debug({ result, handlerA: handlerA.getTag(), handlerB: handlerB.getTag() })
+    return result
   }
 
   private checkOverlap(
@@ -222,6 +275,8 @@ export class GestureHandlerOrchestrator {
   }
 
   private cleanupAwaitingHandlers(handler: GestureHandler): void {
+    const logger = this.logger.cloneWithPrefix(`cleanupAwaitingHandlers(handler=${handler.getTag()})`)
+    logger.debug({ awaitingHandlers: this.awaitingHandlers })
     for (const awaitingHandler of this.awaitingHandlers) {
       if (
         awaitingHandler.isAwaiting() &&
@@ -241,7 +296,7 @@ export class GestureHandlerOrchestrator {
   }
 
   public registerHandlerIfNotPresent(handler: GestureHandler) {
-    this.logger.info("registerHandlerIfNotPresent")
+    this.logger.info(`registerHandlerIfNotPresent(${handler.getTag()})`)
     if (this.gestureHandlers.includes(handler)) return;
     this.gestureHandlers.push(handler);
     handler.setActive(false);

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

@@ -0,0 +1,63 @@
+import { GestureHandler } from "./GestureHandler"
+import { View } from "./View"
+import { RNGHLogger } from "./RNGHLogger"
+import { ViewRegistry } from "./ViewRegistry"
+
+export class GestureHandlerRegistry {
+  private gestureHandlerByHandlerTag: Map<number, GestureHandler> = new Map()
+  private gestureHandlersByViewTag: Map<number, Set<GestureHandler>> = new Map()
+  private viewRegistry: ViewRegistry | undefined
+  private logger: RNGHLogger
+
+  constructor(viewRegistry: ViewRegistry | undefined, logger: RNGHLogger) {
+    this.logger = logger.cloneWithPrefix("GestureHandlerRegistry")
+    this.viewRegistry = viewRegistry
+  }
+
+  public addGestureHandler(gestureHandler: GestureHandler) {
+    this.gestureHandlerByHandlerTag.set(gestureHandler.getTag(), gestureHandler)
+  }
+
+  public bindGestureHandlerWithView(gestureHandlerTag: number, view: View) {
+    this.logger.cloneWithPrefix("bindGestureHandlerWithView").debug({gestureHandlerTag, viewTag: view.getTag()})
+    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 removeGestureHandlerByHandlerTag(handlerTag: number) {
+    const gestureHandler = this.gestureHandlerByHandlerTag.get(handlerTag)
+    if (!gestureHandler) {
+      return;
+    }
+    const viewTag = gestureHandler.getView()?.getTag();
+    if (viewTag) {
+      const gestureHandlers = this.gestureHandlersByViewTag.get(viewTag)
+      if (gestureHandlers) {
+        gestureHandlers.delete(gestureHandler)
+        if (gestureHandlers.size === 0) {
+          this.gestureHandlersByViewTag.delete(viewTag)
+          this.viewRegistry?.deleteByTag(viewTag)
+        }
+      }
+    }
+    if (gestureHandler.getView()) {
+      // Handler is in "prepared" state which means it is registered in the orchestrator and can
+      // receive touch events. This means that before we remove it from the registry we need to
+      // "cancel" it so that orchestrator does no longer keep a reference to it.
+      gestureHandler.cancel()
+    }
+    this.gestureHandlerByHandlerTag.delete(handlerTag)
+  }
+
+  public getGestureHandlerByHandlerTag(handlerTag: number): GestureHandler {
+    return this.gestureHandlerByHandlerTag.get(handlerTag)
+  }
+}

package/harmony/gesture_handler/src/main/ets/{Event.ts → core/IncomingEvent.ts}

@@ -9,13 +9,30 @@ export interface HitSlop {
   height?: number;
 }
 
+const RIGHT = 1;
+const LEFT = 2;
+const UP = 4;
+const DOWN = 8;
+
 export const Directions = {
-  RIGHT: 1,
-  LEFT: 2,
-  UP: 4,
-  DOWN: 8,
+  RIGHT: RIGHT,
+  LEFT: LEFT,
+  UP: UP,
+  DOWN: DOWN,
 } as const;
 
+export type Directions = typeof Directions[keyof typeof Directions];
+
+export const DiagonalDirections = {
+  UP_RIGHT: UP | RIGHT,
+  DOWN_RIGHT: DOWN | RIGHT,
+  UP_LEFT: UP | LEFT,
+  DOWN_LEFT: DOWN | LEFT,
+} as const;
+
+export type DiagonalDirections =
+  typeof DiagonalDirections[keyof typeof DiagonalDirections];
+
 export enum PointerType {
   NONE = 'none',
   MOUSE = 'mouse',
@@ -24,14 +41,14 @@ export enum PointerType {
 }
 
 export enum EventType {
-  DOWN,
-  ADDITIONAL_POINTER_DOWN,
-  UP,
-  ADDITIONAL_POINTER_UP,
-  MOVE,
-  ENTER,
-  OUT,
-  CANCEL,
+  DOWN = "DOWN",
+  ADDITIONAL_POINTER_DOWN = "ADDITIONAL_POINTER_DOWN",
+  UP = "UP",
+  ADDITIONAL_POINTER_UP = "ADDITIONAL_POINTER_UP",
+  MOVE = "MOVE",
+  ENTER = "ENTER",
+  OUT = "OUT",
+  CANCEL = "CANCEL",
 }
 
 export type Touch = {id: number, x: number, y: number, absoluteX: number, absoluteY: number}
@@ -44,7 +61,7 @@ export enum TouchEventType {
   CANCELLED = 4,
 }
 
-export interface AdaptedEvent {
+export interface IncomingEvent {
   x: number;
   y: number;
   offsetX: number;
@@ -59,10 +76,3 @@ export interface AdaptedEvent {
   touchEventType?: TouchEventType;
 }
 
-export interface TrackerElement {
-  lastX: number;
-  lastY: number;
-  timeStamp: number;
-  velocityX: number;
-  velocityY: number;
-}