@react-native-ohos/react-native-svg 15.12.1-rc.11 → 15.12.1-rc.13

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.11';
+export const HAR_VERSION = '15.12.1-rc.12';
 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.11',
+  version: '15.12.1-rc.13',
   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/SvgNode.h

@@ -78,11 +78,12 @@ public:
         }
     }
 
-    template <typename ConcreteProps> void UpdateHrefRenderProps(const std::shared_ptr<ConcreteProps> &props, bool inherit = false) {
+    template <typename ConcreteProps>
+    void UpdateHrefRenderProps(const std::shared_ptr<ConcreteProps> &props, bool inherit = false) {
         if (!props) {
             return;
         }
-        
+
         if (inherit) {
             attributes_.hasInheritedFilter = true;
         }
@@ -91,7 +92,7 @@ public:
         if constexpr (requires { props->propList; }) {
             propSet.insert(props->propList.begin(), props->propList.end());
         }
-        
+
         // Always set name and display if available
         if constexpr (requires { props->name; }) {
             attributes_.id = props->name;
@@ -109,9 +110,9 @@ public:
                 attributes_.maskId = props->mask;
             }
             if constexpr (requires { props->filter; } &&
-                        std::is_same_v<std::decay_t<decltype(props->filter)>, std::string>) {
-                    attributes_.filterId = props->filter;
-                    attributes_.hasInheritedFilter = inherit;
+                          std::is_same_v<std::decay_t<decltype(props->filter)>, std::string>) {
+                attributes_.filterId = props->filter;
+                attributes_.hasInheritedFilter = inherit;
             }
             if constexpr (requires { props->opacity; }) {
                 attributes_.selfOpacity = props->opacity;
@@ -134,7 +135,8 @@ public:
         }
     }
 
-    template <typename ConcreteProps> void UpdateCommonProps(const std::shared_ptr<ConcreteProps> &props, bool inherit = false) {
+    template <typename ConcreteProps>
+    void UpdateCommonProps(const std::shared_ptr<ConcreteProps> &props, bool inherit = false) {
         UpdateHrefRenderProps(props, inherit);
         std::unordered_set<std::string> set;
         if constexpr (requires { props->propList; }) {
@@ -143,79 +145,204 @@ public:
             }
         }
 
-        // Handle fill properties - support both generic and text-specific structures
+        // Handle fill properties - support both object and string forms
         if constexpr (requires { props->fill; }) {
-            if (!props->fill.isNull() && props->fill.count("type") > 0 && props->fill.count("payload") > 0) {
-                int fillType = props->fill["type"].asInt();
-                if (fillType == INHERIT_TYPE) {
-                    Color color = Color(static_cast<uint32_t>(props->fill["payload"].asInt()));
+            bool hasFillProp = set.count("fill");
+            if (props->fill.isString()) {
+                auto fillValue = props->fill.asString();
+                if (fillValue == "none") {
+                    attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                } else if (fillValue == "currentColor") {
+                    Color color = Color::TRANSPARENT;
                     color.SetUseCurrentColor(true);
                     attributes_.fillState.SetColor(color, true);
                 } else {
-                    uint32_t colorValue = static_cast<uint32_t>(props->fill["payload"].asInt());
-                    if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
-                        attributes_.fillState.SetColor(Color(colorValue), set.count("fill"));
-                    } else {
-                        attributes_.fillState.SetColor(Color::TRANSPARENT, set.count("fill"));
-                    }
+                    attributes_.fillState.SetColor(SvgAttributesParser::GetColor(fillValue), hasFillProp);
                 }
-            } else if (!props->fill.isNull() && props->fill.count("payload") > 0) {
-                uint32_t colorValue = static_cast<uint32_t>(props->fill["payload"].asInt());
+            } else if (props->fill.isInt() || props->fill.isDouble()) {
+                uint32_t colorValue = props->fill.isInt() ? static_cast<uint32_t>(props->fill.asInt())
+                                                          : static_cast<uint32_t>(props->fill.asDouble());
                 if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
-                    attributes_.fillState.SetColor(Color(colorValue), set.count("fill"));
+                    attributes_.fillState.SetColor(Color(colorValue), hasFillProp);
                 } else {
-                    attributes_.fillState.SetColor(Color::TRANSPARENT, set.count("fill"));
+                    attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                }
+            } else if (!props->fill.isNull() && props->fill.isObject()) {
+                if (props->fill.count("type") > 0) {
+                    int fillType = props->fill["type"].asInt();
+                    if (fillType == INHERIT_TYPE) {
+                        Color color = Color::TRANSPARENT;
+                        if (props->fill.count("payload") > 0 &&
+                            (props->fill["payload"].isInt() || props->fill["payload"].isDouble())) {
+                            uint32_t colorValue = props->fill["payload"].isInt()
+                                                      ? static_cast<uint32_t>(props->fill["payload"].asInt())
+                                                      : static_cast<uint32_t>(props->fill["payload"].asDouble());
+                            color = Color(colorValue);
+                        } else if (props->color) {
+                            color = Color(*props->color);
+                        }
+                        color.SetUseCurrentColor(true);
+                        attributes_.fillState.SetColor(color, true);
+                    } else if (props->fill.count("payload") > 0) {
+                        const auto &payload = props->fill["payload"];
+                        if (payload.isString()) {
+                            auto payloadValue = payload.asString();
+                            if (payloadValue == "none") {
+                                attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                            } else if (payloadValue == "currentColor") {
+                                Color color = Color::TRANSPARENT;
+                                color.SetUseCurrentColor(true);
+                                attributes_.fillState.SetColor(color, true);
+                            } else {
+                                attributes_.fillState.SetColor(SvgAttributesParser::GetColor(payloadValue),
+                                                               hasFillProp);
+                            }
+                        } else if (payload.isInt() || payload.isDouble()) {
+                            uint32_t colorValue = payload.isInt() ? static_cast<uint32_t>(payload.asInt())
+                                                                  : static_cast<uint32_t>(payload.asDouble());
+                            if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                                attributes_.fillState.SetColor(Color(colorValue), hasFillProp);
+                            } else {
+                                attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                            }
+                        } else {
+                            attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                        }
+                    } else {
+                        attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                    }
+                } else if (props->fill.count("payload") > 0) {
+                    const auto &payload = props->fill["payload"];
+                    if (payload.isString()) {
+                        auto payloadValue = payload.asString();
+                        if (payloadValue == "none") {
+                            attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                        } else if (payloadValue == "currentColor") {
+                            Color color = Color::TRANSPARENT;
+                            color.SetUseCurrentColor(true);
+                            attributes_.fillState.SetColor(color, true);
+                        } else {
+                            attributes_.fillState.SetColor(SvgAttributesParser::GetColor(payloadValue), hasFillProp);
+                        }
+                    } else if (payload.isInt() || payload.isDouble()) {
+                        uint32_t colorValue = payload.isInt() ? static_cast<uint32_t>(payload.asInt())
+                                                              : static_cast<uint32_t>(payload.asDouble());
+                        if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                            attributes_.fillState.SetColor(Color(colorValue), hasFillProp);
+                        } else {
+                            attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                        }
+                    } else {
+                        attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                    }
+                } else {
+                    attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
+                }
+                if (props->fill.count("brushRef") > 0) {
+                    attributes_.fillState.SetHref(props->fill["brushRef"].asString());
                 }
             } else {
-                attributes_.fillState.SetColor(Color::TRANSPARENT, set.count("fill"));
-            }
-            if (!props->fill.isNull() && props->fill.count("brushRef") > 0) {
-                attributes_.fillState.SetHref(props->fill["brushRef"].asString());
+                attributes_.fillState.SetColor(Color::TRANSPARENT, hasFillProp);
             }
         }
 
-        // Handle stroke properties - support both generic and text-specific structures
+        // Handle stroke properties - support both object and string forms
         if constexpr (requires { props->stroke; }) {
-            if (!props->stroke.isNull() && props->stroke.count("type") > 0) {
-                int strokeType = props->stroke["type"].asInt();
-                if (strokeType == INHERIT_TYPE) {
-                    if (props->stroke.count("payload") > 0) {
-                        Color color = Color(static_cast<uint32_t>(props->stroke["payload"].asInt()));
+            bool hasStrokeProp = set.count("stroke");
+            if (props->stroke.isString()) {
+                auto strokeValue = props->stroke.asString();
+                if (strokeValue == "none") {
+                    attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
+                } else if (strokeValue == "currentColor") {
+                    Color color = Color::TRANSPARENT;
+                    color.SetUseCurrentColor(true);
+                    attributes_.strokeState.SetColor(color, true);
+                } else {
+                    attributes_.strokeState.SetColor(SvgAttributesParser::GetColor(strokeValue), hasStrokeProp);
+                }
+            } else if (props->stroke.isInt() || props->stroke.isDouble()) {
+                uint32_t colorValue = props->stroke.isInt() ? static_cast<uint32_t>(props->stroke.asInt())
+                                                            : static_cast<uint32_t>(props->stroke.asDouble());
+                if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                    attributes_.strokeState.SetColor(Color(colorValue), hasStrokeProp);
+                } else {
+                    attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
+                }
+            } else if (!props->stroke.isNull() && props->stroke.isObject()) {
+                if (props->stroke.count("type") > 0) {
+                    int strokeType = props->stroke["type"].asInt();
+                    if (strokeType == INHERIT_TYPE) {
+                        Color color = Color::TRANSPARENT;
+                        if (props->stroke.count("payload") > 0 &&
+                            (props->stroke["payload"].isInt() || props->stroke["payload"].isDouble())) {
+                            uint32_t colorValue = props->stroke["payload"].isInt()
+                                                      ? static_cast<uint32_t>(props->stroke["payload"].asInt())
+                                                      : static_cast<uint32_t>(props->stroke["payload"].asDouble());
+                            color = Color(colorValue);
+                        } else if (props->color) {
+                            color = Color(*props->color);
+                        }
                         color.SetUseCurrentColor(true);
                         attributes_.strokeState.SetColor(color, true);
-                    } else {
-                        if (props->color) {
-                            Color color = Color(*props->color);
-                            color.SetUseCurrentColor(true);
-                            attributes_.strokeState.SetColor(color, true);
+                    } else if (props->stroke.count("payload") > 0) {
+                        const auto &payload = props->stroke["payload"];
+                        if (payload.isString()) {
+                            auto payloadValue = payload.asString();
+                            if (payloadValue == "none") {
+                                attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
+                            } else if (payloadValue == "currentColor") {
+                                Color color = Color::TRANSPARENT;
+                                color.SetUseCurrentColor(true);
+                                attributes_.strokeState.SetColor(color, true);
+                            } else {
+                                attributes_.strokeState.SetColor(SvgAttributesParser::GetColor(payloadValue),
+                                                                 hasStrokeProp);
+                            }
+                        } else if (payload.isInt() || payload.isDouble()) {
+                            uint32_t colorValue = payload.isInt() ? static_cast<uint32_t>(payload.asInt())
+                                                                  : static_cast<uint32_t>(payload.asDouble());
+                            if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
+                                attributes_.strokeState.SetColor(Color(colorValue), hasStrokeProp);
+                            } else {
+                                attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
+                            }
                         } else {
+                            attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
+                        }
+                    }
+                } else if (props->stroke.count("payload") > 0) {
+                    const auto &payload = props->stroke["payload"];
+                    if (payload.isString()) {
+                        auto payloadValue = payload.asString();
+                        if (payloadValue == "none") {
+                            attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
+                        } else if (payloadValue == "currentColor") {
                             Color color = Color::TRANSPARENT;
                             color.SetUseCurrentColor(true);
                             attributes_.strokeState.SetColor(color, true);
+                        } else {
+                            attributes_.strokeState.SetColor(SvgAttributesParser::GetColor(payloadValue),
+                                                             hasStrokeProp);
                         }
-                    }
-                } else {
-                    if (props->stroke.count("payload") > 0) {
-                        uint32_t colorValue = static_cast<uint32_t>(props->stroke["payload"].asInt());
+                    } else if (payload.isInt() || payload.isDouble()) {
+                        uint32_t colorValue = payload.isInt() ? static_cast<uint32_t>(payload.asInt())
+                                                              : static_cast<uint32_t>(payload.asDouble());
                         if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
-                            attributes_.strokeState.SetColor(Color(colorValue), set.count("stroke"));
+                            attributes_.strokeState.SetColor(Color(colorValue), hasStrokeProp);
                         } else {
-                            attributes_.strokeState.SetColor(Color::TRANSPARENT, set.count("stroke"));
+                            attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
                         }
+                    } else {
+                        attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
                     }
-                }
-            } else if (!props->stroke.isNull() && props->stroke.count("payload") > 0) {
-                uint32_t colorValue = static_cast<uint32_t>(props->stroke["payload"].asInt());
-                if (facebook::react::isColorMeaningful(facebook::react::SharedColor(colorValue))) {
-                    attributes_.strokeState.SetColor(Color(colorValue), set.count("stroke"));
                 } else {
-                    attributes_.strokeState.SetColor(Color::TRANSPARENT, set.count("stroke"));
+                    attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
+                }
+                if (props->stroke.count("brushRef") > 0) {
+                    attributes_.strokeState.SetHref(props->stroke["brushRef"].asString());
                 }
             } else {
-                attributes_.strokeState.SetColor(Color::TRANSPARENT, set.count("stroke"));
-            }
-            if (!props->stroke.isNull() && props->stroke.count("brushRef") > 0) {
-                attributes_.strokeState.SetHref(props->stroke["brushRef"].asString());
+                attributes_.strokeState.SetColor(Color::TRANSPARENT, hasStrokeProp);
             }
         }
 
@@ -228,22 +355,28 @@ public:
         if constexpr (requires { props->strokeWidth; }) {
             bool hasStrokeWidthInPropList = set.count("strokeWidth") > 0;
             if (hasStrokeWidthInPropList) {
-                attributes_.strokeState.SetLineWidth(StringUtils::StringToDouble(DynamicUtils::DynamicToString(props->strokeWidth)) * scale_, true);
+                attributes_.strokeState.SetLineWidth(
+                    StringUtils::StringToDouble(DynamicUtils::DynamicToString(props->strokeWidth)) * scale_, true);
             }
         }
         if constexpr (requires { props->strokeDasharray; }) {
             attributes_.strokeState.SetStrokeDashArray(
-                StringUtils::stringVectorToDoubleVector(DynamicUtils::DynamicToStringVector(props->strokeDasharray), scale_), set.count("strokeDasharray"));
+                StringUtils::stringVectorToDoubleVector(DynamicUtils::DynamicToStringVector(props->strokeDasharray),
+                                                        scale_),
+                set.count("strokeDasharray"));
         }
         if constexpr (requires { props->strokeDashoffset; }) {
-            attributes_.strokeState.SetStrokeDashOffset(props->strokeDashoffset * scale_, set.count("strokeDashoffset"));
+            attributes_.strokeState.SetStrokeDashOffset(props->strokeDashoffset * scale_,
+                                                        set.count("strokeDashoffset"));
         }
         if constexpr (requires { props->strokeLinecap; }) {
-            attributes_.strokeState.SetLineCap(SvgAttributesParser::GetLineCapStyle(std::to_string(props->strokeLinecap)), set.count("strokeLinecap"));
+            attributes_.strokeState.SetLineCap(
+                SvgAttributesParser::GetLineCapStyle(std::to_string(props->strokeLinecap)), set.count("strokeLinecap"));
         }
         if constexpr (requires { props->strokeLinejoin; }) {
             attributes_.strokeState.SetLineJoin(
-                SvgAttributesParser::GetLineJoinStyle(std::to_string(props->strokeLinejoin)), set.count("strokeLinejoin"));
+                SvgAttributesParser::GetLineJoinStyle(std::to_string(props->strokeLinejoin)),
+                set.count("strokeLinejoin"));
         }
         if constexpr (requires { props->vectorEffect; }) {
             attributes_.strokeState.SetVectorEffect(props->vectorEffect);
@@ -272,12 +405,12 @@ public:
         attributes_.Inherit(parent);
         // svg color -> current color
         if (attributes_.strokeState.GetColor().IsUseCurrentColor()) {
-            if(context_) {
+            if (context_) {
                 attributes_.strokeState.SetColor(context_->GetSvgColor(), true);
             }
         }
         if (attributes_.fillState.GetColor().IsUseCurrentColor()) {
-            if(context_) {
+            if (context_) {
                 attributes_.fillState.SetColor(context_->GetSvgColor(), true);
             }
         }
@@ -295,10 +428,8 @@ public:
     double getCanvasHeight();
     double getCanvasDiagonal();
 
-    void SetForeignObject(ForeignProps foreignProps) {
-        _foreignPropsArray.emplace_back(foreignProps);
-    }
-    
+    void SetForeignObject(ForeignProps foreignProps) { _foreignPropsArray.emplace_back(foreignProps); }
+
 
 protected:
     // override as need by derived class
@@ -321,10 +452,10 @@ protected:
     std::optional<Gradient> GetGradient(const std::string &href);
 
     std::shared_ptr<PatternAttr> GetPatternAttr(const std::string &href);
-    void DrawForeignPixelMap(OH_Drawing_Canvas *canvas,ForeignProps _foreignProps);
+    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;
@@ -351,7 +482,7 @@ protected:
     bool hrefFill_ = true;      // get fill attributes from reference
     bool hrefRender_ = true;    // get render attr (mask, filter, transform, opacity,
                                 // clip path) from reference
-    bool passStyle_ = false;     // pass style attributes to child node, TAGS
+    bool passStyle_ = false;    // pass style attributes to child node, TAGS
                                 // circle/path/line/... = false
     bool inheritStyle_ = true;  // inherit style attributes from parent node, TAGS
                                 // mask/defs/pattern/filter = false

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

@@ -122,10 +122,11 @@ void ImageSourceResolver::imageDownloadFail(std::string uri) {
         auto &listeners = it->second;
         for (auto listener : listeners) {
             auto weaklistener = listener.lock();
-            if (weaklistener) {
-                weaklistener->onImageSourceCacheDownloadFileFail();
-                removeListenerForURI(uri, weaklistener);
+            if (!weaklistener) {
+               continue;
             }
+			weaklistener->onImageSourceCacheDownloadFileFail();
+            removeListenerForURI(uri, weaklistener);
         }
     }
 }

package/harmony/svg/src/main/ets/SvgPackage.ts

@@ -9,24 +9,6 @@ import type { TurboModule, TurboModuleContext } from '@rnoh/react-native-openhar
 import { RNSVGSvgViewModule } from './RNSVGSvgViewModule';
 import { RNSVGRenderableModule } from './RNSVGRenderableModule';
 import { RNSVGImageModule } from './RNSVGImageModule';
-import { hilog } from '@kit.PerformanceAnalysisKit';
-
-class MyLog {
-  static e(logTag: string, content: string) {
-    const maxSize = 1024;
-    if (content.length <= maxSize) {
-      // 长度小于等于限制直接打印
-      hilog.error(0xFF00, logTag, '%{public}s', content);
-    } else {
-      while (content.length > maxSize) {
-        // 循环分段打印
-        let logContent = content.substring(0, maxSize);
-        content = content.replace(logContent, '');
-        hilog.error(0xFF00, logTag, '%{public}s', logContent); // 打印剩余日志
-      }
-    }
-  }
-}
 
 class SvgTurboModulesFactory extends TurboModulesFactory {
 
@@ -52,7 +34,6 @@ class SvgTurboModulesFactory extends TurboModulesFactory {
 
 export class SvgPackage extends RNPackage {
   createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
-    MyLog.e('[kuang] SvgPackage createTurboModulesFactory = ', JSON.stringify(ctx));
     return new SvgTurboModulesFactory(ctx);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-ohos/react-native-svg",
-  "version": "15.12.1-rc.11",
+  "version": "15.12.1-rc.13",
   "description": "",
   "react-native": "src/index",
   "main": "lib/commonjs/index",