@react-native-oh-tpl/react-native-gesture-handler 2.14.8-rc.1 → 2.14.14

package/DrawerLayout/index.ts

@@ -1,2 +1,2 @@
-import DrawerLayout from 'react-native-gesture-handler/DrawerLayout';
-export default DrawerLayout;
+import DrawerLayout from 'react-native-gesture-handler/DrawerLayout';
+export default DrawerLayout;

package/Swipeable/index.ts

@@ -1,2 +1,2 @@
-import Swipeable from 'react-native-gesture-handler/Swipeable';
-export default Swipeable;
+import Swipeable from 'react-native-gesture-handler/Swipeable';
+export default Swipeable;

package/harmony/gesture_handler/BuildProfile.ets

@@ -0,0 +1,17 @@
+/**
+ * Use these variables when you tailor your ArkTS code. They must be of the const type.
+ */
+export const HAR_VERSION = '2.14.14';
+export const BUILD_MODE_NAME = 'release';
+export const DEBUG = false;
+export const TARGET_NAME = 'default';
+
+/**
+ * BuildProfile Class is used only for compatibility purposes.
+ */
+export default class BuildProfile { 
+	static readonly HAR_VERSION = HAR_VERSION;
+	static readonly BUILD_MODE_NAME = BUILD_MODE_NAME;
+	static readonly DEBUG = DEBUG;
+	static readonly TARGET_NAME = TARGET_NAME;
+}

package/harmony/gesture_handler/build-profile.json5

@@ -0,0 +1,19 @@
+{
+  "apiType": 'stageMode',
+//  "buildOption": {
+//    "externalNativeOptions": {
+//      "path": "./src/main/cpp/CMakeLists.txt",
+//      "arguments": "",
+//      "cppFlags": "",
+//    },
+//  },
+  "targets": [
+    {
+      "name": "default",
+      "runtimeOS": "HarmonyOS"
+    },
+    {
+      "name": "ohosTest",
+    }
+  ]
+}

package/harmony/gesture_handler/hvigorfile.ts

@@ -0,0 +1,2 @@
+// Script for compiling build behavior. It is built in the build plug-in and cannot be modified currently.
+export { harTasks } from '@ohos/hvigor-ohos-plugin';

package/harmony/gesture_handler/index.ets

@@ -0,0 +1,2 @@
+export * from "./ts"
+export { default } from "./src/main/ets/RNOHPackage"

package/harmony/gesture_handler/oh-package-lock.json5

@@ -0,0 +1,18 @@
+{
+  "meta": {
+    "stableOrder": false
+  },
+  "lockfileVersion": 3,
+  "ATTENTION": "THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.",
+  "specifiers": {
+    "@rnoh/react-native-openharmony@../react_native_openharmony.har": "@rnoh/react-native-openharmony@../react_native_openharmony.har"
+  },
+  "packages": {
+    "@rnoh/react-native-openharmony@../react_native_openharmony.har": {
+      "name": "@rnoh/react-native-openharmony",
+      "version": "0.72.35",
+      "resolved": "../react_native_openharmony.har",
+      "registryType": "local"
+    }
+  }
+}

package/harmony/gesture_handler/oh-package.json5

@@ -0,0 +1,12 @@
+{
+  license: '',
+  devDependencies: {},
+  author: '',
+  name: '@react-native-oh-tpl/react-native-gesture-handler',
+  description: '',
+  type: 'module',
+  version: '2.14.14',
+  dependencies: {
+    "@rnoh/react-native-openharmony": "file:./react_native_openharmony"
+  },
+}

package/harmony/gesture_handler/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+file(GLOB rnoh_gesture_handler_SRC CONFIGURE_DEPENDS *.cpp)
+
+add_library(rnoh_gesture_handler SHARED ${rnoh_gesture_handler_SRC})
+target_include_directories(rnoh_gesture_handler PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(rnoh_gesture_handler PUBLIC rnoh)

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

@@ -0,0 +1,12 @@
+#pragma once
+#include "RnohReactNativeHarmonyGestureHandlerPackage.h"
+
+namespace rnoh {
+/**
+ * @deprecated: Use RnohReactNativeHarmonyGestureHandlerPackage instead (2024-10-10)
+ */
+class GestureHandlerPackage : public RnohReactNativeHarmonyGestureHandlerPackage {
+    using Super = RnohReactNativeHarmonyGestureHandlerPackage;
+    using Super::Super;
+};
+} // namespace rnoh

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

@@ -0,0 +1,123 @@
+#pragma once
+#include "RnohReactNativeHarmonyGestureHandlerPackage.h"
+#include "RNOH/RNInstanceCAPI.h"
+#include "componentInstances/RNGestureHandlerButtonComponentInstance.h"
+#include "componentInstances/RNGestureHandlerRootViewComponentInstance.h"
+#include <glog/logging.h>
+#include <react/renderer/debug/SystraceSection.h>
+
+using namespace rnoh;
+using namespace facebook;
+
+class RNGHEventEmitRequestHandler : public EventEmitRequestHandler {
+    void handleEvent(EventEmitRequestHandler::Context const &ctx) override {
+        facebook::react::SystraceSection s("RNGH::RNGHEventEmitRequestHandler::handleEvent");
+        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;
+    }
+};
+
+
+EventEmitRequestHandlers RnohReactNativeHarmonyGestureHandlerPackage::createEventEmitRequestHandlers() {
+    return {
+        std::make_shared<RNGHEventEmitRequestHandler>(),
+    };
+}
+
+ComponentInstanceFactoryDelegate::Shared
+RnohReactNativeHarmonyGestureHandlerPackage::createComponentInstanceFactoryDelegate() {
+    return std::make_shared<RNOHCorePackageComponentInstanceFactoryDelegate>();
+}
+
+class ScrollLockerArkTSMessageHandler : public ArkTSMessageHandler {
+public:
+    void handleArkTSMessage(const Context &ctx) override {
+        facebook::react::SystraceSection s("RNGH::ScrollLockerArkTSMessageHandler::handleArkTSMessage");
+        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> RnohReactNativeHarmonyGestureHandlerPackage::createArkTSMessageHandlers() {
+    return {std::make_shared<ScrollLockerArkTSMessageHandler>()};
+}

package/harmony/gesture_handler/src/main/cpp/RnohReactNativeHarmonyGestureHandlerPackage.h

@@ -0,0 +1,15 @@
+#pragma once
+#include "RNOH/Package.h"
+
+namespace rnoh {
+class RnohReactNativeHarmonyGestureHandlerPackage : public Package {
+public:
+    RnohReactNativeHarmonyGestureHandlerPackage(Package::Context ctx) : Package(ctx) {}
+
+    EventEmitRequestHandlers createEventEmitRequestHandlers();
+
+    ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate();
+
+    std::vector<ArkTSMessageHandler::Shared> createArkTSMessageHandlers() override;
+};
+} // namespace rnoh

package/harmony/gesture_handler/src/main/cpp/componentInstances/RNGestureHandlerButtonComponentInstance.h

@@ -0,0 +1,27 @@
+#pragma once
+#import "RNOH/CppComponentInstance.h"
+#import "RNOH/arkui/StackNode.h"
+#import "generated/RNGestureHandlerButtonComponentDescriptor.h"
+
+namespace rnoh {
+class RNGestureHandlerButtonComponentInstance
+    : public CppComponentInstance<facebook::react::RNGestureHandlerButtonShadowNode> {
+private:
+    StackNode m_stackNode;
+
+public:
+    RNGestureHandlerButtonComponentInstance(Context context) : CppComponentInstance(std::move(context)){};
+
+    StackNode &getLocalRootArkUINode() override { return m_stackNode; };
+
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override {
+        CppComponentInstance::onChildInserted(childComponentInstance, index);
+        m_stackNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+    };
+
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override {
+        CppComponentInstance::onChildRemoved(childComponentInstance);
+        m_stackNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+    };
+};
+} // namespace rnoh

package/harmony/gesture_handler/src/main/cpp/componentInstances/RNGestureHandlerRootViewComponentInstance.h

@@ -0,0 +1,245 @@
+#pragma once
+#import "RNOH/CppComponentInstance.h"
+#import "RNOH/arkui/StackNode.h"
+#import "RNOH/arkui/ArkUINodeRegistry.h"
+#import "RNOH/arkui/NativeNodeApi.h"
+#import "RNOH/RNInstanceCAPI.h"
+#import "generated/RNGestureHandlerRootViewComponentDescriptor.h"
+#import "RNGestureHandlerButtonComponentInstance.h"
+
+namespace rnoh {
+class RNGestureHandlerRootViewComponentInstance
+    : public CppComponentInstance<facebook::react::RNGestureHandlerRootViewShadowNode>,
+      public TouchEventHandler {
+    using Point = facebook::react::Point;
+
+    enum class ActionType { Cancel, Down, Move, Up };
+
+    /**
+     * This function is borrowed from TouchEventDispatcher
+     */
+    static TouchTarget::Shared findTargetForTouchPoint(Point const &point, TouchTarget::Shared const &target) {
+        bool canHandleTouch =
+            target->canHandleTouch() && target->containsPoint(point) && (target->getTouchEventEmitter() != nullptr);
+        bool canChildrenHandleTouch = target->canChildrenHandleTouch() && target->containsPointInBoundingBox(point);
+
+        if (canChildrenHandleTouch) {
+            auto children = target->getTouchTargetChildren();
+            // we want to check the children in reverse order, since the last child is the topmost one
+            std::reverse(children.begin(), children.end());
+            for (auto const &child : children) {
+                auto childPoint = target->computeChildPoint(point, child);
+                auto result = findTargetForTouchPoint(childPoint, child);
+                if (result != nullptr) {
+                    return result;
+                }
+            }
+        }
+        if (canHandleTouch) {
+            return target;
+        }
+        return nullptr;
+    }
+
+private:
+    bool m_isHandlingTouches = false;
+    StackNode m_stackNode;
+
+    struct TouchableView {
+        Tag tag;
+        facebook::react::Float width;
+        facebook::react::Float height;
+        facebook::react::Float x;
+        facebook::react::Float y;
+        bool buttonRole;
+    };
+
+public:
+    RNGestureHandlerRootViewComponentInstance(Context context) : CppComponentInstance(std::move(context)) {
+        ArkUINodeRegistry::getInstance().registerTouchHandler(&m_stackNode, this);
+        NativeNodeApi::getInstance()->registerNodeEvent(m_stackNode.getArkUINodeHandle(), NODE_TOUCH_EVENT,
+                                                        NODE_TOUCH_EVENT, 0);
+        auto rnInstance = m_deps->rnInstance.lock();
+        if (rnInstance) {
+            rnInstance->postMessageToArkTS("RNGH::ROOT_CREATED", m_tag);
+        }
+    };
+
+    ~RNGestureHandlerRootViewComponentInstance() override {
+        NativeNodeApi::getInstance()->unregisterNodeEvent(m_stackNode.getArkUINodeHandle(), NODE_TOUCH_EVENT);
+        ArkUINodeRegistry::getInstance().unregisterTouchHandler(&m_stackNode);
+    }
+
+    StackNode &getLocalRootArkUINode() override { return m_stackNode; };
+
+    void onTouchEvent(ArkUI_UIInputEvent *e) override {
+        auto ancestor = this->getParent().lock();
+        while (ancestor != nullptr) {
+            auto ancestorRNGHRootView = std::dynamic_pointer_cast<RNGestureHandlerRootViewComponentInstance>(ancestor);
+            if (ancestorRNGHRootView != nullptr) {
+                // If there are multiple nested GestureHandlerRootViews, the one nearest to the actual root will handle
+                // the touch.
+                return;
+            }
+            ancestor = ancestor->getParent().lock();
+        }
+
+        auto ancestorTouchTarget = this->getTouchTargetParent();
+        auto rnInstance = m_deps->rnInstance.lock();
+        while (ancestorTouchTarget != nullptr) {
+            if (ancestorTouchTarget->isHandlingTouches()) {
+                rnInstance->postMessageToArkTS("RNGH::CANCEL_TOUCHES", m_tag);
+                return;
+            }
+            ancestorTouchTarget = ancestorTouchTarget->getTouchTargetParent();
+        }
+
+        folly::dynamic payload = folly::dynamic::object;
+        folly::dynamic touchPoints = folly::dynamic::array();
+        std::vector<TouchableView> touchableViews;
+
+        auto action = OH_ArkUI_UIInputEvent_GetAction(e);
+        auto actionType = static_cast<ActionType>(action);
+
+        if (actionType != ActionType::Move) {
+            // point relative to top left corner of this component
+            auto componentX = OH_ArkUI_PointerEvent_GetX(e);
+            auto componentY = OH_ArkUI_PointerEvent_GetY(e);
+            touchableViews = this->findTouchableViews(componentX, componentY);
+        }
+
+        auto activeWindowX = OH_ArkUI_PointerEvent_GetWindowX(e);
+        auto activeWindowY = OH_ArkUI_PointerEvent_GetWindowY(e);
+        int32_t pointerCount = OH_ArkUI_PointerEvent_GetPointerCount(e);
+        int activePointerIdx = 0;
+        for (int i = 0; i < pointerCount; i++) {
+            auto touchPoint = this->convertNodeTouchPointToDynamic(e, i);
+            touchPoints.push_back(touchPoint);
+            if (activeWindowX == touchPoint["windowX"].asDouble() &&
+                activeWindowY == touchPoint["windowY"].asDouble()) {
+                activePointerIdx = i;
+            }
+        }
+        payload["actionTouch"] = touchPoints[activePointerIdx];
+        payload["touchPoints"] = touchPoints;
+        payload["sourceType"] = OH_ArkUI_UIInputEvent_GetSourceType(e);
+        payload["timestamp"] = OH_ArkUI_UIInputEvent_GetEventTime(e);
+        payload["touchableViews"] = this->dynamicFromTouchableViews(touchableViews);
+        payload["rootTag"] = m_tag;
+        payload["action"] = action;
+        if (rnInstance) {
+            rnInstance->postMessageToArkTS("RNGH::TOUCH_EVENT", payload);
+        }
+    }
+
+    void setIsHandlingTouches(bool isHandlingTouches) { m_isHandlingTouches = isHandlingTouches; }
+
+    bool isHandlingTouches() const override { return m_isHandlingTouches; }
+
+private:
+    std::vector<TouchableView> findTouchableViews(float componentX, float componentY) {
+        auto touchTarget = findTargetForTouchPoint({.x = componentX, .y = componentY}, this->shared_from_this());
+        std::vector<TouchTarget::Shared> touchTargets{};
+        auto tmp = touchTarget;
+        while (tmp != nullptr) {
+            touchTargets.push_back(tmp);
+            tmp = tmp->getTouchTargetParent();
+        }
+        std::reverse(touchTargets.begin(), touchTargets.end()); // leaf / ... / root -> root / ... / leaf
+        std::vector<TouchableView> touchableViews{};
+
+        float offsetX = 0;
+        float offsetY = 0;
+        auto surface = this->getSurface().lock();
+        if (surface != nullptr) {
+            offsetX = surface->getLayoutContext().viewportOffset.x;
+            offsetY = surface->getLayoutContext().viewportOffset.y;
+        } else {
+            LOG(WARNING) << "Surface is nullptr";
+        }
+        for (auto &touchTarget : touchTargets) {
+            auto buttonRole = dynamic_cast<RNGestureHandlerButtonComponentInstance *>(touchTarget.get()) != nullptr;
+            auto frame = touchTarget->getLayoutMetrics().frame;
+            auto transform = touchTarget->getTransform();
+            auto transformedFrame = frame * transform;
+            touchableViews.push_back({
+                .tag = touchTarget->getTouchTargetTag(),
+                .width = transformedFrame.size.width,
+                .height = transformedFrame.size.height,
+                .x = transformedFrame.origin.x + offsetX,
+                .y = transformedFrame.origin.y + offsetY,
+                .buttonRole = buttonRole,
+            });
+            offsetX += transformedFrame.origin.x;
+            offsetY += transformedFrame.origin.y;
+            offsetX -= touchTarget->getCurrentOffset().x;
+            offsetY -= touchTarget->getCurrentOffset().y;
+        }
+
+        return touchableViews;
+    }
+
+    folly::dynamic dynamicFromTouchableViews(const std::vector<TouchableView> &touchableViews) {
+        folly::dynamic d_touchableViews = folly::dynamic::array();
+        for (auto touchableView : touchableViews) {
+            folly::dynamic d_touchableView = folly::dynamic::object;
+            d_touchableView["tag"] = touchableView.tag;
+            d_touchableView["x"] = touchableView.x;
+            d_touchableView["y"] = touchableView.y;
+            d_touchableView["width"] = touchableView.width;
+            d_touchableView["height"] = touchableView.height;
+            d_touchableView["buttonRole"] = touchableView.buttonRole;
+            d_touchableViews.push_back(d_touchableView);
+        }
+        return d_touchableViews;
+    }
+
+    folly::dynamic convertNodeTouchPointToDynamic(ArkUI_UIInputEvent *e, int32_t index = 0) {
+        folly::dynamic result = folly::dynamic::object;
+        result["pointerId"] = OH_ArkUI_PointerEvent_GetPointerId(e, index);
+        result["windowX"] = OH_ArkUI_PointerEvent_GetWindowXByIndex(e, index);
+        result["windowY"] = OH_ArkUI_PointerEvent_GetWindowYByIndex(e, index);
+        return result;
+    }
+
+protected:
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override {
+        CppComponentInstance::onChildInserted(childComponentInstance, index);
+        m_stackNode.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
+    };
+
+    void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override {
+        CppComponentInstance::onChildRemoved(childComponentInstance);
+        m_stackNode.removeChild(childComponentInstance->getLocalRootArkUINode());
+    };
+
+private:
+    Surface::Weak m_surface;
+
+    Surface::Weak getSurface() {
+        if (m_surface.lock() != nullptr) {
+            return m_surface;
+        }
+        auto rnInstance = m_deps->rnInstance.lock();
+        if (rnInstance == nullptr) {
+            m_surface.reset();
+            return m_surface;
+        }
+        ComponentInstance::Shared currentRoot = shared_from_this();
+        while (true) {
+            auto maybeNewCurrentRoot = currentRoot->getParent().lock();
+            if (maybeNewCurrentRoot == nullptr) {
+                break;
+            }
+            currentRoot = maybeNewCurrentRoot;
+        }
+        auto maybeSurface = rnInstance->getSurfaceByRootTag(currentRoot->getTag());
+        if (!maybeSurface.has_value()) {
+            m_surface.reset();
+            return m_surface;
+        }
+        m_surface = maybeSurface.value();
+        return m_surface;
+    }
+};
+} // namespace rnoh

package/harmony/gesture_handler/src/main/ets/RNOHPackage.ets

@@ -0,0 +1,17 @@
+import { RNPackage, RNPackageContext } from "@rnoh/react-native-openharmony";
+import type { TurboModule, TurboModuleContext } from "@rnoh/react-native-openharmony/ts";
+import { RNGestureHandlerModule } from './rnoh/RNGestureHandlerModule';
+
+export default class RnohReactNativeHarmonyGestureHandlerPackage extends RNPackage {
+  private isRNGHDevModeEnabled: boolean
+
+  constructor(ctx: RNPackageContext, isRNGHDevModeEnabled: boolean = false) {
+    super(ctx)
+    this.isRNGHDevModeEnabled = isRNGHDevModeEnabled
+  }
+
+  getUITurboModuleFactoryByNameMap(): Map<string, (ctx: TurboModuleContext) => TurboModule | null> {
+    return new Map().set(RNGestureHandlerModule.NAME,
+      (ctx: TurboModuleContext) => new RNGestureHandlerModule(ctx, this.isRNGHDevModeEnabled))
+  }
+}

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

@@ -0,0 +1,42 @@
+export class CircularBuffer<T> {
+  private bufferSize: number;
+  private buffer: T[];
+  private index: number;
+  private actualSize: number;
+
+  constructor(size: number) {
+    this.bufferSize = size;
+    this.buffer = new Array<T>(size);
+    this.index = 0;
+    this.actualSize = 0;
+  }
+
+  public get size(): number {
+    return this.actualSize;
+  }
+
+  public push(element: T): void {
+    this.buffer[this.index] = element;
+    this.index = (this.index + 1) % this.bufferSize;
+    this.actualSize = Math.min(this.actualSize + 1, this.bufferSize);
+  }
+
+  public get(at: number): T {
+    if (this.actualSize === this.bufferSize) {
+      let index = (this.index + at) % this.bufferSize;
+      if (index < 0) {
+        index += this.bufferSize;
+      }
+
+      return this.buffer[index];
+    } else {
+      return this.buffer[at];
+    }
+  }
+
+  public clear(): void {
+    this.buffer = new Array<T>(this.bufferSize);
+    this.index = 0;
+    this.actualSize = 0;
+  }
+}