@react-native-oh-tpl/react-native-gesture-handler 2.14.1-2.14.12 → 2.14.1-2.14.14

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

@@ -107,11 +107,15 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     this.orchestrator = deps.orchestrator
     this.tracker = deps.tracker
     this.interactionManager = deps.interactionManager
-    this.logger = deps.logger
+    this.logger = deps.logger.cloneAndJoinPrefix("GestureHandler")
     this.scrollLocker = deps.scrollLocker
     this.rnGestureResponder = deps.rnGestureResponder
   }
 
+  public abstract getName(): string;
+
+  public abstract isGestureContinuous(): boolean;
+
   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
@@ -119,7 +123,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   public onPointerDown(e: IncomingEvent) {
-    this.logger.info("onPointerDown")
+    const stopTracing = this.logger.cloneAndJoinPrefix("onPointerDown").startTracing()
     this.orchestrator.registerHandlerIfNotPresent(this);
     this.pointerType = e.pointerType;
     if (this.pointerType === PointerType.TOUCH) {
@@ -128,6 +132,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e);
     }
+    stopTracing()
   }
 
   protected sendTouchEvent(e: IncomingEvent) {
@@ -137,7 +142,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
 
 
     const touchEvent: GestureTouchEvent | undefined =
-    this.transformToTouchEvent(e);
+      this.transformToTouchEvent(e);
 
     if (touchEvent) {
       this.eventDispatcher.onGestureHandlerEvent(touchEvent)
@@ -238,35 +243,47 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   public onPointerUp(e: IncomingEvent): void {
-    this.logger.info("onPointerUp")
-    if (this.config.needsPointerData) this.sendTouchEvent(e)
+    const stopTracing = this.logger.cloneAndJoinPrefix("onPointerUp").startTracing()
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(e)
+    }
+    stopTracing()
   }
 
   public onAdditionalPointerAdd(e: IncomingEvent): void {
-    this.logger.info("onAdditionalPointerAdd")
-    if (this.config.needsPointerData) this.sendTouchEvent(e)
+    const stopTracing = this.logger.cloneAndJoinPrefix("onAdditionalPointerAdd").startTracing()
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(e)
+    }
+    stopTracing()
   }
 
   public onAdditionalPointerRemove(e: IncomingEvent): void {
-    this.logger.info("onAdditionalPointerRemove")
-    if (this.config.needsPointerData) this.sendTouchEvent(e)
+    const stopTracing = this.logger.cloneAndJoinPrefix("onAdditionalPointerRemove").startTracing()
+    if (this.config.needsPointerData) {
+      this.sendTouchEvent(e)
+    }
+    stopTracing()
   }
 
   public onPointerMove(e: IncomingEvent): void {
-    this.logger.info("onPointerMove")
+    const stopTracing = this.logger.cloneAndJoinPrefix("onPointerMove").startTracing()
     this.tryToSendMoveEvent(false);
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e);
     }
+    stopTracing()
   }
 
   private tryToSendMoveEvent(out: boolean): void {
-    this.logger.info(`tryToSendMoveEvent ${JSON.stringify({
+    const logger = this.logger.cloneAndJoinPrefix(`tryToSendMoveEvent`)
+    const stopTracing = logger.startTracing()
+    logger.debug({
       out,
       enabled: this.config.enabled,
       isActivated: this.isActivated,
       shouldCancelWhenOutside: this.shouldCancelWhenOutside
-    })}`)
+    })
     if (
       this.config.enabled &&
       this.isActivated &&
@@ -274,17 +291,19 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     ) {
       this.sendEvent({ newState: this.currentState, oldState: this.currentState });
     }
+    stopTracing()
   }
 
   public onPointerEnter(e: IncomingEvent): void {
-    this.logger.info("onPointerEnter")
+    const stopTracing = this.logger.cloneAndJoinPrefix("onPointerEnter").startTracing()
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e)
     }
+    stopTracing()
   }
 
   public onPointerOut(e: IncomingEvent): void {
-    this.logger.info("onPointerOut")
+    const stopTracing = this.logger.cloneAndJoinPrefix("onPointerOut").startTracing()
     if (this.shouldCancelWhenOutside) {
       switch (this.currentState) {
         case State.ACTIVE:
@@ -294,33 +313,38 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
           this.fail();
           break;
       }
+      stopTracing()
       return;
     }
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e);
     }
+    stopTracing()
   }
 
   public onPointerCancel(e: IncomingEvent): void {
-    this.logger.info("onPointerCancel")
+    const stopTracing = this.logger.cloneAndJoinPrefix("onPointerCancel").startTracing()
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e);
     }
     this.cancel();
     this.reset();
+    stopTracing()
   }
 
   public onPointerOutOfBounds(e: IncomingEvent): void {
-    this.logger.info("onPointerOutOfBounds")
+    const stopTracing = this.logger.cloneAndJoinPrefix("onPointerOutOfBounds").startTracing()
     this.tryToSendMoveEvent(true);
     if (this.config.needsPointerData) {
       this.sendTouchEvent(e);
     }
+    stopTracing()
   }
 
   public onViewAttached(view: View) {
-    this.logger.info("onViewAttached")
+    const stopTracing = this.logger.cloneAndJoinPrefix("onViewAttached").startTracing()
     this.view = view
+    stopTracing()
   }
 
   public getTag(): number {
@@ -336,11 +360,15 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   public begin(): void {
-    this.logger.info("begin")
-    if (!this.isWithinHitSlop()) return;
+    const stopTracing = this.logger.cloneAndJoinPrefix("begin").startTracing()
+    if (!this.isWithinHitSlop()) {
+      stopTracing()
+      return;
+    }
     if (this.currentState === State.UNDETERMINED) {
       this.moveToState(State.BEGAN);
     }
+    stopTracing()
   }
 
   private isWithinHitSlop(): boolean {
@@ -413,15 +441,20 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   public activate(): void {
-    this.logger.info("activate")
-    if (!this.config.manualActivation || this.currentState === State.UNDETERMINED || this.currentState === State.BEGAN) {
+    const stopTracing = this.logger.cloneAndJoinPrefix("activate").startTracing()
+    if (!this.config.manualActivation || this.currentState === State.UNDETERMINED ||
+      this.currentState === State.BEGAN) {
       this.moveToState(State.ACTIVE)
     }
+    stopTracing()
   }
 
   protected moveToState(state: State) {
-    this.logger.info(`moveToState ${getStateName(state)}`)
-    if (state === this.currentState) return;
+    const stopTracing = this.logger.cloneAndJoinPrefix(`moveToState ${getStateName(state)}`).startTracing()
+    if (state === this.currentState) {
+      stopTracing()
+      return;
+    }
     const oldState = this.currentState
     this.currentState = state;
     if (this.tracker.getTrackedPointersCount() > 0 && this.config.needsPointerData && this.isFinished()) {
@@ -433,6 +466,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     if (!this.isEnabled() && this.isFinished()) {
       this.currentState = State.UNDETERMINED;
     }
+    stopTracing()
   }
 
   private isFinished() {
@@ -522,7 +556,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   public cancel(): void {
-    this.logger.info(`cancel`)
+    const stopTracing = this.logger.cloneAndJoinPrefix(`cancel`).startTracing()
     if (
       this.currentState === State.ACTIVE ||
         this.currentState === State.UNDETERMINED ||
@@ -531,6 +565,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
       this.onCancel();
       this.moveToState(State.CANCELLED);
     }
+    stopTracing()
   }
 
   protected onCancel(): void {
@@ -546,11 +581,14 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     return this.currentState
   }
 
-  public sendEvent({newState, oldState}: {
+  public sendEvent({ newState, oldState }: {
     oldState: State,
     newState: State
   }): void {
-    const logger = this.logger.cloneWithPrefix(`sendEvent(newState=${getStateName(newState)}, oldState=${getStateName(oldState)})`)
+    const logger =
+      this.logger.cloneAndJoinPrefix(`sendEvent`)
+    const stopTracing = logger.startTracing()
+    logger.debug({ tag: this.getTag(), newState, oldState })
     const stateChangeEvent = this.createStateChangeEvent(newState, oldState);
     if (this.lastSentState !== newState) {
       this.lastSentState = newState;
@@ -562,6 +600,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
       logger.debug("calling onGestureHandlerEvent")
       this.eventDispatcher.onGestureHandlerEvent(stateChangeEvent);
     }
+    stopTracing()
   }
 
   private createStateChangeEvent(newState: State, oldState: State): GestureStateChangeEvent {
@@ -579,8 +618,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 {
@@ -588,19 +633,21 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   shouldWaitForHandlerFailure(handler: GestureHandler): boolean {
-    if (handler === this)
+    if (handler === this) {
       return false;
+    }
     return this.interactionManager.shouldWaitForHandlerFailure(this, handler);
   }
 
   shouldRequireToWaitForFailure(handler: GestureHandler): boolean {
-    if (handler === this)
+    if (handler === this) {
       return false;
+    }
     return this.interactionManager.shouldRequireHandlerToWaitForFailure(this, handler);
   }
 
   shouldWaitFor(otherHandler: GestureHandler): boolean {
-    const logger = this.logger.cloneWithPrefix(`shouldWaitFor(${otherHandler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`shouldWaitFor(${otherHandler.getTag()})`)
     const result = (
       this !== otherHandler &&
         (this.shouldWaitForHandlerFailure(otherHandler) ||
@@ -611,7 +658,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   reset(): void {
-    this.logger.info("reset")
+    const stopTracing = this.logger.cloneAndJoinPrefix("reset").startTracing()
     this.tracker.resetTracker();
     this.onReset();
     this.resetProgress();
@@ -619,6 +666,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
     // manager.resetManager()
     // );
     this.currentState = State.UNDETERMINED;
+    stopTracing()
   }
 
   isAwaiting(): boolean {
@@ -638,7 +686,7 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   fail(): void {
-    this.logger.info('fail')
+    const stopTracing = this.logger.cloneAndJoinPrefix('fail').startTracing()
     if (
       this.currentState === State.ACTIVE ||
         this.currentState === State.BEGAN
@@ -646,11 +694,13 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
       this.moveToState(State.FAILED);
     }
     this.resetProgress();
+    stopTracing()
   }
 
   shouldBeCancelledByOther(otherHandler: GestureHandler): boolean {
-    if (otherHandler === this)
+    if (otherHandler === this) {
       return false;
+    }
     return this.interactionManager.shouldHandlerBeCancelledBy(this, otherHandler);
   }
 
@@ -659,11 +709,15 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   shouldRecognizeSimultaneously(otherHandler: GestureHandler): boolean {
-    this.logger.cloneWithPrefix(`shouldRecognizeSimultaneously(${otherHandler.getTag()})`).debug("")
+    const stopTracing =
+      this.logger.cloneAndJoinPrefix(`shouldRecognizeSimultaneously(${otherHandler.getTag()})`).startTracing()
     if (otherHandler === this) {
+      stopTracing
       return true;
     }
-    return this.interactionManager.shouldRecognizeSimultaneously(this, otherHandler);
+    const result = this.interactionManager.shouldRecognizeSimultaneously(this, otherHandler);
+    stopTracing()
+    return result;
   }
 
   public getPointerType(): PointerType {
@@ -675,10 +729,11 @@ export abstract class GestureHandler<TGestureConfig extends GestureConfig = Gest
   }
 
   public end() {
-    this.logger.info("end")
+    const stopTracing = this.logger.cloneAndJoinPrefix("end").startTracing()
     if (this.currentState === State.BEGAN || this.currentState === State.ACTIVE) {
       this.moveToState(State.END);
     }
     this.resetProgress();
+    stopTracing()
   }
 }

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

@@ -9,11 +9,15 @@ export class GestureHandlerOrchestrator {
   private handlersToCancel: GestureHandler[] = []
   private activationIndex: number = 0
 
-  constructor(private logger: RNGHLogger) {
+  private logger: RNGHLogger
+
+  constructor(logger: RNGHLogger) {
+    this.logger = logger.cloneAndJoinPrefix("GestureHandlerOrchestrator")
   }
 
   public onHandlerStateChange(handler: GestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean) {
-    const logger = this.logger.cloneWithPrefix(`onHandlerStateChange(handler=${handler.getTag()}, newState=${getStateName(newState)}, oldState=${getStateName(oldState)})`)
+    const logger =
+      this.logger.cloneAndJoinPrefix(`onHandlerStateChange(handler=${handler.getTag()}, newState=${getStateName(newState)}, oldState=${getStateName(oldState)})`)
     logger.debug("start")
 
     if (!handler.isEnabled() && !sendIfDisabled) {
@@ -73,7 +77,7 @@ export class GestureHandlerOrchestrator {
   }
 
   private tryActivate(handler: GestureHandler): void {
-    const logger = this.logger.cloneWithPrefix(`tryActivate(${handler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`tryActivate(${handler.getTag()})`)
     logger.debug({
       gestureHandlers: this.gestureHandlers.map(gh => gh.getTag()),
       awaitingHandlers: Array.from(this.awaitingHandlers).map(gh => gh.getTag()),
@@ -123,7 +127,7 @@ export class GestureHandlerOrchestrator {
   }
 
   private hasOtherHandlerToWaitFor(handler: GestureHandler): boolean {
-    const logger = this.logger.cloneWithPrefix(`hasOtherHandlerToWaitFor(handler=${handler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`hasOtherHandlerToWaitFor(handler=${handler.getTag()})`)
     for (const otherHandler of this.gestureHandlers) {
       if (otherHandler === handler) {
         return false
@@ -138,7 +142,7 @@ export class GestureHandlerOrchestrator {
   }
 
   private addAwaitingHandler(handler: GestureHandler) {
-    const logger = this.logger.cloneWithPrefix(`addAwaitingHandler(handlerTag=${handler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`addAwaitingHandler(handlerTag=${handler.getTag()})`)
     logger.debug({ awaitingHandlers: this.awaitingHandlers })
     if (!this.awaitingHandlers.has(handler)) {
       this.awaitingHandlers.add(handler)
@@ -156,11 +160,12 @@ export class GestureHandlerOrchestrator {
     return true
   }
 
-  private shouldHandlerBeCancelledByOtherHandler({handler, otherHandler}: {
+  private shouldHandlerBeCancelledByOtherHandler({ handler, otherHandler }: {
     handler: GestureHandler,
     otherHandler: GestureHandler
   }): boolean {
-    const logger = this.logger.cloneWithPrefix(`shouldHandlerBeCancelledByOtherHandler(${handler.getTag()}, ${otherHandler.getTag()})`)
+    const logger =
+      this.logger.cloneAndJoinPrefix(`shouldHandlerBeCancelledByOtherHandler(${handler.getTag()}, ${otherHandler.getTag()})`)
     if (this.canRunSimultaneously(handler, otherHandler)) {
       logger.debug("false")
       return false;
@@ -176,7 +181,7 @@ export class GestureHandlerOrchestrator {
   }
 
   private canRunSimultaneously(handlerA: GestureHandler, handlerB: GestureHandler) {
-    const logger = this.logger.cloneWithPrefix("canRunSimultaneously")
+    const logger = this.logger.cloneAndJoinPrefix("canRunSimultaneously")
     const result = handlerA === handlerB
       || handlerA.shouldRecognizeSimultaneously(handlerB)
       || handlerB.shouldRecognizeSimultaneously(handlerA)
@@ -275,7 +280,7 @@ export class GestureHandlerOrchestrator {
   }
 
   private cleanupAwaitingHandlers(handler: GestureHandler): void {
-    const logger = this.logger.cloneWithPrefix(`cleanupAwaitingHandlers(handler=${handler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`cleanupAwaitingHandlers(handler=${handler.getTag()})`)
     logger.debug({ awaitingHandlers: this.awaitingHandlers })
     for (const awaitingHandler of this.awaitingHandlers) {
       if (
@@ -297,7 +302,9 @@ export class GestureHandlerOrchestrator {
 
   public registerHandlerIfNotPresent(handler: GestureHandler) {
     this.logger.info(`registerHandlerIfNotPresent(${handler.getTag()})`)
-    if (this.gestureHandlers.includes(handler)) return;
+    if (this.gestureHandlers.includes(handler)) {
+      return;
+    }
     this.gestureHandlers.push(handler);
     handler.setActive(false);
     handler.setAwaiting(false);
@@ -315,7 +322,9 @@ export class GestureHandlerOrchestrator {
   public cancelMouseAndPenGestures(currentHandler: GestureHandler): void {
     this.logger.info("cancelMouseAndPenGestures")
     this.gestureHandlers.forEach((handler: GestureHandler) => {
-      if (handler.getPointerType() !== PointerType.MOUSE && handler.getPointerType() !== PointerType.PEN) return;
+      if (handler.getPointerType() !== PointerType.MOUSE && handler.getPointerType() !== PointerType.PEN) {
+        return;
+      }
 
       if (handler !== currentHandler) {
         handler.cancel();

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

@@ -1,14 +1,17 @@
 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(logger: RNGHLogger) {
-    this.logger = logger.cloneWithPrefix("GestureHandlerRegistry")
+  constructor(viewRegistry: ViewRegistry | undefined, logger: RNGHLogger) {
+    this.logger = logger.cloneAndJoinPrefix("GestureHandlerRegistry")
+    this.viewRegistry = viewRegistry
   }
 
   public addGestureHandler(gestureHandler: GestureHandler) {
@@ -16,7 +19,7 @@ export class GestureHandlerRegistry {
   }
 
   public bindGestureHandlerWithView(gestureHandlerTag: number, view: View) {
-    this.logger.cloneWithPrefix("bindGestureHandlerWithView").debug({gestureHandlerTag, viewTag: view.getTag()})
+    this.logger.cloneAndJoinPrefix("bindGestureHandlerWithView").debug({gestureHandlerTag, viewTag: view.getTag()})
     const viewTag = view.getTag()
     if (!this.gestureHandlersByViewTag.has(viewTag))
       this.gestureHandlersByViewTag.set(viewTag, new Set())
@@ -29,6 +32,31 @@ export class GestureHandlerRegistry {
     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/core/InteractionManager.ts

@@ -9,7 +9,7 @@ export class InteractionManager {
   private logger: RNGHLogger
 
   constructor(logger: RNGHLogger) {
-    this.logger = logger.cloneWithPrefix("InteractionManager")
+    this.logger = logger.cloneAndJoinPrefix("InteractionManager")
   }
 
   public configureInteractions(handler: GestureHandler, config: Config) {
@@ -60,7 +60,7 @@ export class InteractionManager {
     handler: GestureHandler,
     otherHandler: GestureHandler
   ): boolean {
-    const logger = this.logger.cloneWithPrefix(`shouldWaitForHandlerFailure(${handler.getTag()}, ${otherHandler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`shouldWaitForHandlerFailure(${handler.getTag()}, ${otherHandler.getTag()})`)
     const waitFor = this.waitForRelations.get(
       handler.getTag()
     );
@@ -85,7 +85,7 @@ export class InteractionManager {
     handler: GestureHandler,
     otherHandler: GestureHandler
   ): boolean {
-    const logger = this.logger.cloneWithPrefix(`shouldRecognizeSimultaneously(${handler.getTag()}, ${otherHandler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`shouldRecognizeSimultaneously(${handler.getTag()}, ${otherHandler.getTag()})`)
     const simultaneousHandlers: number[] | undefined =
       this.simultaneousRelations.get(handler.getTag());
     if (!simultaneousHandlers) {
@@ -122,7 +122,7 @@ export class InteractionManager {
     handler: GestureHandler,
     otherHandler: GestureHandler
   ): boolean {
-    const logger = this.logger.cloneWithPrefix(`shouldHandlerBeCancelledBy(handler=${handler.getTag()}, otherHandler=${otherHandler.getTag()})`)
+    const logger = this.logger.cloneAndJoinPrefix(`shouldHandlerBeCancelledBy(handler=${handler.getTag()}, otherHandler=${otherHandler.getTag()})`)
     // We check constructor name instead of using `instanceof` in order do avoid circular dependencies
     // const isNativeHandler =
     //   otherHandler.constructor.name === 'NativeViewGestureHandler';

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

@@ -0,0 +1,26 @@
+export class Multiset<T> {
+  private multiplicityByElement: Map<T, number> = new Map();
+  private elements: T[] = [];
+
+  add(element: T) {
+    const count = this.multiplicityByElement.get(element) || 0;
+    if (count === 0) {
+      this.elements.push(element);
+    }
+    this.multiplicityByElement.set(element, count + 1);
+  }
+
+  remove(element: T) {
+    const count = this.multiplicityByElement.get(element) || 0;
+    if (count > 1) {
+      this.multiplicityByElement.set(element, count - 1);
+    } else {
+      this.multiplicityByElement.delete(element);
+      this.elements = this.elements.filter(v => v !== element);
+    }
+  }
+
+  getElements() {
+    return this.elements;
+  }
+}

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

@@ -1,12 +1,16 @@
 export type RNGHLoggerMessage = string | Object
 
 export interface RNGHLogger {
-  info(msg: string): void;
-
-  cloneWithPrefix(prefix: string): RNGHLogger;
+  cloneAndJoinPrefix(prefix: string): RNGHLogger;
 
   debug(msg: RNGHLoggerMessage);
 
+  info(msg: string): void;
+
+  warn(warn: string);
+
   error(msg: string);
+
+  startTracing(): () => void
 }
 

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

@@ -0,0 +1,7 @@
+import { Tag, View } from "./View"
+
+export interface ViewRegistry {
+  getViewByTag(viewTag: Tag): View | undefined
+  save(view: View): void
+  deleteByTag(viewTag: Tag): void
+}

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

@@ -10,4 +10,6 @@ export * from "./InteractionManager"
 export * from "./PointerTracker"
 export * from "./RNGHError"
 export * from "./State"
-export * from "./GestureHandlerRegistry"
+export * from "./GestureHandlerRegistry"
+export * from "./ViewRegistry"
+export * from './Multiset'

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

@@ -28,7 +28,15 @@ const DIAGONAL_DEVIATION_COSINE = coneToDeviation(90 - DEFAULT_ALIGNMENT_CONE);
 
 export class FlingGestureHandler extends GestureHandler {
   constructor(deps: GestureHandlerDependencies) {
-    super({ ...deps, logger: deps.logger.cloneWithPrefix("FlingGestureHandler") })
+    super({ ...deps, logger: deps.logger.cloneAndJoinPrefix("FlingGestureHandler") })
+  }
+
+  override getName(): string {
+    return "FlingGestureHandler"
+  }
+
+  override isGestureContinuous(): boolean {
+    return true
   }
 
   getDefaultConfig() {
@@ -65,7 +73,7 @@ export class FlingGestureHandler extends GestureHandler {
   }
 
   private tryEndFling(): boolean {
-    const logger = this.logger.cloneWithPrefix("tryEndFling")
+    const logger = this.logger.cloneAndJoinPrefix("tryEndFling")
     const velocityVector = this.tracker.getVelocity(this.keyPointer);
 
     const getAlignment = (
@@ -154,7 +162,7 @@ export class FlingGestureHandler extends GestureHandler {
   }
 
   private pointerMoveAction(event: IncomingEvent): void {
-    this.logger.cloneWithPrefix("pointerMoveAction").info(JSON.stringify(event))
+    this.logger.cloneAndJoinPrefix("pointerMoveAction").info(JSON.stringify(event))
     this.tracker.track(event);
 
     if (this.currentState !== State.BEGAN) {
@@ -187,7 +195,7 @@ export class FlingGestureHandler extends GestureHandler {
   }
 
   private onUp(event: IncomingEvent): void {
-    const logger = this.logger.cloneWithPrefix("onUp")
+    const logger = this.logger.cloneAndJoinPrefix("onUp")
     logger.info("start")
     if (this.currentState === State.BEGAN) {
       this.endFling();