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

package/harmony/svg/BuildProfile.ets

@@ -1,7 +1,7 @@
 /**
  * Use these variables when you tailor your ArkTS code. They must be of the const type.
  */
-export const HAR_VERSION = '15.12.1-rc.2';
+export const HAR_VERSION = '15.12.1-rc.5';
 export const BUILD_MODE_NAME = 'debug';
 export const DEBUG = true;
 export const TARGET_NAME = 'default';

package/harmony/svg/oh-package.json5

@@ -6,7 +6,7 @@
   name: '@react-native-ohos/react-native-svg',
   type: 'module',
   main: 'index.ets',
-  version: '15.12.1-rc.5',
+  version: '15.12.1-rc.7',
   dependencies: {
     "@rnoh/react-native-openharmony": "file:../../node_modules/@react-native-oh/react-native-harmony/harmony/react_native_openharmony.har"
   },

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

@@ -23,7 +23,7 @@ target_link_libraries(rnoh_svg PUBLIC libimage_packer.so)
 target_link_libraries(rnoh_svg PUBLIC librawfile.z.so)
 target_link_libraries(rnoh_svg PUBLIC librcp_c.so)
 target_link_libraries(rnoh_svg PUBLIC libohfileuri.so)
-
+target_link_libraries(rnoh_svg PUBLIC libdeviceinfo_ndk.z.so)
 
 if("${OHOS_ARCH}" STREQUAL "arm64-v8a")
     target_link_directories(rnoh_svg PUBLIC ${HMOS_SDK_NATIVE}/sysroot/usr/lib/aarch64-linux-ohos)

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

@@ -8,6 +8,7 @@
 
 #include "RNOH/arkui/ArkUINode.h"
 #include "SvgForeignObjectNodeDelegate.h"
+#include "SvgForeignProps.h"
 #include "SvgHost.h"
 #include "SvgNode.h"
 #include "arkui/native_node.h"
@@ -39,8 +40,7 @@ public:
     void SetGroupNode(const std::weak_ptr<SvgNode> &node) { _groupNode = node; }
     void ResetNodeHandle() {}
     void AddChild(ArkUINode &node);
-    void SetForeignObject(OH_PixelmapNative *pixelMap, float w, float h, float x, float y) {
-        ForeignProps foreignProps = {std::move(pixelMap), w, h, x, y};
+    void SetForeignObject(ForeignProps foreignProps) {
         if (auto groupNode = _groupNode.lock()) {
             groupNode->SetForeignObject(std::move(foreignProps));
         }

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

@@ -40,11 +40,11 @@ SvgForeignObjectNode::~SvgForeignObjectNode() {
 }
 void SvgForeignObjectNode::insertChild(ArkUINode &child, std::size_t index) { mStackNode.insertChild(child, index); }
 
-void SvgForeignObjectNode::SetSnapHeight(float height) { _height = height; }
+void SvgForeignObjectNode::SetSnapHeight(Dimension height) { _height = height; }
 
-void SvgForeignObjectNode::SetSnapWidth(float width) { _width = width; }
+void SvgForeignObjectNode::SetSnapWidth(Dimension width) { _width = width; }
 
-void SvgForeignObjectNode::SetSnapPosition(float x, float y) {
+void SvgForeignObjectNode::SetSnapPosition(Dimension x, Dimension y) {
     _positionX = x;
     _positionY = y;
 }
@@ -58,17 +58,17 @@ void SvgForeignObjectNode::onNodeEvent(ArkUI_NodeEventType eventType, EventArgs
                 return;
             }
             _isGeneratedPixelMap = false;
-            m_NodeDelegate->onDrawForeignImage(pixelMap, _width, _height, _positionX, _positionY);
+            ForeignProps foreignProps = {pixelMap, _width, _height, _positionX, 
+                _positionY, _path, _clipRule, _mask, pointScaleFactor_, transform_};
+            m_NodeDelegate->onDrawForeignImage(foreignProps);
         }
     }
 }
 
 OH_PixelmapNative *SvgForeignObjectNode::GetNodePixelMap() {
-    DLOG(INFO) << "[svgForeignNode] OH_CURRENT_API_VERSION:" << OH_CURRENT_API_VERSION
-                << ";ROM SDK:" << OH_GetSdkApiVersion();
-    
-#if OH_CURRENT_API_VERSION >= 15
-    if (OH_GetSdkApiVersion() < 15) {
+#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;

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

@@ -24,6 +24,7 @@
 #include "RNOH/arkui/ArkUINode.h"
 #include "RNOH/arkui/StackNode.h"
 #include "SvgForeignObjectNodeDelegate.h"
+#include "properties/Dimension.h"
 
 namespace rnoh {
 namespace svg {
@@ -34,21 +35,44 @@ public:
     void onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) override;
     StackNode &getSnapNode() { return mStackNode; }
     void insertChild(ArkUINode &child, std::size_t index);
-    void SetSnapPosition(float x, float y);
-    void SetSnapWidth(float width);
-    void SetSnapHeight(float height);
+    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;
-    float _width{0};
-    float _height{0};
-    float _positionX{0};
-    float _positionY{0};
+    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}; //防止快照生成多次，导致性能影响
 };
 

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

@@ -21,10 +21,10 @@
 
 #ifndef HARMONY_SVGFOREIGNOBJECTNODEDELEGATE_H
 #define HARMONY_SVGFOREIGNOBJECTNODEDELEGATE_H
-#include <multimedia/image_framework/image/pixelmap_native.h>
+#include "SvgForeignProps.h"
 class SvgForeignObjectNodeDelegate {
 public:
     virtual ~SvgForeignObjectNodeDelegate() = default;
-    virtual void onDrawForeignImage(OH_PixelmapNative *foreignPixelMap,float width,float height,float x,float y){};
+    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/SvgNode.cpp

@@ -141,9 +141,8 @@ void SvgNode::OnMask(OH_Drawing_Canvas *canvas) {
     refMask->Draw(canvas);
 }
 
-void SvgNode::OnTransform(OH_Drawing_Canvas *canvas) {
+void SvgNode::OnTransform(OH_Drawing_Canvas *canvas, std::vector<double> transform) {
     // input transfrom: (float scaleX, float skewY, float skewX, float scaleY, float transX, float transY)
-    const auto &transform = attributes_.transform;
     /* (OH_Drawing_Matrix* , float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float
     persp0, float persp1, float persp2 )
     */
@@ -192,7 +191,7 @@ void SvgNode::Draw(OH_Drawing_Canvas *canvas) {
     const auto count = OH_Drawing_CanvasGetSaveCount(canvas);
     OH_Drawing_CanvasSave(canvas);
     if (!attributes_.transform.empty()) {
-        OnTransform(canvas);
+        OnTransform(canvas, attributes_.transform);
     }
     if (!hrefClipPath_.empty()) {
         OnClipPath(canvas);
@@ -296,12 +295,55 @@ double SvgNode::getCanvasDiagonal() {
     return canvasDiagonal_;
 }
 
+void SvgNode::DrawForeignClip(OH_Drawing_Canvas *canvas,const std::string &id,int clipRule) {
+    if (!context_) {
+        DLOG(INFO) << "[svgForeignNode] NO CONTEXT";
+        return;
+    }
+    auto refSvgNode = context_->GetSvgNodeById(id);
+    if (!refSvgNode) {
+        DLOG(WARNING) << "[svgForeignNode] clipPath: SvgNode is null!";
+        return;
+    };
+    auto clipPath = refSvgNode->AsPath();
+    drawing::Path::FillType fillType = clipRule == 0
+                                           ? OH_Drawing_PathFillType::PATH_FILL_TYPE_EVEN_ODD
+                                           : OH_Drawing_PathFillType::PATH_FILL_TYPE_WINDING;
+    clipPath.SetFillType(fillType);
+    OH_Drawing_CanvasClipPath(canvas, clipPath.get(), OH_Drawing_CanvasClipOp::INTERSECT, true);
+}
+
+void SvgNode::DrawForeignMask(OH_Drawing_Canvas *canvas, const std::string &id) {
+    if (!context_) {
+        DLOG(INFO) << "[svgForeignNode] NO CONTEXT";
+        return;
+    }
+    auto refMask = context_->GetSvgNodeById(id);
+    if (!refMask) {
+        return;
+    };
+    refMask->Draw(canvas);
+}
+
 void SvgNode::DrawForeignPixelMap(OH_Drawing_Canvas *canvas, ForeignProps _foreignProps) {
     if (!_foreignProps.foreignPixelMap) {
         DLOG(INFO) << "[svgForeignNode] foreignPixelMap is null";
         return;
     }
-    DLOG(INFO) << "[svgForeignNode] DrawForeignPixelMap  start , width:" << _foreignProps.width;
+    if (!_foreignProps.transform.empty()) {
+        OnTransform(canvas, _foreignProps.transform);
+    }
+    if (!_foreignProps.path.empty()) {
+        DrawForeignClip(canvas,_foreignProps.path, _foreignProps.clipRule);
+    }
+    
+    if (!_foreignProps.mask.empty()) {
+        DrawForeignMask(canvas,_foreignProps.mask);
+    }
+    double postionX = _foreignProps.x.ParsePropsToPx(OH_Drawing_CanvasGetWidth(canvas), _foreignProps.pointScaleFactor);
+    double postionY = _foreignProps.y.ParsePropsToPx(OH_Drawing_CanvasGetHeight(canvas), _foreignProps.pointScaleFactor);
+    double foreignW = _foreignProps.width.ParsePropsToPx(OH_Drawing_CanvasGetWidth(canvas), _foreignProps.pointScaleFactor);
+    double foreignH = _foreignProps.height.ParsePropsToPx(OH_Drawing_CanvasGetHeight(canvas), _foreignProps.pointScaleFactor);
     OH_Pixelmap_ImageInfo *imageInfo;
     OH_PixelmapImageInfo_Create(&imageInfo);
 
@@ -316,7 +358,9 @@ void SvgNode::DrawForeignPixelMap(OH_Drawing_Canvas *canvas, ForeignProps _forei
         OH_PixelmapNative_Release(_foreignProps.foreignPixelMap);
         return;
     }
-
+    float  originalRelWidth  = originalWidth > foreignW ? foreignW : originalWidth;
+    float  originalRelHeight  = originalHeight > foreignH ? foreignH : originalHeight;
+    DLOG(INFO) << "[svgForeignNode] DrawForeignPixelMap start , foreignH:" << foreignH << ";originalHeight:" << originalHeight <<";originalRelHeight:" << originalRelHeight;
     OH_Drawing_PixelMap *ohPixelMap = OH_Drawing_PixelMapGetFromOhPixelMapNative(_foreignProps.foreignPixelMap);
     if (!ohPixelMap) {
         DLOG(WARNING) << "[svgForeignNode] Failed to get OH_Drawing_PixelMap";
@@ -326,15 +370,12 @@ void SvgNode::DrawForeignPixelMap(OH_Drawing_Canvas *canvas, ForeignProps _forei
 
     OH_Drawing_CanvasSave(canvas);
 
-    OH_Drawing_CanvasTranslate(canvas, _foreignProps.x, _foreignProps.y);
-
-
-    float scaleX = static_cast<float>(_foreignProps.width) / originalWidth;
-    float scaleY = static_cast<float>(_foreignProps.height) / originalHeight;
+    OH_Drawing_CanvasTranslate(canvas, postionX, postionY);
+    
     OH_Drawing_CanvasScale(canvas, 1, 1);
 
-    OH_Drawing_Rect *srcRect = OH_Drawing_RectCreate(0, 0, originalWidth, originalHeight);
-    OH_Drawing_Rect *dstRect = OH_Drawing_RectCreate(0, 0, originalWidth, originalHeight);
+    OH_Drawing_Rect *srcRect = OH_Drawing_RectCreate(0, 0, originalRelWidth, originalRelHeight);
+    OH_Drawing_Rect *dstRect = OH_Drawing_RectCreate(0, 0, originalRelWidth, originalRelHeight);
     OH_Drawing_SamplingOptions *sampling = OH_Drawing_SamplingOptionsCreate(FILTER_MODE_LINEAR, MIPMAP_MODE_LINEAR);
     OH_Drawing_CanvasDrawPixelMapRect(canvas, ohPixelMap, srcRect, dstRect, sampling);
 

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

@@ -28,6 +28,7 @@
 #include <type_traits>
 #include "SvgBaseAttribute.h"
 #include "SvgContext.h"
+#include "SvgForeignProps.h"
 #include "properties/Decoration.h"
 #include "properties/Dimension.h"
 #include "properties/Size.h"
@@ -44,15 +45,6 @@
 namespace rnoh {
 namespace svg {
 
-struct ForeignProps {
-    OH_PixelmapNative *foreignPixelMap{nullptr};
-    float width;
-    float height;
-    float x;
-    float y;
-};
-
-
 constexpr int INHERIT_TYPE = 2;
 
 class SvgNode : public std::enable_shared_from_this<SvgNode> {
@@ -306,6 +298,7 @@ public:
     void SetForeignObject(ForeignProps foreignProps) {
         _foreignPropsArray.emplace_back(foreignProps);
     }
+    
 
 protected:
     // override as need by derived class
@@ -318,7 +311,7 @@ protected:
     virtual void OnDrawTraversed(OH_Drawing_Canvas *canvas);
     void OnClipPath(OH_Drawing_Canvas *canvas);
     void OnMask(OH_Drawing_Canvas *canvas);
-    void OnTransform(OH_Drawing_Canvas *canvas);
+    void OnTransform(OH_Drawing_Canvas *canvas, std::vector<double> transform);
 
     const Rect &GetRootViewBox() const;
 
@@ -329,6 +322,9 @@ protected:
 
     std::shared_ptr<PatternAttr> GetPatternAttr(const std::string &href);
     void DrawForeignPixelMap(OH_Drawing_Canvas *canvas,ForeignProps _foreignProps);
+    void DrawForeignMask(OH_Drawing_Canvas *canvas, const std::string &id);
+    void DrawForeignClip(OH_Drawing_Canvas *canvas, const std::string &id, int clipRule);
+    
     void InitNoneFlag() {
         hrefFill_ = false;
         hrefRender_ = false;

package/harmony/svg/src/main/cpp/componentInstances/RNSVGForeignObjectComponentInstance.cpp

@@ -33,24 +33,52 @@ RNSVGForeignObjectComponentInstance::RNSVGForeignObjectComponentInstance(Context
 
 
 RNSVGForeignObjectComponentInstance::~RNSVGForeignObjectComponentInstance() {
-    NativeNodeApi::getInstance()->unregisterNodeEvent(mForeignStackNode.getArkUINodeHandle(), NODE_EVENT_ON_AREA_CHANGE);
+    NativeNodeApi::getInstance()->unregisterNodeEvent(mForeignStackNode.getArkUINodeHandle(),
+                                                      NODE_EVENT_ON_AREA_CHANGE);
 }
 
 void RNSVGForeignObjectComponentInstance::onFinalizeUpdates() {
     ComponentInstance::onFinalizeUpdates();
     if (m_props) {
-        float pointScaleFactor = getLayoutMetrics().pointScaleFactor;
-        mForeignStackNode.SetSnapPosition(pointScaleFactor * std::stof(DynamicUtils::DynamicToString(m_props->x)),
-                                          pointScaleFactor * std::stof(DynamicUtils::DynamicToString(m_props->y)));
-        mForeignStackNode.SetSnapWidth(pointScaleFactor * std::stof(DynamicUtils::DynamicToString(m_props->width)));
-        mForeignStackNode.SetSnapHeight(pointScaleFactor * std::stof(DynamicUtils::DynamicToString(m_props->height)));
+        mForeignStackNode.SetPointScaleFactor(getLayoutMetrics().pointScaleFactor);
+        mForeignStackNode.SetSnapPosition(propsConversionValue(m_props->x), propsConversionValue(m_props->y));
+        mForeignStackNode.SetSnapWidth(propsConversionValue(m_props->width));
+        mForeignStackNode.SetSnapHeight(propsConversionValue(m_props->height));
+
+        mForeignStackNode.SetClipPath(m_props->clipPath, m_props->clipRule);
+        mForeignStackNode.SetMask(m_props->mask);
+        mForeignStackNode.SetTransform(m_props->matrix);
+        auto childs = getChildren();
+        if (childs.size() > 0) {
+            for (ComponentInstance::Shared c : childs) {
+                if ((m_props->opacity > 0 && m_props->opacity != 1)) {
+                    setOpacity(c->getLocalRootArkUINode(), m_props->opacity);
+                }
+            }
+        }
         mForeignStackNode.SetGeneratedPixelMap(true);
     }
 }
 
+Dimension RNSVGForeignObjectComponentInstance::propsConversionValue(const folly::dynamic &d) {
+    if (d.isNull()) {
+        return Dimension(0, DimensionUnit::INVALID);
+    }
+    return StringUtils::StringToDimension(d.asString(), true);
+}
+
+void RNSVGForeignObjectComponentInstance::setOpacity(ArkUINode &node, float op) {
+    if (op != 1) {
+        node.setOpacity(m_props->opacity);
+    }
+}
+
 void RNSVGForeignObjectComponentInstance::onChildInserted(ComponentInstance::Shared const &childComponentInstance,
                                                           std::size_t index) {
     CppComponentInstance::onChildInserted(childComponentInstance, index);
+    float width = childComponentInstance->getLayoutMetrics().frame.size.width;
+    float height = childComponentInstance->getLayoutMetrics().frame.size.height;
+    mForeignStackNode.setNodeSize(width, height);
     node.insertChild(childComponentInstance->getLocalRootArkUINode(), index);
 }
 

package/harmony/svg/src/main/cpp/componentInstances/RNSVGForeignObjectComponentInstance.h

@@ -27,6 +27,8 @@
 #include "RNOH/arkui/ColumnNode.h"
 #include "RNOH/arkui/NativeNodeApi.h"
 #include "utils/DynamicUtils.h"
+#include "properties/Dimension.h"
+#include "utils/StringUtils.h"
 namespace rnoh {
 namespace svg {
 class RNSVGForeignObjectComponentInstance : public CppComponentInstance<facebook::react::RNSVGForeignObjectShadowNode> {
@@ -40,7 +42,10 @@ public:
     void onChildRemoved(ComponentInstance::Shared const &childComponentInstance) override;
 
     SvgForeignObjectNode &getLocalRootArkUINode() override;
-
+    
+    void setOpacity(ArkUINode &node, float op);
+    
+    Dimension propsConversionValue(const folly::dynamic& d);
 private:
     SvgForeignObjectNode mForeignStackNode;
     ColumnNode node;

package/harmony/svg/src/main/cpp/componentInstances/RNSVGSvgViewComponentInstance.cpp

@@ -47,12 +47,11 @@ void RNSVGSvgViewComponentInstance::onFinalizeUpdates() {
     getLocalRootArkUINode().markDirty();
 }
 
-void RNSVGSvgViewComponentInstance::onDrawForeignImage(OH_PixelmapNative *foreignPixelMap, float width, float height,
-                                                       float x, float y) {
-    if (foreignPixelMap) {
-        DLOG(INFO) << "[svgForeignNode] RNSVGSvgViewComponentInstance OH_PixelmapNative is not null, position:{ x:" << x
-                   << ",y:" << y << "},width:" << width << ";height:" << height;
-        m_svgArkUINode.SetForeignObject(foreignPixelMap, width, height, x, y);
+void RNSVGSvgViewComponentInstance::onDrawForeignImage(ForeignProps foreignProps) {
+    if (foreignProps.foreignPixelMap) {
+        DLOG(INFO) << "[svgForeignNode] RNSVGSvgViewComponentInstance OH_PixelmapNative is not null, position:{ x:" << foreignProps.x.Value()
+                   << ",y:" << foreignProps.y.Value() << "},width:" << foreignProps.width.Value() << ";height:" << foreignProps.height.Value();
+        m_svgArkUINode.SetForeignObject(foreignProps);
         m_svgArkUINode.markDirty();
     } else {
         DLOG(INFO) << "RNSVGSvgViewComponentInstance OH_PixelmapNative is null";

package/harmony/svg/src/main/cpp/componentInstances/RNSVGSvgViewComponentInstance.h

@@ -31,7 +31,7 @@ public:
     ~RNSVGSvgViewComponentInstance();
 
     void onFinalizeUpdates() override;
-    void onDrawForeignImage(OH_PixelmapNative *foreignPixelMap,float width,float height,float x,float y) override;
+    void onDrawForeignImage(ForeignProps foreignProps) override;
     // get SvgNode from childComponentInstance and set it to root_
     void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override;
 

package/harmony/svg/src/main/cpp/downloadUtils/HttpTaskProcessor.cpp

@@ -44,9 +44,30 @@ void ResponseCallback(void *usrCtx, Rcp_Response *response, uint32_t errCode) {
 }
 
 void HttpTaskProcessor::createParentPath(const fs::path &filePath) {
-    fs::path parentPath = filePath.parent_path();
-    if (!parentPath.empty() && !fs::exists(parentPath)) {
-        fs::create_directories(parentPath);
+    try {
+        fs::path parentPath = filePath.parent_path();
+        if (!parentPath.empty() && !fs::exists(parentPath)) {
+            // 检查路径的有效性
+            if (parentPath.is_relative()) {
+                LOG(ERROR) << "[SVGImage] Invalid parent path (relative path): " << parentPath;
+                return;
+            }
+            // 尝试创建目录，并捕获可能的异常
+            auto result = fs::create_directories(parentPath);
+            if (result) {
+                LOG(INFO) << "[SVGImage] Successfully created parent directories: " << parentPath;
+            } else {
+                LOG(ERROR) << "[SVGImage] Failed to create parent directories: " << parentPath;
+            }
+        }
+    } catch (const fs::filesystem_error& e) {
+        LOG(ERROR) << "[SVGImage] Filesystem error in createParentPath: " << e.what() 
+                   << " for path: " << filePath;
+    } catch (const std::exception& e) {
+        LOG(ERROR) << "[SVGImage] Standard exception in createParentPath: " << e.what() 
+                   << " for path: " << filePath;
+    } catch (...) {
+        LOG(ERROR) << "[SVGImage] Unknown exception in createParentPath for path: " << filePath;
     }
 }
 
@@ -54,14 +75,52 @@ size_t HttpTaskProcessor::saveImage(const char *buffer, uint32_t length) {
     size_t status = 0;
     if (filePath_ == "")
         return status;
-    createParentPath(filePath_);
-    fp_ = fopen(filePath_.c_str(), "w");
-    if (fp_) {
-        status = fwrite(buffer, sizeof(char), length, fp_);
-        fclose(fp_);
-    } else {
-        LOG(ERROR) << "[SVGImage] write to file failed: " << filePath_;
+    
+    // 验证输入参数
+    if (buffer == nullptr || length == 0) {
+        LOG(ERROR) << "[SVGImage] Invalid buffer or length in saveImage";
+        return status;
+    }
+    
+    try {
+        // 先创建父目录
+        createParentPath(filePath_);
+        
+        // 验证文件路径的合理性
+        fs::path filePath(filePath_);
+        if (filePath.has_filename()) {
+            LOG(INFO) << "[SVGImage] Attempting to save image to: " << filePath_;
+        } else {
+            LOG(ERROR) << "[SVGImage] Invalid file path (no filename): " << filePath_;
+            return status;
+        }
+        
+        // 打开文件进行写入
+        fp_ = fopen(filePath_.c_str(), "w");
+        if (fp_) {
+            status = fwrite(buffer, sizeof(char), length, fp_);
+            fclose(fp_);
+            
+            if (status == length) {
+                LOG(INFO) << "[SVGImage] Successfully saved image: " << filePath_ 
+                         << " (size: " << length << " bytes)";
+            } else {
+                LOG(ERROR) << "[SVGImage] Partial write error. Expected: " << length 
+                           << ", wrote: " << status;
+                status = 0; // 返回0表示失败
+            }
+        } else {
+            LOG(ERROR) << "[SVGImage] Failed to open file for writing: " << filePath_ 
+                       << " (errno: " << errno << ")";
+        }
+    } catch (const std::exception& e) {
+        LOG(ERROR) << "[SVGImage] Exception in saveImage: " << e.what();
+        status = 0;
+    } catch (...) {
+        LOG(ERROR) << "[SVGImage] Unknown exception in saveImage";
+        status = 0;
     }
+    
     return status;
 }
 

package/harmony/svg/src/main/cpp/properties/Dimension.h

@@ -141,6 +141,20 @@ public:
         return 0.0;
     };
 
+    double ParsePropsToPx(double relative, float pointScaleFactor){
+        if (unit_ == DimensionUnit::NONE) {
+            return value_*pointScaleFactor;
+        }
+        if (unit_ == DimensionUnit::PERCENT) {
+            return value_*relative - pointScaleFactor;
+        }
+        if (unit_ == DimensionUnit::VP) {
+            return value_*pointScaleFactor;
+        } else {
+            return value_;
+        }  
+    }
+    
     double GetNativeValue(DimensionUnit unit, double scale) const {
         if (unit_ == unit) {
             return value_;

package/harmony/svg/src/main/cpp/turboModules/RNSVGImageModule.cpp

@@ -20,6 +20,35 @@ RNSVGImageModule::RNSVGImageModule(const ArkTSTurboModule::Context ctx, const st
     // 获取缓存路径前缀
     auto cache = this->callSync("getCacheDir", {});
     m_fileCacheDir = cache.asString() + "/";
+    
+    // 确保缓存目录存在
+    try {
+        fs::path cachePath(m_fileCacheDir);
+        if (!fs::exists(cachePath)) {
+            if (auto result = fs::create_directories(cachePath)) {
+                LOG(INFO) << "[SVGImage] Created cache directory: " << m_fileCacheDir;
+            } else {
+                LOG(WARNING) << "[SVGImage] Failed to create cache directory: " << m_fileCacheDir;
+            }
+        } else if (!fs::is_directory(cachePath)) {
+            LOG(ERROR) << "[SVGImage] Cache path exists but is not a directory: " << m_fileCacheDir;
+            // 尝试创建备份目录
+            std::string backupDir = m_fileCacheDir + "_backup";
+            fs::create_directories(backupDir);
+            m_fileCacheDir = backupDir + "/";
+            LOG(INFO) << "[SVGImage] Using backup cache directory: " << m_fileCacheDir;
+        }
+    } catch (const std::exception& e) {
+        LOG(ERROR) << "[SVGImage] Error creating/validating cache directory: " << e.what();
+        // 使用临时目录作为后备方案
+        m_fileCacheDir = "/data/local/tmp/rnsvg_cache/";
+        try {
+            fs::create_directories(m_fileCacheDir);
+        } catch (...) {
+            LOG(ERROR) << "[SVGImage] Failed to create temp cache directory";
+        }
+    }
+    
     m_imageSourceResolver = std::make_shared<ImageSourceResolver>(m_fileCacheDir);
 
     fs::path directoryPath = m_fileCacheDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-ohos/react-native-svg",
-  "version": "15.12.1-rc.5",
+  "version": "15.12.1-rc.7",
   "description": "",
   "react-native": "src/index",
   "main": "lib/commonjs/index",
@@ -21,7 +21,6 @@
     "react-native-svg": "15.12.0"
   },
   "devDependencies": {
-    "@ohos/hvigor-ohos-plugin": "^6.20.0",
     "@react-native-community/cli": "15.0.1",
     "@tsconfig/react-native": "^3.0.0",
     "@types/jest": "^29.5.1",
@@ -29,7 +28,7 @@
     "@types/react": "^19.1.7",
     "@types/react-native": "^0.71.6",
     "react-native-builder-bob": "^0.20.4",
-    "typescript": "^5.2.2"
+    "typescript": "^5.8.3"
   },
   "harmony": {
     "alias": "react-native-svg",

package/tsconfig.json

@@ -3,7 +3,7 @@
     "@tsconfig/react-native/tsconfig.json",
   ],
   "compilerOptions": {
-    "noEmit": false,
+    "noEmit": false
   },
   "exclude": [
     "lib",