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

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SVGPackage.cpp

@@ -0,0 +1,135 @@
+/*
+ * 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 "SVGPackage.h"
+
+#include "RNOH/generated/components/RNSVGGroupJSIBinder.h"
+#include "RNOH/generated/components/RNSVGSvgViewJSIBinder.h"
+#include "RNOH/generated/components/RNSVGPathJSIBinder.h"
+#include "RNOH/generated/components/RNSVGRectJSIBinder.h"
+#include "RNOH/generated/components/RNSVGImageJSIBinder.h"
+#include "RNOH/generated/components/RNSVGCircleJSIBinder.h"
+#include "RNOH/generated/components/RNSVGEllipseJSIBinder.h"
+#include "RNOH/generated/components/RNSVGLinearGradientJSIBinder.h"
+#include "RNOH/generated/components/RNSVGDefsJSIBinder.h"
+#include "RNOH/generated/components/RNSVGTextJSIBinder.h"
+#include "RNOH/generated/components/RNSVGTSpanJSIBinder.h"
+#include "RNOH/generated/components/RNSVGClipPathJSIBinder.h"
+#include "RNOH/generated/components/RNSVGMaskJSIBinder.h"
+#include "RNOH/generated/components/RNSVGMarkerJSIBinder.h"
+#include "RNOH/generated/components/RNSVGUseJSIBinder.h"
+#include "RNOH/generated/components/RNSVGForeignObjectJSIBinder.h"
+#include "RNOH/generated/components/RNSVGLineJSIBinder.h"
+#include "RNOH/generated/components/RNSVGPatternJSIBinder.h"
+#include "RNOH/generated/components/RNSVGRadialGradientJSIBinder.h"
+#include "RNOH/generated/components/RNSVGSymbolJSIBinder.h"
+#include "RNOH/generated/components/RNSVGTextPathJSIBinder.h"
+#include "RNOH/generated/components/RNSVGFilterJSIBinder.h"
+#include "RNOH/generated/components/RNSVGFeBlendJSIBinder.h"
+#include "RNOH/generated/components/RNSVGFeColorMatrixJSIBinder.h"
+#include "RNOH/generated/components/RNSVGFeCompositeJSIBinder.h"
+#include "RNOH/generated/components/RNSVGFeGaussianBlurJSIBinder.h"
+#include "RNOH/generated/components/RNSVGFeFloodJSIBinder.h"
+#include "RNOH/generated/components/RNSVGFeOffsetJSIBinder.h"
+#include "turboModules/RNSVGSvgViewModule.h"
+#include "turboModules/RNSVGRenderableModule.h"
+#include "turboModules/RNSVGImageModule.h"
+#include <react/renderer/components/react_native_svg/ComponentDescriptors.h>
+#include "svgImage/RNSVGImageComponentDescriptor.h"
+
+using namespace rnoh;
+using namespace facebook;
+using namespace svg;
+
+std::vector<react::ComponentDescriptorProvider> SVGPackage::createComponentDescriptorProviders() {
+    return {
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGCircleComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGClipPathComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGDefsComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGEllipseComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGFeBlendComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGFeColorMatrixComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGFeCompositeComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGFeGaussianBlurComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGFeFloodComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGFeOffsetComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGFilterComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGForeignObjectComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGGroupComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGSvgViewComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGImageComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGLineComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGLinearGradientComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGMarkerComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGMaskComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGPathComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGPatternComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGRadialGradientComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGRectComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGSymbolComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGTSpanComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGTextComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGTextPathComponentDescriptor>(),
+        facebook::react::concreteComponentDescriptorProvider<facebook::react::RNSVGUseComponentDescriptor>(),
+    };
+}
+
+ComponentNapiBinderByString SVGPackage::createComponentNapiBinderByName() { return {}; }
+
+ComponentJSIBinderByString SVGPackage::createComponentJSIBinderByName() {
+    return {
+        {"RNSVGCircle", std::make_shared<RNSVGCircleJSIBinder>()},
+        {"RNSVGClipPath", std::make_shared<RNSVGClipPathJSIBinder>()},
+        {"RNSVGDefs", std::make_shared<RNSVGDefsJSIBinder>()},
+        {"RNSVGEllipse", std::make_shared<RNSVGEllipseJSIBinder>()},
+        {"RNSVGForeignObject", std::make_shared<RNSVGForeignObjectJSIBinder>()},
+        {"RNSVGGroup", std::make_shared<RNSVGGroupJSIBinder>()},
+        {"RNSVGSvgView", std::make_shared<RNSVGSvgViewJSIBinder>()},
+        {"RNSVGImage", std::make_shared<RNSVGImageJSIBinder>()},
+        {"RNSVGLine", std::make_shared<RNSVGLineJSIBinder>()},
+        {"RNSVGLinearGradient", std::make_shared<RNSVGLinearGradientJSIBinder>()},
+        {"RNSVGRadialGradient", std::make_shared<RNSVGRadialGradientJSIBinder>()},
+        {"RNSVGMarker", std::make_shared<RNSVGMarkerJSIBinder>()},
+        {"RNSVGMask", std::make_shared<RNSVGMaskJSIBinder>()},
+        {"RNSVGPath", std::make_shared<RNSVGPathJSIBinder>()},
+        {"RNSVGPattern", std::make_shared<RNSVGPatternJSIBinder>()},
+        {"RNSVGRect", std::make_shared<RNSVGRectJSIBinder>()},
+        {"RNSVGSymbol", std::make_shared<RNSVGSymbolJSIBinder>()},
+        {"RNSVGTSpan", std::make_shared<RNSVGTSpanJSIBinder>()},
+        {"RNSVGText", std::make_shared<RNSVGTextJSIBinder>()},
+        {"RNSVGTextPath", std::make_shared<RNSVGTextPathJSIBinder>()},
+        {"RNSVGUse", std::make_shared<RNSVGUseJSIBinder>()},
+        {"RNSVGFilter", std::make_shared<RNSVGFilterJSIBinder>()},
+        {"RNSVGFeBlend", std::make_shared<RNSVGFeBlendJSIBinder>()},
+        {"RNSVGFeColorMatrix", std::make_shared<RNSVGFeColorMatrixJSIBinder>()},
+        {"RNSVGFeComposite", std::make_shared<RNSVGFeCompositeJSIBinder>()},
+        {"RNSVGFeGaussianBlur", std::make_shared<RNSVGFeGaussianBlurJSIBinder>()},
+        {"RNSVGFeFlood", std::make_shared<RNSVGFeFloodJSIBinder>()},
+        {"RNSVGFeOffset", std::make_shared<RNSVGFeOffsetJSIBinder>()},
+    };
+};
+
+class SvgTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+        if (name == "RNSVGSvgViewModule") {
+            return std::make_shared<RNSVGSvgViewModule>(ctx, name);
+        }
+        if (name == "RNSVGRenderableModule") {
+            return std::make_shared<RNSVGRenderableModule>(ctx, name);
+        }
+        if (name == "RNSVGImageModule") {
+            return std::make_shared<RNSVGImageModule>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+
+std::unique_ptr<TurboModuleFactoryDelegate> SVGPackage::createTurboModuleFactoryDelegate() {
+    return std::make_unique<SvgTurboModuleFactoryDelegate>();
+}

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SVGPackage.h

@@ -0,0 +1,157 @@
+/*
+ * 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 "RNOH/Package.h"
+#include <glog/logging.h>
+#include "componentInstances/RNSVGForeignObjectComponentInstance.h"
+#include "componentInstances/RNSVGSvgViewComponentInstance.h"
+#include "componentInstances/RNSVGCircleComponentInstance.h"
+#include "componentInstances/RNSVGGroupComponentInstance.h"
+#include "componentInstances/RNSVGPathComponentInstance.h"
+#include "componentInstances/RNSVGRectComponentInstance.h"
+#include "componentInstances/RNSVGImageComponentInstance.h"
+#include "componentInstances/RNSVGEllipseComponentInstance.h"
+#include "componentInstances/RNSVGLinearGradientComponentInstance.h"
+#include "componentInstances/RNSVGRadialGradientComponentInstance.h"
+#include "componentInstances/RNSVGLineComponentInstance.h"
+#include "componentInstances/RNSVGDefsComponentInstance.h"
+#include "componentInstances/RNSVGTextComponentInstance.h"
+#include "componentInstances/RNSVGTextPathComponentInstance.h"
+#include "componentInstances/RNSVGTSpanComponentInstance.h"
+#include "componentInstances/RNSVGClipPathComponentInstance.h"
+#include "componentInstances/RNSVGMaskComponentInstance.h"
+#include "componentInstances/RNSVGUseComponentInstance.h"
+#include "componentInstances/RNSVGMarkerComponentInstance.h"
+#include "componentInstances/RNSVGPatternComponentInstance.h"
+#include "componentInstances/RNSVGSymbolComponentInstance.h"
+#include "componentInstances/RNSVGFilterComponentInstance.h"
+#include "componentInstances/RNSVGFeBlendComponentInstance.h"
+#include "componentInstances/RNSVGFeColorMatrixComponentInstance.h"
+#include "componentInstances/RNSVGFeFloodComponentInstance.h"
+#include "componentInstances/RNSVGFeCompositeComponentInstance.h"
+#include "componentInstances/RNSVGFeGaussianBlurComponentInstance.h"
+#include "componentInstances/RNSVGFeOffsetComponentInstance.h"
+
+using namespace rnoh;
+using namespace facebook;
+using namespace svg;
+
+namespace rnoh {
+
+class SVGPackageComponentInstanceFactoryDelegate : public ComponentInstanceFactoryDelegate {
+public:
+    using ComponentInstanceFactoryDelegate::ComponentInstanceFactoryDelegate;
+
+    ComponentInstance::Shared create(ComponentInstance::Context ctx) override {
+        DLOG(INFO) << "[SVGPackageComponentInstanceFactoryDelegate] create componentName= " << ctx.componentName;
+        if (ctx.componentName == "RNSVGSvgView") {
+            return std::make_shared<RNSVGSvgViewComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGForeignObject") {
+           return std::make_shared<RNSVGForeignObjectComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGCircle") {
+            return std::make_shared<RNSVGCircleComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGGroup") {
+            return std::make_shared<RNSVGGroupComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGPath") {
+            return std::make_shared<RNSVGPathComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGRect") {
+            return std::make_shared<RNSVGRectComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGImage") {
+            return std::make_shared<RNSVGImageComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGEllipse") {
+            return std::make_shared<RNSVGEllipseComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGLinearGradient") {
+            return std::make_shared<RNSVGLinearGradientComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGRadialGradient") {
+            return std::make_shared<RNSVGRadialGradientComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGLine") {
+            return std::make_shared<RNSVGLineComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGDefs") {
+            return std::make_shared<RNSVGDefsComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGText") {
+            return std::make_shared<RNSVGTextComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGTSpan") {
+            return std::make_shared<RNSVGTSpanComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGTextPath") {
+            return std::make_shared<RNSVGTextPathComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGClipPath") {
+            return std::make_shared<RNSVGClipPathComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGMask") {
+            return std::make_shared<RNSVGMaskComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGUse") {
+            return std::make_shared<RNSVGUseComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGMarker") {
+            return std::make_shared<RNSVGMarkerComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGPattern") {
+            return std::make_shared<RNSVGPatternComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGSymbol") {
+            return std::make_shared<RNSVGSymbolComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGFilter") {
+            return std::make_shared<RNSVGFilterComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGFeBlend") {
+            return std::make_shared<RNSVGFeBlendComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGFeColorMatrix") {
+            return std::make_shared<RNSVGFeColorMatrixComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGFeFlood") {
+            return std::make_shared<RNSVGFeFloodComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGFeComposite") {
+            return std::make_shared<RNSVGFeCompositeComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGFeGaussianBlur") {
+            return std::make_shared<RNSVGFeGaussianBlurComponentInstance>(std::move(ctx));
+        }
+        if (ctx.componentName == "RNSVGFeOffset") {
+            return std::make_shared<RNSVGFeOffsetComponentInstance>(std::move(ctx));
+        }
+        return nullptr;
+    }
+};
+
+class SVGPackage : public Package {
+public:
+    explicit SVGPackage(Package::Context ctx) : Package(ctx) {}
+
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override;
+
+    ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate() override {
+        return std::make_shared<SVGPackageComponentInstanceFactoryDelegate>();
+    }
+
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override;
+
+    ComponentNapiBinderByString createComponentNapiBinderByName() override;
+
+    ComponentJSIBinderByString createComponentJSIBinderByName() override;
+};
+
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgArkUINode.cpp

@@ -0,0 +1,78 @@
+/*
+ * 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 "arkui/native_node.h"
+#include "arkui/native_type.h"
+#include "RNOH/arkui/NativeNodeApi.h"
+#include "SvgArkUINode.h"
+#include <native_drawing/drawing_canvas.h>
+#include <native_drawing/drawing_path.h>
+#include <native_drawing/drawing_pen.h>
+#include <native_drawing/drawing_types.h>
+#include <sstream>
+#include <functional>
+#include "SvgViewManager.h"
+
+namespace rnoh {
+namespace svg {
+
+constexpr int NODE_EVENT_ID = 77;
+
+// 对应SVGArkUINode
+SvgArkUINode::SvgArkUINode() : ArkUINode(NativeNodeApi::getInstance()->createNode(ArkUI_NodeType::ARKUI_NODE_CUSTOM)) {
+    userCallback_ = new UserCallback();
+    // 设置自定义回调。注册onDraw
+    userCallback_->callback = [this](ArkUI_NodeCustomEvent *event) {
+        auto type = OH_ArkUI_NodeCustomEvent_GetEventType(event);
+        switch (type) {
+        case ARKUI_NODE_CUSTOM_EVENT_ON_DRAW:
+            OnDraw(event);
+            break;
+        default:
+            break;
+        }
+    };
+    eventReceiver = [](ArkUI_NodeCustomEvent *event) {
+        if (OH_ArkUI_NodeCustomEvent_GetEventTargetId(event) == NODE_EVENT_ID) {
+            auto *userData = reinterpret_cast<UserCallback *>(OH_ArkUI_NodeCustomEvent_GetUserData(event));
+            if (userData != nullptr && userData->callback != nullptr) {
+                userData->callback(event);
+            }
+        }
+    };
+    maybeThrow(NativeNodeApi::getInstance()->addNodeCustomEventReceiver(m_nodeHandle, eventReceiver));
+    maybeThrow(NativeNodeApi::getInstance()->registerNodeCustomEvent(m_nodeHandle, ARKUI_NODE_CUSTOM_EVENT_ON_DRAW, NODE_EVENT_ID,
+                                                                     userCallback_));
+}
+
+SvgArkUINode::~SvgArkUINode() {
+    NativeNodeApi::getInstance()->removeNodeCustomEventReceiver(m_nodeHandle, eventReceiver);
+    NativeNodeApi::getInstance()->unregisterNodeCustomEvent(m_nodeHandle, ARKUI_NODE_CUSTOM_EVENT_ON_DRAW);
+    delete userCallback_;
+    userCallback_ = nullptr;
+}
+
+void SvgArkUINode::AddChild(ArkUINode &node) {
+    maybeThrow(NativeNodeApi::getInstance()->addChild(m_nodeHandle, node.getArkUINodeHandle()));
+}
+void SvgArkUINode::OnDraw(ArkUI_NodeCustomEvent *event) {
+    auto *drawContext = OH_ArkUI_NodeCustomEvent_GetDrawContextInDraw(event);
+    auto *drawingHandle = reinterpret_cast<OH_Drawing_Canvas *>(OH_ArkUI_DrawContext_GetCanvas(drawContext));
+    DLOG(INFO) << "[svg] <SVGArkUINode> CanvasGetHeight: " << OH_Drawing_CanvasGetHeight(drawingHandle);
+    DLOG(INFO) << "[svg] <SVGArkUINode> CanvasGetWidth: " << OH_Drawing_CanvasGetWidth(drawingHandle);
+    auto root = root_.lock();
+    CHECK_NULL_VOID(root);
+    if (root->GetContext()) {
+        // reset the idMap
+        root->GetContext()->ClearIdMap();
+    }
+    root->ContextTraversal();
+    root->InitStyle({});
+    root->Draw(drawingHandle);
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgArkUINode.h

@@ -0,0 +1,51 @@
+/*
+ * 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 "RNOH/arkui/ArkUINode.h"
+#include "SvgForeignObjectNodeDelegate.h"
+#include "SvgForeignProps.h"
+#include "SvgHost.h"
+#include "SvgNode.h"
+#include "arkui/native_node.h"
+
+namespace rnoh {
+namespace svg {
+
+struct UserCallback {
+    std::function<void(ArkUI_NodeCustomEvent *event)> callback;
+};
+
+// ArkUINode
+class SvgArkUINode : public ArkUINode {
+private:
+    void OnDraw(ArkUI_NodeCustomEvent *event);
+    
+    std::weak_ptr<SvgNode> root_;
+    ArkUI_NativeNodeAPI_1 *nativeModule_ = nullptr;
+    UserCallback *userCallback_ = nullptr;
+    std::weak_ptr<SvgNode> _groupNode;
+    std::vector<ForeignProps> foreignPropsArray;
+    void (*eventReceiver)(ArkUI_NodeCustomEvent *event);
+ 
+public:
+    SvgArkUINode();
+    ~SvgArkUINode() override;
+
+    void SetSvgNode(const std::weak_ptr<SvgNode> &node) { root_ = node; }
+    void SetGroupNode(const std::weak_ptr<SvgNode> &node) { _groupNode = node; }
+    void ResetNodeHandle() {}
+    void AddChild(ArkUINode &node);
+    void SetForeignObject(ForeignProps foreignProps) {
+        if (auto groupNode = _groupNode.lock()) {
+            groupNode->SetForeignObject(std::move(foreignProps));
+        }
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgBaseAttribute.h

@@ -0,0 +1,83 @@
+/*
+ * 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.
+ *
+ * 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.
+ */
+
+// from ArkUI "frameworks/core/components/declaration/svg/svg_base_declaration.h"
+#pragma once
+
+#include "Attribute.h"
+#include "properties/SvgPaintState.h"
+#include <string>
+#include <vector>
+
+namespace rnoh {
+namespace svg {
+
+const char VALUE_NONE[] = "none";
+
+struct SvgBaseAttribute : Attribute {
+    double selfOpacity = 1.0; // opacity declared in tag attribute
+    double opacity = 1.0; // multiplied with parent opacity. The actual opacity to be drawn
+    float smoothEdge = 0.0f;
+    FillState fillState;
+    StrokeState strokeState;
+//     SvgTextStyle textStyle;
+    std::vector<double> transform; // transform matrix
+    std::string transformOrigin;
+    std::string filterId;
+    std::string maskId;
+    std::string id;
+    std::string markerStart;
+    std::string markerMid;
+    std::string markerEnd;
+    std::string clipPath;
+    ClipState clipState;
+    bool hasInheritedFilter = false; // Indicates if the filterId is inherited from parent node
+    bool hasFilter = false; 
+
+    void InheritFromUse(const SvgBaseAttribute& parent)
+    {
+        opacity = selfOpacity * parent.opacity;
+        fillState.Inherit(parent.fillState);
+        strokeState.Inherit(parent.strokeState);
+        clipState.Inherit(parent.clipState);
+        // 继承filter属性
+        if (filterId.empty()) {
+            filterId = parent.filterId;
+            hasInheritedFilter = parent.hasInheritedFilter;
+        }
+    }
+
+    void Inherit(const SvgBaseAttribute& parent)
+    {
+        opacity = selfOpacity * parent.opacity;
+        fillState.Inherit(parent.fillState);
+        strokeState.Inherit(parent.strokeState);
+        clipState.Inherit(parent.clipState);
+        // 继承filter属性
+        if (filterId.empty()) {
+            filterId = parent.filterId;
+            hasInheritedFilter = parent.hasInheritedFilter;
+        }
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgCircle.cpp

@@ -0,0 +1,29 @@
+/*
+ * 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 "SvgCircle.h"
+
+namespace rnoh {
+namespace svg {
+
+drawing::Path SvgCircle::AsPath() {
+    drawing::Path path;
+    double x = relativeOnWidth(circleAttribute_.cx);
+    double y = relativeOnHeight(circleAttribute_.cy);
+    double r = relativeOnOther(circleAttribute_.r);
+    
+    path.AddCircle(x, y, r, PATH_DIRECTION_CW);
+    
+    elements_ = {PathElement(ElementType::kCGPathElementMoveToPoint, {Point(x, y - r)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x, y - r), Point(x + r, y)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x + r, y), Point(x, y + r)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x, y + r), Point(x - r, y)}),
+                       PathElement(ElementType::kCGPathElementAddLineToPoint, {Point(x - r, y), Point(x, y - r)})};
+    return path;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgCircle.h

@@ -0,0 +1,29 @@
+/*
+ * 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 "utils/SvgAttributesParser.h"
+
+namespace rnoh {
+namespace svg {
+
+class SvgCircle : public SvgGraphic {
+public:
+    SvgCircle() = default;
+    ~SvgCircle() override = default;
+
+    void SetX(const std::string &x) { circleAttribute_.cx = SvgAttributesParser::ParseDimension(x, true); }
+    void SetY(const std::string &y) { circleAttribute_.cy = SvgAttributesParser::ParseDimension(y, true); }
+    void SetR(const std::string &r) { circleAttribute_.r = SvgAttributesParser::ParseDimension(r, true); }
+    drawing::Path AsPath() override;
+private:
+    SvgCircleAttribute circleAttribute_;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgClipPath.h

@@ -0,0 +1,22 @@
+/*
+ * 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 "SvgQuote.h"
+
+namespace rnoh {
+namespace svg {
+
+    class SvgClipPath : public SvgQuote {
+
+    public:
+        SvgClipPath() = default;
+        ~SvgClipPath() override = default;
+    };
+    
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/SvgContext.cpp

@@ -0,0 +1,56 @@
+/*
+ * 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 <iostream>
+#include "SvgNode.h"
+
+namespace rnoh {
+namespace svg {
+std::shared_ptr<SvgNode> SvgContext::GetSvgNodeById(const std::string &id) const {
+    auto item = idMapper_.find(id);
+    if (item != idMapper_.end()) {
+        auto node = item->second.lock();
+        if (node) {
+            return node;
+        }
+    }
+    return nullptr;
+}
+
+void SvgContext::PushStyle(const std::string &styleName, const std::pair<std::string, std::string> &attrPair) {
+    const auto &arrMapIter = styleMap_.find(styleName);
+    if (arrMapIter == styleMap_.end()) {
+        AttrMap attrMap;
+        attrMap.emplace(attrPair);
+        styleMap_.emplace(std::make_pair(styleName, attrMap));
+    } else {
+        if (arrMapIter->second.find(attrPair.first) != arrMapIter->second.end()) {
+            arrMapIter->second.erase(attrPair.first);
+        }
+        arrMapIter->second.emplace(attrPair);
+    }
+}
+
+const AttrMap &SvgContext::GetAttrMap(const std::string &key) const {
+    auto styleClassIter = styleMap_.find(key);
+    if (styleClassIter != styleMap_.end()) {
+        return styleClassIter->second;
+    }
+    static AttrMap emptyMap;
+    return emptyMap;
+}
+
+const Rect &SvgContext::GetRootViewBox() const {
+    if (!rootViewBox_.IsValid()) {
+        static Rect rect;
+        rect = Rect(0, 0, svgSize_.Width(), svgSize_.Height());
+        return rect;
+    }
+    return rootViewBox_;
+}
+
+} // namespace svg
+} // namespace rnoh