@react-native-ohos/react-native-svg 15.0.2-rc.5 → 15.12.1-rc.10

package/harmony/svg/src/main/cpp/SvgForeignObjectNode.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "SvgForeignObjectNode.h"
+#include "RNOH/arkui/NativeNodeApi.h"
+#include <deviceinfo.h>
+#include <info/application_target_sdk_version.h>
+namespace rnoh {
+namespace svg {
+SvgForeignObjectNode::SvgForeignObjectNode()
+    : ArkUINode(NativeNodeApi::getInstance()->createNode(ArkUI_NodeType::ARKUI_NODE_STACK)) {
+    mStackNode.setVisibility(ArkUI_Visibility::ARKUI_VISIBILITY_HIDDEN);
+    mStackNode.setClip(true);
+    maybeThrow(NativeNodeApi::getInstance()->addChild(m_nodeHandle, mStackNode.getArkUINodeHandle()));
+}
+
+SvgForeignObjectNode::~SvgForeignObjectNode() {
+    if (m_NodeDelegate) {
+        m_NodeDelegate = nullptr;
+    }
+    _isGeneratedPixelMap = false;
+}
+void SvgForeignObjectNode::insertChild(ArkUINode &child, std::size_t index) { mStackNode.insertChild(child, index); }
+
+void SvgForeignObjectNode::SetSnapHeight(Dimension height) { _height = height; }
+
+void SvgForeignObjectNode::SetSnapWidth(Dimension width) { _width = width; }
+
+void SvgForeignObjectNode::SetSnapPosition(Dimension x, Dimension y) {
+    _positionX = x;
+    _positionY = y;
+}
+
+void SvgForeignObjectNode::onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) {
+    if (eventType == ArkUI_NodeEventType::NODE_EVENT_ON_AREA_CHANGE) {
+        if (m_NodeDelegate && _isGeneratedPixelMap) {
+            OH_PixelmapNative *pixelMap = GetNodePixelMap();
+            if (!pixelMap) {
+                LOG(ERROR) << "[svgForeignNode] get node snapshot pixelMap is null";
+                return;
+            }
+            _isGeneratedPixelMap = false;
+            ForeignProps foreignProps = {pixelMap, _width, _height, _positionX, 
+                _positionY, _path, _clipRule, _mask, pointScaleFactor_, transform_};
+            m_NodeDelegate->onDrawForeignImage(foreignProps);
+        }
+    }
+}
+
+OH_PixelmapNative *SvgForeignObjectNode::GetNodePixelMap() {
+#ifdef OH_CURRENT_API_VERSION
+    if (OH_CURRENT_API_VERSION < 15 || OH_GetSdkApiVersion() < 15) {
+        LOG(ERROR) << "[svgForeignNode] current sdk or rom cannot support ForeignObject";
+        return nullptr;
+    }
+    OH_PixelmapNative *pixelMap;
+    ArkUI_SnapshotOptions *options = OH_ArkUI_CreateSnapshotOptions();
+    OH_ArkUI_SnapshotOptions_SetScale(options, 1);
+    int32_t code = OH_ArkUI_GetNodeSnapshot(mStackNode.getArkUINodeHandle(), options, &pixelMap);
+    if (code == ARKUI_ERROR_CODE_NO_ERROR) {
+        return pixelMap;
+    }
+#endif
+    return nullptr;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgForeignObjectNode.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef HARMONY_SVGFOREIGNOBJECTNODE_H
+#define HARMONY_SVGFOREIGNOBJECTNODE_H
+#include "RNOH/arkui/ArkUINode.h"
+#include "RNOH/arkui/StackNode.h"
+#include "SvgForeignObjectNodeDelegate.h"
+#include "properties/Dimension.h"
+
+namespace rnoh {
+namespace svg {
+class SvgForeignObjectNode : public ArkUINode {
+public:
+    SvgForeignObjectNode();
+    ~SvgForeignObjectNode() override;
+    void onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) override;
+    StackNode &getSnapNode() { return mStackNode; }
+    void insertChild(ArkUINode &child, std::size_t index);
+    void SetSnapPosition(Dimension x, Dimension y);
+    void SetSnapWidth(Dimension width);
+    void SetSnapHeight(Dimension height);
+    void SetPointScaleFactor(float pointScaleFactor) {
+        pointScaleFactor_ = pointScaleFactor;
+    }
+    void SetTransform(std::vector<double> transform) {
+        transform_ = transform;
+    }
+    void setNodeSize(float w, float h){
+        mStackNode.setSize({w, h});
+    }
+    OH_PixelmapNative *GetNodePixelMap();
+    void SetForeignNodeDelegate(SvgForeignObjectNodeDelegate *delegate) { m_NodeDelegate = delegate; };
+    void SetGeneratedPixelMap(bool isNeed) {
+        _isGeneratedPixelMap = isNeed;
+    }
+    
+    void SetClipPath(std::string path,int clipRule) {
+        _path = path;
+        _clipRule = clipRule;
+    }
+     void SetMask(std::string mask) {
+        _mask = mask;
+    }
+    
+private:
+    StackNode mStackNode;
+    SvgForeignObjectNodeDelegate *m_NodeDelegate;
+    Dimension _width{0};
+    Dimension _height{0};
+    Dimension _positionX{0};
+    Dimension _positionY{0};
+    std::string _path{""};
+    std::string _mask{""};
+    std::vector<double> transform_;
+    int _clipRule{0};
+    float pointScaleFactor_{0};
+    bool _isGeneratedPixelMap{false}; //防止快照生成多次，导致性能影响
+};
+
+} // namespace svg
+} // namespace rnoh
+#endif // HARMONY_SVGFOREIGNOBJECTNODE_H

package/harmony/svg/src/main/cpp/SvgForeignObjectNodeDelegate.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef HARMONY_SVGFOREIGNOBJECTNODEDELEGATE_H
+#define HARMONY_SVGFOREIGNOBJECTNODEDELEGATE_H
+#include "SvgForeignProps.h"
+class SvgForeignObjectNodeDelegate {
+public:
+    virtual ~SvgForeignObjectNodeDelegate() = default;
+    virtual void onDrawForeignImage(ForeignProps props){};
+};
+#endif //HARMONY_SVGFOREIGNOBJECTNODEDELEGATE_H

package/harmony/svg/src/main/cpp/SvgForeignProps.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ *
+ * This file incorporates from the OpenHarmony project, licensed under
+ * the Apache License, Version 2.0. Specifically:
+ * - [OpenHarmony/arkui_ace_engine] (https://gitee.com/openharmony/arkui_ace_engine)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy
+ * of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+#ifndef HARMONY_FOREIGNPROPS_H
+#define HARMONY_FOREIGNPROPS_H
+#include "properties/Dimension.h"
+#include <multimedia/image_framework/image/pixelmap_native.h>
+#include <string>
+struct ForeignProps {
+    OH_PixelmapNative *foreignPixelMap{nullptr};
+    rnoh::svg::Dimension width;
+    rnoh::svg::Dimension height;
+    rnoh::svg::Dimension x;
+    rnoh::svg::Dimension y;
+    std::string path;
+    int clipRule;
+    std::string mask;
+    float pointScaleFactor;
+    std::vector<double> transform;
+};
+#endif //HARMONY_FOREIGNPROPS_H

package/harmony/svg/src/main/cpp/SvgGradient.cpp

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SvgGradient.h"
+#include <native_drawing/drawing_shader_effect.h>
+#include "properties/Decoration.h"
+
+namespace rnoh {
+namespace svg {
+
+constexpr int TRANSFORM_SCALE_X_INDEX = 0;
+constexpr int TRANSFORM_SKEW_Y_INDEX = 1;
+constexpr int TRANSFORM_SKEW_X_INDEX = 2;
+constexpr int TRANSFORM_SCALE_Y_INDEX = 3;
+constexpr int TRANSFORM_TRANSLATE_X_INDEX = 4;
+constexpr int TRANSFORM_TRANSLATE_Y_INDEX = 5;
+constexpr size_t GRADIENT_TRANSFORM_MATRIX_SIZE = 6;
+
+SvgGradient::SvgGradient(GradientType gradientType)
+{
+    gradientAttr_.gradient.SetType(gradientType);
+    InitNoneFlag();
+}
+
+void SvgGradient::OnDraw(OH_Drawing_Canvas *canvas) {
+}
+
+void SvgGradient::SetAttrX1(const std::string& x1) {
+    gradientAttr_.gradient.GetLinearGradient().x1 = StringUtils::StringToDimensionWithUnit(x1, defaultUnit_);
+}
+
+void SvgGradient::SetAttrY1(const std::string& y1) {
+    gradientAttr_.gradient.GetLinearGradient().y1 = StringUtils::StringToDimensionWithUnit(y1, defaultUnit_);
+}
+
+void SvgGradient::SetAttrX2(const std::string& x2) {
+    gradientAttr_.gradient.GetLinearGradient().x2 = StringUtils::StringToDimensionWithUnit(x2, defaultUnit_);
+}
+
+void SvgGradient::SetAttrY2(const std::string& y2) {
+    gradientAttr_.gradient.GetLinearGradient().y2 = StringUtils::StringToDimensionWithUnit(y2, defaultUnit_);
+}
+
+void SvgGradient::SetAttrFx(const std::string& fx) {
+    gradientAttr_.gradient.GetRadialGradient().fRadialCenterX = StringUtils::StringToDimensionWithUnit(fx, defaultUnit_);
+}
+
+void SvgGradient::SetAttrFy(const std::string& fy) {
+    gradientAttr_.gradient.GetRadialGradient().fRadialCenterY = StringUtils::StringToDimensionWithUnit(fy, defaultUnit_);
+}
+
+void SvgGradient::SetAttrCx(const std::string& cx) {
+    gradientAttr_.gradient.GetRadialGradient().radialCenterX = StringUtils::StringToDimensionWithUnit(cx, defaultUnit_);
+}
+
+void SvgGradient::SetAttrCy(const std::string& cy) {
+    gradientAttr_.gradient.GetRadialGradient().radialCenterY = StringUtils::StringToDimensionWithUnit(cy, defaultUnit_);
+}
+
+void SvgGradient::SetAttrRx(const std::string& rx) {
+    gradientAttr_.gradient.GetRadialGradient().radialHorizontalSize = StringUtils::StringToDimensionWithUnit(rx, defaultUnit_);
+}
+
+void SvgGradient::SetAttrRy(const std::string& ry) {
+    gradientAttr_.gradient.GetRadialGradient().radialVerticalSize = StringUtils::StringToDimensionWithUnit(ry, defaultUnit_);
+}
+
+void SvgGradient::SetAttrGradient(std::vector<Float> gradient) {
+    auto stopCount = gradient.size() / 2;
+    gradientAttr_.gradient.ClearColors();
+    for (auto i = 0; i < stopCount; i++) {
+        auto stopIndex = i * 2;
+        GradientColor gradientColor;
+        gradientColor.SetDimension(Dimension(gradient[stopIndex]));
+        gradientColor.SetColor(Color((int32_t)gradient[stopIndex + 1]));
+        gradientAttr_.gradient.AddColor(gradientColor);
+    }
+}
+
+void SvgGradient::SetAttrGradientUnits(int gradientUnits) {
+    auto unit = static_cast<Unit>(gradientUnits);
+    if (unit < Unit::objectBoundingBox || unit > Unit::userSpaceOnUse) {
+        unit = Unit::objectBoundingBox;
+    }
+    gradientAttr_.gradient.SetGradientUnits(ToUnit(gradientUnits));
+    defaultUnit_ = (gradientAttr_.gradient.GetGradientUnits() == Unit::objectBoundingBox)
+                    ? DimensionUnit::PERCENT
+                    : DimensionUnit::VP;
+}
+
+void SvgGradient::SetAttrGradientTransforms(std::vector<Float> gradientTransforms) {
+    std::vector<Float> newMatrix {
+        1, 0, 0,
+        0, 1, 0,
+        0, 0, 1,
+    };
+    if (gradientTransforms.size() == GRADIENT_TRANSFORM_MATRIX_SIZE) {
+        newMatrix[0] = (Float) gradientTransforms[TRANSFORM_SCALE_X_INDEX];
+        newMatrix[1] = (Float) gradientTransforms[TRANSFORM_SKEW_X_INDEX];
+        newMatrix[2] = (Float) gradientTransforms[TRANSFORM_TRANSLATE_X_INDEX] * scale_;
+        newMatrix[3] = (Float) gradientTransforms[TRANSFORM_SKEW_Y_INDEX];
+        newMatrix[4] = (Float) gradientTransforms[TRANSFORM_SCALE_Y_INDEX];
+        newMatrix[5] = (Float) gradientTransforms[TRANSFORM_TRANSLATE_Y_INDEX] * scale_;
+        gradientAttr_.gradient.SetGradientTransform(std::move(newMatrix));
+    }
+}
+
+const Gradient& SvgGradient::GetGradient() const
+{
+    return gradientAttr_.gradient;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/SvgGradient.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "SvgGraphic.h"
+#include <native_drawing/drawing_point.h>
+#include "utils/SvgAttributesParser.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgGradient : public SvgNode {
+public:
+    using Float = facebook::react::Float;
+    explicit SvgGradient(GradientType gradientType);
+    ~SvgGradient() override = default;
+    
+    void OnDraw(OH_Drawing_Canvas *canvas) override;
+
+    void SetAttrX1(const std::string& x1);
+    void SetAttrY1(const std::string& y1);
+    void SetAttrX2(const std::string& x2);
+    void SetAttrY2(const std::string& y2);
+
+    void SetAttrFx(const std::string& fx);
+    void SetAttrFy(const std::string& fy);
+    void SetAttrCx(const std::string& cx);
+    void SetAttrCy(const std::string& cy);
+    void SetAttrRx(const std::string& rx);
+    void SetAttrRy(const std::string& ry);
+
+    void SetAttrGradient(std::vector<Float> gradient);
+    void SetAttrGradientUnits(int gradientUnits);
+    void SetAttrGradientTransforms(std::vector<Float> gradientTransforms);
+
+    const Gradient& GetGradient() const;
+
+private:
+    SvgGradientAttribute gradientAttr_;
+    double scale_ = 3.25;
+    DimensionUnit defaultUnit_ = DimensionUnit::VP;
+};
+
+} // namespace svg
+} // namespace rnoh