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

package/harmony/gesture_handler/src/main/ets/GestureHandlerArkUIAdapter.ts

@@ -1,203 +0,0 @@
-import { Point } from "@rnoh/react-native-openharmony/ts"
-import { GestureHandler } from "./GestureHandler"
-import { AdaptedEvent, EventType, PointerType, TouchEventType, Touch } from "./Event"
-import { View } from "./View"
-import { RNGHLogger } from "./RNGHLogger"
-import { TouchEvent, TouchType, TouchObject } from "./types"
-
-export class GestureHandlerArkUIAdapter {
-  private activePointerIds = new Set<number>()
-  private pointersIdInBounds = new Set<number>()
-  private gestureHandler: GestureHandler
-  private view: View
-  private logger: RNGHLogger
-
-  constructor(gestureHandler: GestureHandler, view: View, logger: RNGHLogger) {
-    logger.info("constructor")
-    this.gestureHandler = gestureHandler
-    this.view = view
-    this.logger = logger
-  }
-
-  handleTouch(e: TouchEvent) {
-    for (const changedTouch of e.changedTouches) {
-      if (this.shouldSkipTouch(changedTouch)) continue;
-      const wasInBounds = this.pointersIdInBounds.has(changedTouch.id)
-      const isInBounds = this.isInBounds({ x: changedTouch.windowX, y: changedTouch.windowY })
-      this.logger.info(`handleTouch: ${JSON.stringify({ type: changedTouch.type, wasInBounds, isInBounds })}`)
-      const adaptedEvent = this.adaptTouchEvent(e, changedTouch)
-      switch (adaptedEvent.eventType) {
-        case EventType.DOWN:
-          this.gestureHandler.onPointerDown(adaptedEvent)
-          break;
-        case EventType.ADDITIONAL_POINTER_DOWN:
-          this.gestureHandler.onAdditionalPointerAdd(adaptedEvent)
-          break;
-        case EventType.UP:
-          this.gestureHandler.onPointerUp(adaptedEvent)
-          break;
-        case EventType.ADDITIONAL_POINTER_UP:
-          this.gestureHandler.onAdditionalPointerRemove(adaptedEvent)
-          break;
-        case EventType.MOVE:
-          if (!wasInBounds && !isInBounds)
-            this.gestureHandler.onPointerOutOfBounds(adaptedEvent)
-          else
-            this.gestureHandler.onPointerMove(adaptedEvent)
-          break;
-        case EventType.ENTER:
-          this.gestureHandler.onPointerEnter(adaptedEvent)
-          break;
-        case EventType.OUT:
-          this.gestureHandler.onPointerOut(adaptedEvent)
-          break;
-        case EventType.CANCEL:
-          this.gestureHandler.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): AdaptedEvent {
-    const xAbsolute = changedTouch.windowX
-    const yAbsolute = changedTouch.windowY
-
-    const eventType = this.mapTouchTypeToEventType(
-      changedTouch.type,
-      this.activePointerIds.size,
-      this.isInBounds({ x: xAbsolute, y: yAbsolute }),
-      this.pointersIdInBounds.has(changedTouch.id)
-    )
-    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.pointersIdInBounds.add(pointerId)
-        break;
-      case TouchType.Move:
-        if (this.isInBounds({ x, y }))
-          this.pointersIdInBounds.add(pointerId)
-        else
-          this.pointersIdInBounds.delete(pointerId)
-        break;
-      case TouchType.Up:
-        this.pointersIdInBounds.delete(pointerId)
-        break;
-      case TouchType.Cancel:
-        this.pointersIdInBounds.delete(pointerId)
-        break;
-    }
-  }
-
-  private isInBounds(point: Point): boolean {
-    const x = point.x
-    const y = point.y
-    const rect = this.view.getBoundingRect()
-    const result = x >= rect.x && x <= (rect.x + rect.width) && y >= rect.y && y <= (rect.y + rect.height)
-    return result;
-  }
-
-  private updateActivePointers(touchType: TouchType, pointerId: number): void {
-    switch (touchType) {
-      case TouchType.Down:
-        this.activePointerIds.add(pointerId)
-      case TouchType.Up:
-        this.activePointerIds.delete(pointerId)
-      case TouchType.Cancel:
-        this.activePointerIds.clear()
-      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,
-    activePointersCounter: number,
-    isCurrentlyInBounds: boolean,
-    wasInBounds: boolean
-  ): EventType {
-    switch (touchType) {
-      case TouchType.Down:
-        if (activePointersCounter > 0)
-          return EventType.ADDITIONAL_POINTER_DOWN
-        else
-          return EventType.DOWN
-      case TouchType.Up:
-        if (activePointersCounter > 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/GestureHandlerFactory.ts

@@ -1,45 +0,0 @@
-import { GestureHandlerOrchestrator } from './GestureHandlerOrchestrator';
-import { GestureHandler, GestureHandlerDependencies, ScrollLocker } from "./GestureHandler"
-import { PointerTracker } from './PointerTracker';
-import { RNGHError } from "./RNGHError"
-import { InteractionManager } from './InteractionManager';
-import { RNGHLogger } from './RNGHLogger';
-import { TapGestureHandler } from './TapGestureHandler';
-import { PanGestureHandler } from "./PanGestureHandler"
-import { NativeViewGestureHandler } from "./NativeViewGestureHandler"
-
-
-export class GestureHandlerFactory {
-  private orchestrator: GestureHandlerOrchestrator
-  private interactionManager = new InteractionManager()
-  private factoryLogger: RNGHLogger
-
-  constructor(private logger: RNGHLogger, private scrollLocker: ScrollLocker) {
-    this.factoryLogger = logger.cloneWithPrefix("Factory")
-    this.orchestrator = new GestureHandlerOrchestrator(logger.cloneWithPrefix("Orchestrator"))
-  }
-
-  create(handlerName: string, handlerTag: number): GestureHandler {
-    this.factoryLogger.info(`create ${handlerName} with handlerTag: ${handlerTag}`)
-    const deps: GestureHandlerDependencies = {
-      tracker: new PointerTracker(),
-      orchestrator: this.orchestrator,
-      handlerTag,
-      interactionManager: this.interactionManager,
-      logger: this.logger.cloneWithPrefix("GestureHandler"),
-      scrollLocker: this.scrollLocker,
-    }
-    switch (handlerName) {
-      case "TapGestureHandler":
-        return new TapGestureHandler(deps)
-      case "PanGestureHandler":
-        return new PanGestureHandler(deps)
-      case "NativeViewGestureHandler":
-        return new NativeViewGestureHandler(deps)
-      default:
-        const msg = `Unknown handler type: ${handlerName}`
-        this.factoryLogger.info(msg)
-        throw new RNGHError(msg)
-    }
-  }
-}

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

@@ -1,280 +0,0 @@
-import { GestureHandler } from "./GestureHandler"
-import { State } from "./State"
-import { PointerType } from "./Event"
-import { RNGHLogger } from "./RNGHLogger"
-
-export class GestureHandlerOrchestrator {
-  private awaitingHandlers: Set<GestureHandler> = new Set()
-  private gestureHandlers: GestureHandler[] = []
-  private handlersToCancel: GestureHandler[] = []
-  private activationIndex: number = 0
-
-  constructor(private logger: RNGHLogger) {
-  }
-
-  public onHandlerStateChange(handler: GestureHandler, newState: State, oldState: State, sendIfDisabled?: boolean) {
-    this.logger.info("onHandlerStateChange")
-    if (this.shouldCancelStateChange(handler, sendIfDisabled)) return;
-    if (this.isFinishedState(newState)) {
-      this.handleChangingToFinishedState(handler, newState)
-    }
-    if (newState === State.ACTIVE) {
-      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 })
-      }
-    } 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 })
-    }
-    this.cleanUpHandlers(handler)
-  }
-
-  private isFinishedState(state: State) {
-    return [State.END, State.FAILED, State.CANCELLED].includes(state)
-  }
-
-  private shouldCancelStateChange(handler: GestureHandler, sendIfDisabled?: boolean) {
-    const isHandlerDisabled = !handler.isEnabled()
-    return!sendIfDisabled && isHandlerDisabled
-  }
-
-  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 tryActivate(handler: GestureHandler): void {
-    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;
-        }
-      }
-    }
-  }
-
-  private hasOtherHandlerToWaitFor(handler: GestureHandler): boolean {
-    for (const otherHandler of this.gestureHandlers) {
-      if (!this.isFinishedState(otherHandler.getState()) && otherHandler.shouldWaitFor(handler)) {
-        return true
-      }
-    }
-    return false;
-  }
-
-  private addAwaitingHandler(handler: GestureHandler) {
-    if (!this.awaitingHandlers.has(handler)) {
-      this.awaitingHandlers.add(handler)
-      handler.setAwaiting(true)
-      handler.setActivationIndex(this.activationIndex++)
-    }
-  }
-
-  private shouldActivate(handler: GestureHandler) {
-    for (const otherHandler of this.gestureHandlers) {
-      if (this.shouldHandlerBeCancelledByOtherHandler({ handler, otherHandler })) {
-        return false
-      }
-    }
-    return true
-  }
-
-  private shouldHandlerBeCancelledByOtherHandler({handler, otherHandler}: {
-    handler: GestureHandler,
-    otherHandler: GestureHandler
-  }): boolean {
-    if (this.canRunSimultaneously(handler, otherHandler))
-      return false;
-    if (handler !== otherHandler && (handler.isAwaiting() || handler.getState() === State.ACTIVE))
-      return handler.shouldBeCancelledByOther(otherHandler)
-    return this.checkOverlap(handler, otherHandler)
-  }
-
-  private canRunSimultaneously(handlerA: GestureHandler, handlerB: GestureHandler) {
-    return handlerA === handlerB
-      || handlerA.shouldRecognizeSimultaneously(handlerB)
-      || handlerB.shouldRecognizeSimultaneously(handlerA)
-  }
-
-  private checkOverlap(
-    handler: GestureHandler,
-    otherHandler: GestureHandler
-  ): boolean {
-    // If handlers don't have common pointers, default return value is false.
-    // However, if at least on pointer overlaps with both handlers, we return true
-    // This solves issue in overlapping parents example
-
-    // TODO: Find better way to handle that issue, for example by activation order and handler cancelling
-
-    const handlerPointers: number[] = handler.getTrackedPointersID();
-    const otherPointers: number[] = otherHandler.getTrackedPointersID();
-    let overlap = false;
-    handlerPointers.forEach((pointer: number) => {
-      const handlerX: number = handler.getTracker().getLastX(pointer);
-      const handlerY: number = handler.getTracker().getLastY(pointer);
-      if (
-        handler.getView().isPositionInBounds({ x: handlerX, y: handlerY }) &&
-        otherHandler.getView().isPositionInBounds({ x: handlerX, y: handlerY })
-      ) {
-        overlap = true;
-      }
-    });
-    otherPointers.forEach((pointer: number) => {
-      const otherX: number = otherHandler.getTracker().getLastX(pointer);
-      const otherY: number = otherHandler.getTracker().getLastY(pointer);
-      if (
-        handler.getView().isPositionInBounds({ x: otherX, y: otherY }) &&
-        otherHandler.getView().isPositionInBounds({ x: otherX, y: otherY })
-      ) {
-        overlap = true;
-      }
-    });
-    return overlap;
-  }
-
-  private makeActive(handler: GestureHandler): void {
-    handler.setActive(true)
-    handler.setShouldResetProgress(true)
-    handler.setActivationIndex(this.activationIndex++)
-    for (const otherHandler of this.gestureHandlers) {
-      if (this.shouldHandlerBeCancelledByOtherHandler({ handler: otherHandler, otherHandler: handler })) {
-        this.handlersToCancel.push(otherHandler)
-      }
-    }
-    for (let i = this.handlersToCancel.length - 1; i >= 0; --i) {
-      this.handlersToCancel[i]?.cancel();
-    }
-    this.handlersToCancel = []
-    for (const awaitingHandler of this.awaitingHandlers) {
-      if (this.shouldHandlerBeCancelledByOtherHandler({ handler: awaitingHandler, otherHandler: handler })) {
-        awaitingHandler.cancel();
-        awaitingHandler.setAwaiting(true);
-      }
-    }
-    const currentState = handler.getState()
-    handler.sendEvent({ newState: State.ACTIVE, oldState: State.BEGAN })
-    if (currentState !== State.ACTIVE) {
-      handler.sendEvent({ newState: State.END, oldState: State.ACTIVE })
-      if (currentState !== State.END) {
-        handler.sendEvent({ newState: State.UNDETERMINED, oldState: State.END })
-      }
-    }
-    if (handler.isAwaiting()) {
-      handler.setAwaiting(false)
-      this.awaitingHandlers.delete(handler)
-    }
-  }
-
-  private cleanUpHandlers(handler: GestureHandler) {
-    this.cleanUpFinishedHandlers()
-    if (this.awaitingHandlers.has(handler)) {
-      this.cleanupAwaitingHandlers(handler);
-    }
-  }
-
-  private cleanUpFinishedHandlers(): void {
-    for (let i = this.gestureHandlers.length - 1; i >= 0; --i) {
-      const handler = this.gestureHandlers[i];
-      if (!handler) {
-        continue;
-      }
-      if (this.isFinishedState(handler.getState()) && !handler.isAwaiting()) {
-        this.gestureHandlers.splice(i, 1);
-        this.cleanUpHandler(handler);
-      }
-    }
-  }
-
-  private cleanupAwaitingHandlers(handler: GestureHandler): void {
-    for (const awaitingHandler of this.awaitingHandlers) {
-      if (
-        awaitingHandler.isAwaiting() &&
-        awaitingHandler.shouldWaitFor(handler)
-      ) {
-        this.cleanUpHandler(awaitingHandler);
-        this.awaitingHandlers.delete(awaitingHandler)
-      }
-    }
-  }
-
-  private cleanUpHandler(handler: GestureHandler) {
-    handler.reset();
-    handler.setActive(false);
-    handler.setAwaiting(false);
-    handler.setActivationIndex(Number.MAX_VALUE);
-  }
-
-  public registerHandlerIfNotPresent(handler: GestureHandler) {
-    this.logger.info("registerHandlerIfNotPresent")
-    if (this.gestureHandlers.includes(handler)) return;
-    this.gestureHandlers.push(handler);
-    handler.setActive(false);
-    handler.setAwaiting(false);
-    handler.setActivationIndex(Number.MAX_SAFE_INTEGER);
-  }
-
-  /**
-   This function is called when handler receives touchdown event
-   If handler is using mouse or pen as a pointer and any handler receives touch event,
-   mouse/pen event disappears - it doesn't send onPointerCancel nor onPointerUp (and others)
-   This became a problem because handler was left at active state without any signal to end or fail
-   To handle this, when new touch event is received, we loop through active handlers and check which type of
-   pointer they're using. If there are any handler with mouse/pen as a pointer, we cancel them
-   */
-  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 !== currentHandler) {
-        handler.cancel();
-      } else {
-        // Handler that received touch event should have its pointer tracker reset
-        // This allows handler to smoothly change from mouse/pen to touch
-        // The drawback is, that when we try to use mouse/pen one more time, it doesn't send onPointerDown at the first time
-        // so it is required to click two times to get handler to work
-        //
-        // However, handler will receive manually created onPointerEnter that is triggered in EventManager in onPointerMove method.
-        // There may be possibility to use that fact to make handler respond properly to first mouse click
-        handler.getTracker().resetTracker();
-      }
-    });
-  }
-}
-

package/harmony/gesture_handler/src/main/ets/GestureHandlerPackage.ts

@@ -1,22 +0,0 @@
-import {RNPackage, TurboModuleContext, TurboModulesFactory} from '@rnoh/react-native-openharmony/ts';
-import type {TurboModule} from '@rnoh/react-native-openharmony/ts';
-import {RNGestureHandlerModule} from './RNGestureHandlerModule';
-
-class GestureHandlerTurboModulesFactory extends TurboModulesFactory {
-  createTurboModule(name: string): TurboModule | null {
-    if (name === RNGestureHandlerModule.NAME) {
-      return new RNGestureHandlerModule(this.ctx);
-    }
-    return null;
-  }
-
-  hasTurboModule(name: string): boolean {
-    return name === 'RNGestureHandlerModule';
-  }
-}
-
-export class GestureHandlerPackage extends RNPackage {
-  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
-    return new GestureHandlerTurboModulesFactory(ctx);
-  }
-}

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

@@ -1,28 +0,0 @@
-import { GestureHandler } from "./GestureHandler"
-import { View } from "./View"
-
-export class GestureHandlerRegistry {
-  private gestureHandlerByHandlerTag: Map<number, GestureHandler> = new Map()
-  private gestureHandlersByViewTag: Map<number, Set<GestureHandler>> = new Map()
-
-  public addGestureHandler(gestureHandler: GestureHandler) {
-    this.gestureHandlerByHandlerTag.set(gestureHandler.getTag(), gestureHandler)
-  }
-
-  public bindGestureHandlerWithView(gestureHandlerTag: number, view: View) {
-    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 getGestureHandlerByHandlerTag(handlerTag: number): GestureHandler {
-    return this.gestureHandlerByHandlerTag.get(handlerTag)
-  }
-}

package/harmony/gesture_handler/src/main/ets/InteractionManager.ts

@@ -1,109 +0,0 @@
-import { GestureHandler, Handler, GestureConfig as Config } from "./GestureHandler"
-
-export class InteractionManager {
-  private readonly waitForRelations: Map<number, number[]> = new Map()
-  private readonly simultaneousRelations: Map<number, number[]> = new Map()
-
-  public configureInteractions(handler: GestureHandler, config: Config) {
-    this.dropRelationsForHandlerWithTag(handler.getTag());
-
-    if (config.waitFor) {
-      const waitFor: number[] = [];
-      config.waitFor.forEach((otherHandler: Handler): void => {
-        // New API reference
-        if (typeof otherHandler === 'number') {
-          waitFor.push(otherHandler);
-        } else {
-          // Old API reference
-          waitFor.push(otherHandler.handlerTag);
-        }
-      });
-
-      this.waitForRelations.set(handler.getTag(), waitFor);
-    }
-
-    if (config.simultaneousHandlers) {
-      const simultaneousHandlers: number[] = [];
-      config.simultaneousHandlers.forEach((otherHandler: Handler): void => {
-        if (typeof otherHandler === 'number') {
-          simultaneousHandlers.push(otherHandler);
-        } else {
-          simultaneousHandlers.push(otherHandler.handlerTag);
-        }
-      });
-
-      this.simultaneousRelations.set(handler.getTag(), simultaneousHandlers);
-    }
-  }
-
-  public shouldWaitForHandlerFailure(
-    handler: GestureHandler,
-    otherHandler: GestureHandler
-  ): boolean {
-    const waitFor: number[] | undefined = this.waitForRelations.get(
-      handler.getTag()
-    );
-    if (!waitFor) {
-      return false;
-    }
-
-    let shouldWait = false;
-
-    waitFor.forEach((tag: number): void => {
-      if (tag === otherHandler.getTag()) {
-        shouldWait = true;
-        return; //Returns from callback
-      }
-    });
-
-    return shouldWait;
-  }
-
-  public shouldRecognizeSimultaneously(
-    handler: GestureHandler,
-    otherHandler: GestureHandler
-  ): boolean {
-    const simultaneousHandlers: number[] | undefined =
-    this.simultaneousRelations.get(handler.getTag());
-    if (!simultaneousHandlers) {
-      return false;
-    }
-
-    let shouldRecognizeSimultaneously = false;
-
-    simultaneousHandlers.forEach((tag: number): void => {
-      if (tag === otherHandler.getTag()) {
-        shouldRecognizeSimultaneously = true;
-        return;
-      }
-    });
-
-    return shouldRecognizeSimultaneously;
-  }
-
-  public shouldRequireHandlerToWaitForFailure(
-    _handler: GestureHandler,
-    _otherHandler: GestureHandler
-  ): boolean {
-    //TODO: Implement logic
-    return false;
-  }
-
-  public shouldHandlerBeCancelledBy(
-    _handler: GestureHandler,
-    _otherHandler: GestureHandler
-  ): boolean {
-    //TODO: Implement logic
-    return false;
-  }
-
-  public dropRelationsForHandlerWithTag(handlerTag: number): void {
-    this.waitForRelations.delete(handlerTag);
-    this.simultaneousRelations.delete(handlerTag);
-  }
-
-  public reset() {
-    this.waitForRelations.clear();
-    this.simultaneousRelations.clear();
-  }
-}