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

package/harmony/gesture_handler/src/main/ets/rnoh/RNGestureHandlerModule.ts

@@ -1,15 +1,21 @@
 import { TurboModule, TurboModuleContext, Tag } from "@rnoh/react-native-openharmony/ts";
 import { TM } from "../namespace/ts"
-import { GestureHandlerRegistry, State, OutgoingEventDispatcher, RNGHLogger, InteractionManager, ViewRegistry } from '../core';
+import {
+  GestureHandlerRegistry,
+  State,
+  OutgoingEventDispatcher,
+  RNGHLogger,
+  InteractionManager,
+  ViewRegistry
+} from '../core';
 import { GestureHandlerFactory } from "../gesture-handlers"
-import { ViewRegistryArkTS, ViewRegistryCAPI } from './ViewRegistry';
-import { StandardRNGHLogger, FakeRNGHLogger } from './Logger';
+import { RNGHViewRegistry } from './RNGHViewRegistry';
+import { DevelopmentRNGHLogger, ProductionRNGHLogger } from './Logger';
 import { JSEventDispatcher, AnimatedEventDispatcher, ReanimatedEventDispatcher } from './OutgoingEventDispatchers'
-import { RNOHScrollLockerArkTS, RNOHScrollLockerCAPI } from "./RNOHScrollLocker"
-import { RNGHRootTouchHandlerCAPI, RawTouchEvent } from "./RNGHRootTouchHandlerCAPI"
-import { RNGHRootTouchHandlerArkTS } from './RNGHRootTouchHandlerArkTS';
-import { ViewCAPI } from "./View"
-import { FakeRNGestureResponder, RNOHGestureResponder } from "./RNOHGestureResponder"
+import { RNOHScrollLockerCAPI } from "./RNOHScrollLocker"
+import { RNGHRootViewController, RawTouchEvent } from "./RNGHRootViewController"
+import { RNGHView } from "./RNGHView"
+import { RNOHGestureResponder } from "./RNOHGestureResponder"
 
 export enum ActionType {
   REANIMATED_WORKLET = 1,
@@ -20,22 +26,26 @@ export enum ActionType {
 
 
 export class RNGestureHandlerModule extends TurboModule implements TM.RNGestureHandlerModule.Spec {
-  static NAME = "RNGestureHandlerModule"
+  static readonly NAME = "RNGestureHandlerModule"
 
   private gestureHandlerRegistry: GestureHandlerRegistry
   private gestureHandlerFactory: GestureHandlerFactory | undefined = undefined
   private viewRegistry: ViewRegistry | undefined = undefined
   private logger: RNGHLogger
-  private touchHandlerByRootTag = new Map<Tag, RNGHRootTouchHandlerCAPI>()
+  private cleanLogger: RNGHLogger
+  private rootViewControllerByRootTag = new Map<Tag, RNGHRootViewController>()
   private interactionManager: InteractionManager
 
-  constructor(ctx: TurboModuleContext) {
+  constructor(ctx: TurboModuleContext, isDevModeEnabled: boolean = false) {
     super(ctx)
-    const debug = false
-    this.logger = debug ? new StandardRNGHLogger(ctx.logger, "RNGH") : new FakeRNGHLogger()
-    this.interactionManager = new InteractionManager(this.logger)
-    this.gestureHandlerRegistry = new GestureHandlerRegistry(this.viewRegistry, this.logger)
-
+    this.cleanLogger =
+      isDevModeEnabled && ctx.isDebugModeEnabled ? new DevelopmentRNGHLogger(ctx.logger, "RNGH") :
+        new ProductionRNGHLogger(ctx.logger, "RNGH")
+    this.logger = this.cleanLogger.cloneAndJoinPrefix("RNGestureHandlerModule")
+    const logger = this.logger.cloneAndJoinPrefix("constructor")
+    const stopTracing = logger.startTracing()
+    this.interactionManager = new InteractionManager(this.cleanLogger)
+    this.gestureHandlerRegistry = new GestureHandlerRegistry(this.viewRegistry, this.cleanLogger)
     if (this.ctx.rnInstance.getArchitecture() === "C_API") {
       this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::TOUCH_EVENT", (e: any) => {
         this.onTouch(e)
@@ -44,60 +54,67 @@ export class RNGestureHandlerModule extends TurboModule implements TM.RNGestureH
         this.onGHRootCreated(rootTag)
       })
       this.ctx.rnInstance.cppEventEmitter.subscribe("RNGH::CANCEL_TOUCHES", (rootTag: any) => {
-        const touchHandler = this.touchHandlerByRootTag.get(rootTag)
+        const touchHandler = this.rootViewControllerByRootTag.get(rootTag)
         touchHandler?.cancelTouches()
       })
     }
+    stopTracing()
   }
 
   /**
-   * @architecture: C-API
    * Called from C++.
    */
   private onGHRootCreated(rootTag: Tag) {
-    this.touchHandlerByRootTag.set(rootTag, new RNGHRootTouchHandlerCAPI(this.logger, new RNGHRootTouchHandlerArkTS(rootTag, this.viewRegistry, this.gestureHandlerRegistry, this.logger)));
+    const stopTracing = this.logger.cloneAndJoinPrefix("onGHRootCreated").startTracing()
+    this.rootViewControllerByRootTag.set(rootTag, new RNGHRootViewController(this.logger, this.gestureHandlerRegistry));
+    stopTracing()
   }
 
   /**
-   * @architecture: C-API
    * Called from C++.
    */
   private onTouch(e: RawTouchEvent & { rootTag: Tag }) {
-    const logger = this.logger.cloneWithPrefix("onTouch")
-    if (!(this.viewRegistry instanceof ViewRegistryCAPI)) {
-      logger.error("Expected ViewRegistryCAPI")
-      return;
-    }
-    const touchHandler = this.touchHandlerByRootTag.get(e.rootTag)
-    if (!touchHandler) {
-      logger.error(`Couldn't find touch handler for gesture root tag: ${e.rootTag}`)
-      return;
-    }
-    // update view registry
-    e.touchableViews.forEach(touchableView => {
-      const view = this.viewRegistry.getViewByTag(touchableView.tag)
-      if (view) {
-        if (!(view instanceof ViewCAPI)) {
-          logger.error(`Expected ViewCAPI`)
-          return
-        }
-        view.updateBoundingBox(touchableView)
-        view.setButtonRole(touchableView.buttonRole)
-      } else {
-        this.viewRegistry.save(new ViewCAPI(touchableView))
+    const logger = this.logger.cloneAndJoinPrefix("onTouch")
+    const stopTracing = logger.startTracing();
+    (() => {
+      if (!(this.viewRegistry instanceof RNGHViewRegistry)) {
+        logger.error("Expected ViewRegistryCAPI")
+        return;
+      }
+      const rootViewController = this.rootViewControllerByRootTag.get(e.rootTag)
+      if (!rootViewController) {
+        logger.error(`Couldn't find a rootViewController for a gesture root tag: ${e.rootTag}`)
+        return;
       }
-    })
-    // relay touch
-    touchHandler.handleTouch(e, e.touchableViews.map(({tag}) => this.viewRegistry.getViewByTag(tag)));
+      // update view registry
+      e.touchableViews.forEach(touchableView => {
+        const view = this.viewRegistry.getViewByTag(touchableView.tag)
+        if (view) {
+          if (!(view instanceof RNGHView)) {
+            logger.error(`Expected ViewCAPI`)
+            return
+          }
+          view.updateBoundingBox(touchableView)
+          view.setButtonRole(touchableView.buttonRole)
+        } else {
+          this.viewRegistry.save(new RNGHView(touchableView))
+        }
+      })
+      rootViewController.handleTouch(e, e.touchableViews.map(({ tag }) => this.viewRegistry.getViewByTag(tag)));
+    })()
+    stopTracing()
   }
 
   // -------------------------------------------------------------------------------------------------------------------
 
   public install() {
-    this.viewRegistry = this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new ViewRegistryArkTS(this.ctx.descriptorRegistry) : new ViewRegistryCAPI()
-    const scrollLocker = this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new RNOHScrollLockerArkTS(this.ctx.rnInstance) : new RNOHScrollLockerCAPI(this.ctx.rnInstance, this.logger);
-    const rnGestureResponder =  this.ctx.rnInstance.getArchitecture() === "ARK_TS" ? new FakeRNGestureResponder() : new RNOHGestureResponder(this.ctx.rnInstance)
-    this.gestureHandlerFactory = new GestureHandlerFactory(this.logger, scrollLocker, this.interactionManager, rnGestureResponder)
+    const stopTracing = this.ctx.logger.clone("install").startTracing()
+    this.viewRegistry = new RNGHViewRegistry()
+    const scrollLocker = new RNOHScrollLockerCAPI(this.ctx.rnInstance, this.cleanLogger);
+    const rnGestureResponder = new RNOHGestureResponder(this.ctx.rnInstance)
+    this.gestureHandlerFactory =
+      new GestureHandlerFactory(this.cleanLogger, scrollLocker, this.interactionManager, rnGestureResponder)
+    stopTracing()
     return true
   }
 
@@ -106,16 +123,20 @@ export class RNGestureHandlerModule extends TurboModule implements TM.RNGestureH
     handlerTag: number,
     config: Readonly<Record<string, unknown>>
   ) {
-    const logger = this.logger.cloneWithPrefix("createGestureHandler")
-    if (!this.gestureHandlerFactory) {
-      this.ctx.logger.error("Trying to create a gesture handler before creating gesture handler factory")
-      return
-    }
-    logger.debug({ handlerName, handlerTag, config })
-    const gestureHandler = this.gestureHandlerFactory.create(handlerName, handlerTag)
-    this.gestureHandlerRegistry.addGestureHandler(gestureHandler)
-    this.interactionManager.configureInteractions(gestureHandler, config);
-    gestureHandler.updateGestureConfig(config)
+    const logger = this.logger.cloneAndJoinPrefix("createGestureHandler")
+    const stopTracing = logger.startTracing();
+    (() => {
+      if (!this.gestureHandlerFactory) {
+        logger.error("Trying to create a gesture handler before creating gesture handler factory")
+        return
+      }
+      logger.debug({ handlerName, handlerTag, config })
+      const gestureHandler = this.gestureHandlerFactory.create(handlerName, handlerTag)
+      this.gestureHandlerRegistry.addGestureHandler(gestureHandler)
+      this.interactionManager.configureInteractions(gestureHandler, config);
+      gestureHandler.updateGestureConfig(config)
+    })()
+    stopTracing()
   }
 
   public attachGestureHandler(
@@ -123,43 +144,55 @@ export class RNGestureHandlerModule extends TurboModule implements TM.RNGestureH
     viewTag: number,
     actionType: ActionType
   ) {
-    const eventDispatcher = this.createEventDispatcher(actionType, viewTag)
-    if (!eventDispatcher) {
-      this.ctx.logger.error("RNGH: Couldn't create EventDispatcher")
-      return
-    }
-    const viewRegistry = this.viewRegistry
-    let view = this.viewRegistry.getViewByTag(viewTag)
-    if (!view && viewRegistry instanceof ViewRegistryCAPI) {
-      view = new ViewCAPI({
-        tag: viewTag,
-        x: 0,
-        y: 0,
-        width: 0,
-        height: 0,
-        buttonRole: false
+    const logger = this.logger.cloneAndJoinPrefix("attachGestureHandler")
+    const stopTracing = logger.startTracing();
+    (() => {
+      const eventDispatcher = this.createEventDispatcher(actionType, viewTag)
+      if (!eventDispatcher) {
+        logger.error("RNGH: Couldn't create EventDispatcher")
+        return
+      }
+      const viewRegistry = this.viewRegistry
+      let view = this.viewRegistry.getViewByTag(viewTag)
+      if (!view && viewRegistry instanceof RNGHViewRegistry) {
+        view = new RNGHView({
+          tag: viewTag,
+          x: 0,
+          y: 0,
+          width: 0,
+          height: 0,
+          buttonRole: false
+        })
+        viewRegistry.save(view)
+      }
+      if (!view) {
+        logger.error("Expected view")
+        return;
+      }
+      this.gestureHandlerRegistry.bindGestureHandlerWithView(handlerTag, view)
+      this.gestureHandlerRegistry.getGestureHandlersByViewTag(view.getTag()).forEach((handler) => {
+        if (handler.isGestureContinuous() && eventDispatcher instanceof JSEventDispatcher) {
+          logger.warn(`Using JSEventDispatcher for a continuous gesture (${handler.getName()}). Gesture-driven animations may not be smooth. Consider using Animated.event.`)
+        }
       })
-      viewRegistry.save(view)
-    }
-    if (!view) {
-      this.ctx.logger.error("Expected view")
-      return;
-    }
-    this.gestureHandlerRegistry.bindGestureHandlerWithView(handlerTag, view)
-    this.gestureHandlerRegistry
-      .getGestureHandlerByHandlerTag(handlerTag)
-      .setEventDispatcher(eventDispatcher)
+      this.gestureHandlerRegistry
+        .getGestureHandlerByHandlerTag(handlerTag)
+        .setEventDispatcher(eventDispatcher)
+    })()
+    stopTracing()
   }
 
   private createEventDispatcher(actionType: ActionType, viewTag: number): OutgoingEventDispatcher | null {
     switch (actionType) {
       case ActionType.REANIMATED_WORKLET:
-        return new ReanimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('ReanimatedEventDispatcher'), viewTag)
+        return new ReanimatedEventDispatcher(this.ctx.rnInstance,
+          this.cleanLogger, viewTag)
       case ActionType.NATIVE_ANIMATED_EVENT:
-        return new AnimatedEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('AnimatedEventDispatcher'), viewTag)
+        return new AnimatedEventDispatcher(this.ctx.rnInstance,
+          this.cleanLogger, viewTag)
       case ActionType.JS_FUNCTION_OLD_API:
       case ActionType.JS_FUNCTION_NEW_API:
-        return new JSEventDispatcher(this.ctx.rnInstance, this.logger.cloneWithPrefix('JSEventDispatcher'));
+        return new JSEventDispatcher(this.ctx.rnInstance, this.cleanLogger);
     }
   }
 
@@ -167,22 +200,26 @@ export class RNGestureHandlerModule extends TurboModule implements TM.RNGestureH
     handlerTag: number,
     newConfig: Readonly<Record<string, unknown>>
   ) {
+    const stopTracing = this.logger.cloneAndJoinPrefix("updateGestureHandler").startTracing()
     const gestureHandler = this.gestureHandlerRegistry.getGestureHandlerByHandlerTag(handlerTag)
     this.interactionManager.configureInteractions(gestureHandler, newConfig);
     gestureHandler.updateGestureConfig(newConfig)
+    stopTracing()
   }
 
   public dropGestureHandler(handlerTag: number) {
+    const stopTracing = this.logger.cloneAndJoinPrefix("dropGestureHandler").startTracing()
     this.interactionManager.dropRelationsForHandlerWithTag(handlerTag)
     this.gestureHandlerRegistry.removeGestureHandlerByHandlerTag(handlerTag)
+    stopTracing()
   }
 
   public handleSetJSResponder(tag: number, blockNativeResponder: boolean) {
-    this.warn("handleSetJSResponder is not implemented")
+    this.logger.cloneAndJoinPrefix("handleSetJSResponder").warn("not implemented")
   }
 
   public handleClearJSResponder() {
-    this.warn("handleClearJSResponder is not implemented")
+    this.logger.cloneAndJoinPrefix("handleClearJSResponder").warn("not implemented")
   }
 
   public flushOperations() {
@@ -190,9 +227,6 @@ export class RNGestureHandlerModule extends TurboModule implements TM.RNGestureH
   }
 
   // -------------------------------------------------------------------------------------------------------------------
-  protected warn(message: string) {
-    this.ctx.logger.warn("RNGH: " + message)
-  }
 
   public getGestureHandlerRegistry() {
     return this.gestureHandlerRegistry
@@ -204,7 +238,7 @@ export class RNGestureHandlerModule extends TurboModule implements TM.RNGestureH
 
   public getViewRegistry() {
     if (!this.viewRegistry) {
-      this.logger.info("Tried to get viewRegistry before it was initialized")
+      this.logger.error("Tried to get viewRegistry before it was initialized")
       throw new Error("Tried to get viewRegistry before it was initialized")
     }
     return this.viewRegistry

package/harmony/gesture_handler/src/main/ets/rnoh/RNOHGestureResponder.ts

@@ -1,16 +1,7 @@
 import { RNInstance } from "@rnoh/react-native-openharmony/ts"
 import { RNGestureResponder } from "../core"
 
-export class FakeRNGestureResponder {
-  lock() {
-    // Cancelling RN events isn't supported in ArkTS architecture.
-    return () => {}
-  }
-}
 
-/**
- * Used in C-API architecture.
- */
 export class RNOHGestureResponder implements RNGestureResponder {
   constructor(private rnInstance: RNInstance) {
   }

package/harmony/gesture_handler/src/main/ets/rnoh/RNOHScrollLocker.ts

@@ -1,20 +1,13 @@
 import { RNInstance } from '@rnoh/react-native-openharmony/ts';
 import { ScrollLocker, RNGHLogger } from '../core';
 
-export class RNOHScrollLockerArkTS implements ScrollLocker {
-  constructor(private rnInstance: RNInstance) {
-  }
 
-  lockScrollContainingViewTag(viewTag: number) {
-    return this.rnInstance.blockComponentsGestures(viewTag);
-  }
-}
 
 export class RNOHScrollLockerCAPI implements ScrollLocker {
   private logger: RNGHLogger
 
   constructor(private rnInstance: RNInstance, logger: RNGHLogger) {
-    this.logger = logger.cloneWithPrefix("RNOHScrollLockerCAPI")
+    this.logger = logger.cloneAndJoinPrefix("RNOHScrollLockerCAPI")
   }
 
   lockScrollContainingViewTag(viewTag: number) {

package/package.json

@@ -7,13 +7,17 @@
         "./src/specs"
       ]
     },
-    "redirectInternalImports": true
+    "redirectInternalImports": true,
+    "autolinking": {
+      "cmakeLibraryTargetName": "rnoh_gesture_handler",
+      "ohPackageName": "@react-native-oh-tpl/react-native-gesture-handler"
+    }
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/react-native-oh-library/react-native-harmony-gesture-handler.git"
   },
-  "version": "2.14.13",
+  "version": "2.14.15",
   "description": "",
   "react-native": "src/index.ts",
   "main": "lib/commonjs/index.js",
@@ -71,4 +75,4 @@
       ]
     ]
   }
-}
+}

package/harmony/gesture_handler/src/main/cpp/GestureHandlerPackage.cpp

@@ -1,149 +0,0 @@
-#pragma once
-#include "GestureHandlerPackage.h"
-#include "RNOH/RNInstanceCAPI.h"
-#include "componentInstances/RNGestureHandlerButtonComponentInstance.h"
-#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"
-#include "RNOH/ArkTSTurboModule.h"
-#include "RNGestureHandlerModule.h"
-#include "RNGestureHandlerButtonComponentDescriptor.h"
-#include "RNGestureHandlerRootViewComponentDescriptor.h"
-#include "RNGestureHandlerButtonJSIBinder.h"
-#include "RNGestureHandlerRootViewJSIBinder.h"
-#include <glog/logging.h>
-
-using namespace rnoh;
-using namespace facebook;
-
-class GestureHandlerTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
-public:
-    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
-        if (name == "RNGestureHandlerModule") {
-            return std::make_shared<RNGestureHandlerModule>(ctx, name);
-        }
-        return nullptr;
-    };
-};
-
-
-class RNGHEventEmitRequestHandler : public EventEmitRequestHandler {
-    void handleEvent(EventEmitRequestHandler::Context const &ctx) override {
-        auto eventEmitter = ctx.shadowViewRegistry->getEventEmitter<facebook::react::ViewEventEmitter>(ctx.tag);
-        if (eventEmitter == nullptr) {
-            return;
-        }
-        if (ctx.eventName == "onGestureHandlerEvent") {
-            eventEmitter->dispatchUniqueEvent(ctx.eventName, ArkJS(ctx.env).getDynamic(ctx.payload));
-        } else if (ctx.eventName == "onGestureHandlerStateChange") {
-            eventEmitter->dispatchEvent("onGestureHandlerStateChange", ArkJS(ctx.env).getDynamic(ctx.payload));
-        }
-    }
-};
-
-class RNOHCorePackageComponentInstanceFactoryDelegate : public ComponentInstanceFactoryDelegate {
-public:
-    using ComponentInstanceFactoryDelegate::ComponentInstanceFactoryDelegate;
-
-    ComponentInstance::Shared create(ComponentInstance::Context ctx) override {
-        if (ctx.componentName == "RNGestureHandlerButton") {
-            return std::make_shared<RNGestureHandlerButtonComponentInstance>(ctx);
-        } else if (ctx.componentName == "RNGestureHandlerRootView") {
-            return std::make_shared<RNGestureHandlerRootViewComponentInstance>(ctx);
-        }
-        return nullptr;
-    }
-};
-
-std::unique_ptr<TurboModuleFactoryDelegate> GestureHandlerPackage::createTurboModuleFactoryDelegate() {
-    return std::make_unique<GestureHandlerTurboModuleFactoryDelegate>();
-}
-
-std::vector<react::ComponentDescriptorProvider> GestureHandlerPackage::createComponentDescriptorProviders() {
-    return {
-        react::concreteComponentDescriptorProvider<react::RNGestureHandlerRootViewComponentDescriptor>(),
-        react::concreteComponentDescriptorProvider<react::RNGestureHandlerButtonComponentDescriptor>(),
-    };
-}
-
-ComponentJSIBinderByString GestureHandlerPackage::createComponentJSIBinderByName() {
-    return {
-        {"RNGestureHandlerButton", std::make_shared<RNGestureHandlerButtonJSIBinder>()},
-        {"RNGestureHandlerRootView", std::make_shared<RNGestureHandlerRootViewJSIBinder>()},
-    };
-};
-
-EventEmitRequestHandlers GestureHandlerPackage::createEventEmitRequestHandlers() {
-    return {
-        std::make_shared<RNGHEventEmitRequestHandler>(),
-    };
-}
-
-ComponentInstanceFactoryDelegate::Shared GestureHandlerPackage::createComponentInstanceFactoryDelegate() {
-    return std::make_shared<RNOHCorePackageComponentInstanceFactoryDelegate>();
-}
-
-class ScrollLockerArkTSMessageHandler : public ArkTSMessageHandler {
-public:
-  void handleArkTSMessage(const Context &ctx) override {
-    if (ctx.messageName == "RNGH::SET_NATIVE_RESPONDERS_BLOCK") {
-      auto targetComponentInstanceTag = ctx.messagePayload["targetTag"].asDouble();
-      auto shouldBlock = ctx.messagePayload["shouldBlock"].asBool();
-      auto rnInstance = ctx.rnInstance.lock();
-      if (rnInstance != nullptr) {
-        auto rnInstanceCAPI = std::dynamic_pointer_cast<RNInstanceCAPI>(rnInstance);
-        if (rnInstanceCAPI != nullptr) {
-          
-          std::vector<ComponentInstance::Shared> ancestors;
-          auto tmpComponentInstance = rnInstanceCAPI->findComponentInstanceByTag(targetComponentInstanceTag);
-          while (tmpComponentInstance != nullptr) {
-            ancestors.push_back(tmpComponentInstance);
-            tmpComponentInstance = tmpComponentInstance->getParent().lock();
-          }
-          if (ancestors.size() == 0) {
-            return;
-          }
-          /**
-           * Ensure consistent behavior with Android by not blocking scrolls above the GestureHandlerRootView handling
-           * the touch. If there are multiple nested GestureHandlerRootViews, the one nearest to the actual root will
-           * handle the touch.
-           */
-          auto isChangingResponderStatusAllowed = false; 
-          for (size_t i = ancestors.size() - 1; i > 0; i--) {
-            auto ancestor = ancestors[i];
-            if (!isChangingResponderStatusAllowed) {
-              auto rootView = std::dynamic_pointer_cast<RNGestureHandlerRootViewComponentInstance>(ancestor);
-              if (rootView != nullptr) {
-                isChangingResponderStatusAllowed = true;
-              }
-            } else {
-              ancestor->setNativeResponderBlocked(shouldBlock, "RNGH");
-            } 
-          }
-        }
-      }
-    } else if (ctx.messageName == "RNGH::ROOT_VIEW_IS_HANDLING_TOUCHES") {
-      auto descendantViewTag = ctx.messagePayload["descendantViewTag"].asDouble();
-      auto isHandlingTouches = ctx.messagePayload["isHandlingTouches"].asBool();
-      auto rnInstance = ctx.rnInstance.lock();
-      if (rnInstance != nullptr) {
-        auto rnInstanceCAPI = std::dynamic_pointer_cast<RNInstanceCAPI>(rnInstance);
-        if (rnInstanceCAPI != nullptr) {
-          auto tmpComponentInstance = rnInstanceCAPI->findComponentInstanceByTag(descendantViewTag);
-          while (tmpComponentInstance != nullptr) {
-            tmpComponentInstance = tmpComponentInstance->getParent().lock();
-            if (tmpComponentInstance) {
-              auto rnghRootViewComponentInstance =
-                std::dynamic_pointer_cast<RNGestureHandlerRootViewComponentInstance>(tmpComponentInstance);
-              if (rnghRootViewComponentInstance) {
-                rnghRootViewComponentInstance->setIsHandlingTouches(isHandlingTouches);
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-};
-
-std::vector<ArkTSMessageHandler::Shared> GestureHandlerPackage::createArkTSMessageHandlers() {
-    return {std::make_shared<ScrollLockerArkTSMessageHandler>()};
-}

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

@@ -1,11 +0,0 @@
-import { Tag, View } from "./View"
-
-export interface ViewFinder {
-    getTouchableViewsAt(
-      pointRelativeToRoot: {
-        x: number,
-        y: number
-      },
-      rootTag: Tag
-    ): View[]
-  }

package/harmony/gesture_handler/src/main/ets/rnoh/RNGHRootTouchHandlerArkTS.ts

@@ -1,98 +0,0 @@
-import { Tag } from '@rnoh/react-native-openharmony/ts';
-import { GestureHandlerArkUIAdapter } from './GestureHandlerArkUIAdapter';
-import { RNGHLogger, GestureHandlerRegistry, View, ViewFinder } from '../core';
-import { TouchEvent, TouchType } from './types';
-
-export class RNGHRootTouchHandlerArkTS {
-  private adapterByViewTag: Map<number, GestureHandlerArkUIAdapter> = new Map(); // TODO: remove adapter when view is removed
-  /**
-   * A view is ACTIVE, if it recently received POINTER_DOWN event
-   */
-  private activeViewTags = new Set<number>();
-  private viewFinder: ViewFinder;
-  private gestureHandlerRegistry: GestureHandlerRegistry;
-  private logger: RNGHLogger;
-  private rootTag: Tag;
-
-  constructor(
-    rootTag: Tag,
-    viewFinder: ViewFinder,
-    gestureHandlerRegistry: GestureHandlerRegistry,
-    logger: RNGHLogger,
-  ) {
-    this.rootTag = rootTag;
-    this.viewFinder = viewFinder;
-    this.gestureHandlerRegistry = gestureHandlerRegistry;
-    this.logger = logger;
-  }
-
-  /**
-   *
-   * @param touchEvent - TouchEvent. The type is any to allow providing the type in ets file (any and unknowns aren't allowed in ets files).
-   * @param touchableViews - Optional. List of views that can have gesture handler attached for given touch. If not provided, viewFinder will be used.
-   */
-  public handleTouch(touchEvent: any, touchableViews: View[] | null = null) {
-    const e = touchEvent as TouchEvent;
-    if (e.type === TouchType.Down) {
-      this.activeViewTags.clear();
-    }
-    for (const changedTouch of e.changedTouches) {
-      const views = touchableViews ?? this.viewFinder.getTouchableViewsAt(
-        {
-          x: changedTouch.windowX,
-          y: changedTouch.windowY,
-        },
-        this.rootTag,
-      );
-      for (const view of views) {
-        for (const handler of this.gestureHandlerRegistry.getGestureHandlersByViewTag(
-          view.getTag(),
-        )) {
-          this.logger.info(
-            `Found GestureHandler ${handler.getTag()} for view ${view.getTag()}`,
-          );
-
-          // create adapter if necessary
-          if (!this.adapterByViewTag.has(view.getTag())) {
-            this.adapterByViewTag.set(
-              view.getTag(),
-              new GestureHandlerArkUIAdapter(
-                view,
-                this.logger,
-              ),
-            );
-          }
-
-          // attach handler (there might be multiple handlers per view)
-          this.adapterByViewTag.get(view.getTag())!.attachGestureHandler(handler) // TODO: detachGestureHandler
-
-          // register active view tag
-          if (e.type === TouchType.Down) {
-            this.activeViewTags.add(view.getTag());
-          }
-        }
-      }
-
-      // send touch to gesture handlers, prioritize handling touch events for child components
-      if (this.activeViewTags.size > 0) {
-        const tags = Array.from(this.activeViewTags);
-        for (let i = tags.length - 1; i >= 0; i--) {
-          const tag = tags[i];
-          const adapter = this.adapterByViewTag.get(tag);
-          if (adapter) {
-            adapter.handleTouch(e);
-          }
-        }
-      }
-    }
-  }
-
-  public cancelTouches() {
-    for (const activeViewTag of this.activeViewTags) {
-      this.gestureHandlerRegistry.getGestureHandlersByViewTag(activeViewTag).forEach(gh => {
-        gh.cancel()
-        gh.reset()
-      })
-    }
-  }
-}