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

package/DrawerLayout/index.ts

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

package/Swipeable/index.ts

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

package/harmony/gesture_handler/BuildProfile.ets

@@ -1,5 +1,17 @@
+/**
+ * Use these variables when you tailor your ArkTS code. They must be of the const type.
+ */
+export const HAR_VERSION = '2.14.1-2.14.13';
+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 = '2.12.9';
-	static readonly BUILD_MODE_NAME = 'debug';
-	static readonly DEBUG = true;
+	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/hvigorfile.ts

@@ -1,2 +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';
+export { harTasks } from '@ohos/hvigor-ohos-plugin';

package/harmony/gesture_handler/index.ets

@@ -1,3 +1,3 @@
 export * from "./ts"
-export * from "./src/main/ets/RNGestureHandlerRootView"
-export * from "./src/main/ets/RNGestureHandlerButton"
+export * from "./src/main/ets/rnoh/RNGestureHandlerRootView"
+export * from "./src/main/ets/rnoh/RNGestureHandlerButton"

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

@@ -5,12 +5,13 @@
   "lockfileVersion": 3,
   "ATTENTION": "THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.",
   "specifiers": {
-    "@rnoh/react-native-openharmony@../rnoh": "@rnoh/react-native-openharmony@../rnoh"
+    "@rnoh/react-native-openharmony@../react_native_openharmony.har": "@rnoh/react-native-openharmony@../react_native_openharmony.har"
   },
   "packages": {
-    "@rnoh/react-native-openharmony@../rnoh": {
+    "@rnoh/react-native-openharmony@../react_native_openharmony.har": {
       "name": "@rnoh/react-native-openharmony",
-      "resolved": "../rnoh",
+      "version": "0.72.28",
+      "resolved": "../react_native_openharmony.har",
       "registryType": "local"
     }
   }

package/harmony/gesture_handler/oh-package.json5

@@ -4,9 +4,9 @@
   author: '',
   name: '@react-native-oh-tpl/react-native-gesture-handler',
   description: '',
-  main: 'index.ets',
-  version: '2.12.9',
+  type: 'module',
+  version: '2.14.1-2.14.13',
   dependencies: {
-    "@rnoh/react-native-openharmony": 'file:../rnoh',
+    "@rnoh/react-native-openharmony": "file:./react_native_openharmony"
   },
 }

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

@@ -1,14 +1,15 @@
 #pragma once
 #include "GestureHandlerPackage.h"
 #include "RNOH/RNInstanceCAPI.h"
-#include "RNGestureHandlerButtonComponentInstance.h"
-#include "RNGestureHandlerRootViewComponentInstance.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;
@@ -23,6 +24,7 @@ public:
     };
 };
 
+
 class RNGHEventEmitRequestHandler : public EventEmitRequestHandler {
     void handleEvent(EventEmitRequestHandler::Context const &ctx) override {
         auto eventEmitter = ctx.shadowViewRegistry->getEventEmitter<facebook::react::ViewEventEmitter>(ctx.tag);
@@ -30,7 +32,9 @@ class RNGHEventEmitRequestHandler : public EventEmitRequestHandler {
             return;
         }
         if (ctx.eventName == "onGestureHandlerEvent") {
-            eventEmitter->dispatchEvent(ctx.eventName, ArkJS(ctx.env).getDynamic(ctx.payload));
+            eventEmitter->dispatchUniqueEvent(ctx.eventName, ArkJS(ctx.env).getDynamic(ctx.payload));
+        } else if (ctx.eventName == "onGestureHandlerStateChange") {
+            eventEmitter->dispatchEvent("onGestureHandlerStateChange", ArkJS(ctx.env).getDynamic(ctx.payload));
         }
     }
 };
@@ -79,23 +83,65 @@ ComponentInstanceFactoryDelegate::Shared GestureHandlerPackage::createComponentI
 
 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) {
-                    auto tmpComponentInstance = rnInstanceCAPI->findComponentInstanceByTag(targetComponentInstanceTag);
-                    while (tmpComponentInstance != nullptr) {
-                        tmpComponentInstance->setNativeResponderBlocked(shouldBlock, "RNGH");
-                        tmpComponentInstance = tmpComponentInstance->getParent().lock();
-                    }
-                }
+  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() {

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

@@ -5,13 +5,13 @@ namespace rnoh {
     class GestureHandlerPackage : public Package {
     public:
         GestureHandlerPackage(Package::Context ctx) : Package(ctx) {}
-
+    
         std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override;
-
+    
         std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override;
 
         ComponentJSIBinderByString createComponentJSIBinderByName() override;
-
+    
         EventEmitRequestHandlers createEventEmitRequestHandlers();
 
         ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate();

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

@@ -12,12 +12,12 @@ class RNGestureHandlerRootViewJSIBinder : public ViewComponentJSIBinder {
         return object;
     }
 
-    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
         facebook::jsi::Object events(rt);
         return events;
     }
 
-    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
         facebook::jsi::Object events(rt);
         return events;
     }

package/harmony/gesture_handler/src/main/cpp/{RNGestureHandlerButtonComponentInstance.h → componentInstances/RNGestureHandlerButtonComponentInstance.h}

@@ -1,7 +1,7 @@
 #pragma once
 #import "RNOH/CppComponentInstance.h"
 #import "RNOH/arkui/StackNode.h"
-#import "RNGestureHandlerButtonComponentDescriptor.h"
+#import "../RNGestureHandlerButtonComponentDescriptor.h"
 
 namespace rnoh {
     class RNGestureHandlerButtonComponentInstance
@@ -24,4 +24,4 @@ namespace rnoh {
             m_stackNode.removeChild(childComponentInstance->getLocalRootArkUINode());
         };
     };
-} // namespace rnoh
+} // namespace rnoh

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

@@ -0,0 +1,242 @@
+#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 "../RNGestureHandlerRootViewComponentDescriptor.h"
+#import "RNGestureHandlerButtonComponentInstance.h"
+
+namespace rnoh {
+class RNGestureHandlerRootViewComponentInstance
+    : public CppComponentInstance<facebook::react::RNGestureHandlerRootViewShadowNode>,
+      public TouchEventHandler {
+  using Point = facebook::react::Point;
+
+  /**
+   * 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;
+    payload["action"] = OH_ArkUI_UIInputEvent_GetAction(e);
+    folly::dynamic touchPoints = folly::dynamic::array();
+    auto activeWindowX = OH_ArkUI_PointerEvent_GetWindowX(e);
+    auto activeWindowY = OH_ArkUI_PointerEvent_GetWindowY(e);
+
+    // point relative to top left corner of this component
+    auto componentX = OH_ArkUI_PointerEvent_GetX(e);
+    auto componentY = OH_ArkUI_PointerEvent_GetY(e);
+    auto touchableViews = this->findTouchableViews(componentX, componentY);
+
+    std::stringstream touchableViewTags;
+    for (auto touchableView : touchableViews) {
+      touchableViewTags << touchableView.tag << ";";
+    }
+
+    payload["touchableViews"] = this->dynamicFromTouchableViews(touchableViews);
+
+    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["rootTag"] = m_tag;
+    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