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

package/harmony/svg/src/main/cpp/properties/TextProperties.cpp

@@ -0,0 +1,91 @@
+/*
+ * 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 "TextProperties.h"
+
+namespace rnoh {
+namespace svg {
+
+TextPathMethod textPathMethodFromStr(const std::string &str) {
+    if (str == "stretch") {
+        return TextPathMethod::stretch;
+    } else {
+        return TextPathMethod::align;
+    }
+}
+
+TextPathSide textPathSideFromStr(const std::string &str) {
+    if (str == "right") {
+        return TextPathSide::right;
+    } else {
+        return TextPathSide::left;
+    }
+}
+
+TextPathMidLine textPathMidLineFromStr(const std::string &str) {
+    if (str == "sharp") {
+        return TextPathMidLine::sharp;
+    } else {
+        return TextPathMidLine::smooth;
+    }
+}
+
+TextPathSpacing textPathSpacingFromStr(const std::string &str) {
+    if (str == "auto") {
+        return TextPathSpacing::Auto;
+    } else {
+        return TextPathSpacing::Exact;
+    }
+}
+
+TextLengthAdjust textLengthAdjustFromStr(const std::string &str) {
+    if (str == "spacing") {
+        return TextLengthAdjust::spacing;
+    } else {
+        return TextLengthAdjust::spacingAndGlyphs;
+    }
+}
+
+AlignmentBaseline alignmentBaselineFromStr(const std::string &str) {
+    if (str == "baseline") {
+        return AlignmentBaseline::baseline;
+    } else if (str == "text-bottom") {
+        return AlignmentBaseline::textBottom;
+    } else if (str == "alphabetic") {
+        return AlignmentBaseline::alphabetic;
+    } else if (str == "ideographic") {
+        return AlignmentBaseline::ideographic;
+    } else if (str == "middle") {
+        return AlignmentBaseline::middle;
+    } else if (str == "central") {
+        return AlignmentBaseline::central;
+    } else if (str == "mathematical") {
+        return AlignmentBaseline::mathematical;
+    } else if (str == "text-top") {
+        return AlignmentBaseline::textTop;
+    } else if (str == "bottom") {
+        return AlignmentBaseline::bottom;
+    } else if (str == "center") {
+        return AlignmentBaseline::center;
+    } else if (str == "top") {
+        return AlignmentBaseline::top;
+    } else if (str == "text-before-edge") {
+        return AlignmentBaseline::textBeforeEdge;
+    } else if (str == "text-after-edge") {
+        return AlignmentBaseline::textAfterEdge;
+    } else if (str == "before-edge") {
+        return AlignmentBaseline::beforeEdge;
+    } else if (str == "after-edge") {
+        return AlignmentBaseline::afterEdge;
+    } else if (str == "hanging") {
+        return AlignmentBaseline::hanging;
+    } else {
+        return AlignmentBaseline::baseline;
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -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.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace rnoh {
+namespace svg {
+
+enum class AlignmentBaseline {
+    baseline,
+    textBottom,
+    alphabetic,
+    ideographic,
+    middle,
+    central,
+    mathematical,
+    textTop,
+    bottom,
+    center,
+    top,
+    /*
+        SVG implementations may support the following aliases in order to support legacy content:
+
+        text-before-edge = text-top
+        text-after-edge = text-bottom
+    */
+    textBeforeEdge,
+    textAfterEdge,
+    // SVG 1.1
+    beforeEdge,
+    afterEdge,
+    hanging,
+};
+
+enum class TextLengthAdjust { spacing, spacingAndGlyphs };
+
+enum class TextPathMethod { align, stretch };
+enum class TextPathMidLine { sharp, smooth };
+enum class TextPathSide { left, right };
+enum class TextPathSpacing { Auto, Exact };
+
+AlignmentBaseline alignmentBaselineFromStr(const std::string &str);
+TextLengthAdjust textLengthAdjustFromStr(const std::string &str);
+
+TextPathMethod textPathMethodFromStr(const std::string &str);
+TextPathSide textPathSideFromStr(const std::string &str);
+TextPathMidLine textPathMidLineFromStr(const std::string &str);
+TextPathSpacing textPathSpacingFromStr(const std::string &str);
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,108 @@
+/*
+ * 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.
+ */
+
+// based on https://svgwg.org/svg2-draft/coords.html#ComputingAViewportsTransform
+#pragma once
+
+#include "Rect.h"
+#include "drawing/Matrix.h"
+#include <string>
+#include <glog/logging.h>
+
+namespace rnoh {
+namespace svg {
+
+class ViewBox {
+private:
+    static const int MOS_MEET = 0;
+    static const int MOS_SLICE = 1;
+    static const int MOS_NONE = 2;
+
+public:
+    static drawing::Matrix getTransform(const Rect &vbRect, const Rect &eRect, const std::string &align, const int &meetOrSlice) {
+        // Let vb-x, vb-y, vb-width, vb-height be the min-x, min-y, width and height values of the
+        // viewBox attribute respectively.
+        double vbX = vbRect.Left();
+        double vbY = vbRect.Top();
+        double vbWidth = vbRect.Width();
+        double vbHeight = vbRect.Height();
+
+        // Let e-x, e-y, e-width, e-height be the position and size of the element respectively.
+        double eX = eRect.Left();
+        double eY = eRect.Top();
+        double eWidth = eRect.Width();
+        double eHeight = eRect.Height();
+
+        // Initialize scale-x to e-width/vb-width.
+        double scaleX = (vbWidth != 0) ? eWidth / vbWidth : 0.0;
+
+        // Initialize scale-y to e-height/vb-height.
+        double scaleY = (vbHeight != 0) ? eHeight / vbHeight : 0.0;
+
+        // Initialize translate-x to e-x - (vb-x * scale-x).
+        // Initialize translate-y to e-y - (vb-y * scale-y).
+        double translateX = eX - (vbX * scaleX);
+        double translateY = eY - (vbY * scaleY);
+
+        // If meetOrSlice is 'none'
+        if (meetOrSlice == MOS_NONE) {
+            // Let scale be set the smaller value of scale-x and scale-y.
+            // Assign scale-x and scale-y to scale.
+            double scale = scaleX = scaleY =  std::min(scaleX, scaleY);
+
+            // If scale is greater than 1
+            if (scale > 1) {
+                // Minus translateX by (eWidth / scale - vbWidth) / 2
+                // Minus translateY by (eHeight / scale - vbHeight) / 2
+                translateX -= (eWidth / scale - vbWidth) / 2;
+                translateY -= (eHeight / scale - vbHeight) / 2;
+            } else {
+                translateX -= (eWidth - vbWidth * scale) / 2;
+                translateY -= (eHeight - vbHeight * scale) / 2;
+            }
+        } else {
+            // If align is not 'none' and meetOrSlice is 'meet', set the larger of scale-x and scale-y to
+            // the smaller.
+            // Otherwise, if align is not 'none' and meetOrSlice is 'slice', set the smaller of scale-x
+            // and scale-y to the larger.
+            if (align != "none" && meetOrSlice == MOS_MEET) {
+                scaleX = scaleY = std::min(scaleX, scaleY);
+            } else if (align != "none" && meetOrSlice == MOS_SLICE) {
+                scaleX = scaleY = std::max(scaleX, scaleY);
+            }
+
+            // If align contains 'xMid', add (e-width - vb-width * scale-x) / 2 to translate-x.
+            if (align.find("xMid") != std::string::npos) {
+                translateX += (eWidth - vbWidth * scaleX) / 2.0;
+            }
+
+            // If align contains 'xMax', add (e-width - vb-width * scale-x) to translate-x.
+            if (align.find("xMax") != std::string::npos) {
+                translateX += (eWidth - vbWidth * scaleX);
+            }
+
+            // If align contains 'yMid', add (e-height - vb-height * scale-y) / 2 to translate-y.
+            if (align.find("YMid") != std::string::npos) {
+                translateY += (eHeight - vbHeight * scaleY) / 2.0;
+            }
+
+            // If align contains 'yMax', add (e-height - vb-height * scale-y) to translate-y.
+            if (align.find("YMax") != std::string::npos) {
+                translateY += (eHeight - vbHeight * scaleY);
+            }
+        }
+
+        // The transform applied to content contained by the element is given by
+        // translate(translate-x, translate-y) scale(scale-x, scale-y).
+        drawing::Matrix transform;
+        transform.PostTranslate(static_cast<float>(translateX), static_cast<float>(translateY));
+        transform.PreScale(static_cast<float>(scaleX), static_cast<float>(scaleY), 0, 0);
+        return transform;
+    }
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/svgImage/RNSVGImageComponentDescriptor.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <react/renderer/imagemanager/ImageManager.h>
+#include <react/utils/ContextContainer.h>
+
+#include "RNSVGImageShadowNode.h"
+
+namespace facebook {
+namespace react {
+
+/*
+ * Descriptor for <RNSVGImage> component.
+ */
+class RNSVGImageComponentDescriptor final : public ConcreteComponentDescriptor<RNSVGImageShadowNode> {
+public:
+    RNSVGImageComponentDescriptor(ComponentDescriptorParameters const &parameters)
+        : ConcreteComponentDescriptor(parameters), imageManager_(std::make_shared<ImageManager>(contextContainer_)){};
+    
+    void adopt(ShadowNode &shadowNode) const override {
+        ConcreteComponentDescriptor::adopt(shadowNode);
+
+        auto &imageShadowNode = static_cast<RNSVGImageShadowNode&>(shadowNode);
+        // `RNSVGImageShadowNode` uses `ImageManager` to initiate image loading and
+        // communicate the loading state and results to mounting layer.
+        imageShadowNode.setImageManager(imageManager_);
+    }
+
+private:
+    const SharedImageManager imageManager_;
+};
+
+} // namespace react
+} // namespace facebook

package/harmony/svg/src/main/cpp/svgImage/RNSVGImageShadowNode.cpp

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <cstdlib>
+#include <limits>
+
+#include <react/renderer/core/LayoutContext.h>
+
+#include "RNSVGImageShadowNode.h"
+
+namespace facebook {
+namespace react {
+
+const char RNSVGImageComponentName[] = "RNSVGImage";
+
+void RNSVGImageShadowNode::setImageManager(const SharedImageManager &imageManager) {
+    ensureUnsealed();
+    imageManager_ = imageManager;
+}
+
+ImageSource RNSVGImageShadowNode::getImageSource() const {
+    auto source = getConcreteProps().src;
+
+    auto layoutMetrics = getLayoutMetrics();
+    auto size = layoutMetrics.getContentFrame().size;
+    auto scale = layoutMetrics.pointScaleFactor;
+    source.size = size;
+    source.scale = scale;
+    return source;
+}
+
+void RNSVGImageShadowNode::updateStateIfNeeded() {
+    ensureUnsealed();
+
+    auto imageSource = getImageSource();
+    auto const &currentState = getStateData();
+    bool hasSameImageSource = currentState.getImageSource() == imageSource;
+
+    if (hasSameImageSource) {
+        return;
+    }
+
+    auto state = RNSVGImageState{
+        imageSource,
+        imageManager_->requestImage(imageSource, getSurfaceId()),
+    };
+    setStateData(std::move(state));
+}
+
+#pragma mark - LayoutableShadowNode
+
+void RNSVGImageShadowNode::layout(LayoutContext layoutContext) {
+    updateStateIfNeeded();
+    ConcreteViewShadowNode::layout(layoutContext);
+}
+
+} // namespace react
+} // namespace facebook

package/harmony/svg/src/main/cpp/svgImage/RNSVGImageShadowNode.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/react_native_svg/EventEmitters.h>
+#include <react/renderer/components/react_native_svg/Props.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/imagemanager/ImageManager.h>
+#include <react/renderer/imagemanager/primitives.h>
+
+#include "RNSVGImageState.h"
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT extern const char RNSVGImageComponentName[];
+
+/*
+ * `ShadowNode` for <RNSVGImage> component.
+ */
+class JSI_EXPORT RNSVGImageShadowNode final
+    : public ConcreteViewShadowNode<RNSVGImageComponentName, RNSVGImageProps, ViewEventEmitter, RNSVGImageState> {
+public:
+    using ConcreteViewShadowNode::ConcreteViewShadowNode;
+
+    static ShadowNodeTraits BaseTraits() {
+        auto traits = ConcreteViewShadowNode::BaseTraits();
+        traits.set(ShadowNodeTraits::Trait::LeafYogaNode);
+        return traits;
+    }
+
+    /*
+     * Associates a shared `ImageManager` with the node.
+     */
+    void setImageManager(const SharedImageManager &imageManager);
+
+    static RNSVGImageState initialStateData(Props::Shared const &props,
+                                            ShadowNodeFamily::Shared const &family,
+                                            ComponentDescriptor const &componentDescriptor) {
+        auto imageSource = ImageSource{ImageSource::Type::Invalid};
+        return {imageSource, {imageSource, nullptr, {}}};
+    }
+
+#pragma mark - LayoutableShadowNode
+
+    void layout(LayoutContext layoutContext) override;
+
+private:
+    ImageSource getImageSource() const;
+
+    SharedImageManager imageManager_;
+
+    void updateStateIfNeeded();
+};
+
+} // namespace react
+} // namespace facebook

package/harmony/svg/src/main/cpp/svgImage/RNSVGImageState.cpp

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "RNSVGImageState.h"
+
+namespace facebook {
+namespace react {
+
+ImageSource RNSVGImageState::getImageSource() const { return imageSource_; }
+
+ImageRequest const &RNSVGImageState::getImageRequest() const { return *imageRequest_; }
+} // namespace react
+} // namespace facebook

package/harmony/svg/src/main/cpp/svgImage/RNSVGImageState.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/imagemanager/ImageRequest.h>
+#include <react/renderer/imagemanager/primitives.h>
+
+#ifdef ANDROID
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook {
+namespace react {
+
+/*
+ * State for <Image> component.
+ */
+class JSI_EXPORT RNSVGImageState final {
+public:
+    RNSVGImageState(ImageSource const &imageSource, ImageRequest imageRequest)
+        : imageSource_(imageSource), imageRequest_(std::make_shared<ImageRequest>(std::move(imageRequest))){};
+
+    /*
+     * Returns stored ImageSource object.
+     */
+    ImageSource getImageSource() const;
+
+    /*
+     * Exposes for reading stored `ImageRequest` object.
+     * `ImageRequest` object cannot be copied or moved from `ImageLocalData`.
+     */
+    ImageRequest const &getImageRequest() const;
+
+#ifdef ANDROID
+    RNSVGImageState(RNSVGImageState const &previousState, folly::dynamic data){};
+
+    /*
+     * Empty implementation for Android because it doesn't use this class.
+     */
+    folly::dynamic getDynamic() const { return {}; };
+
+    MapBuffer getMapBuffer() const { return MapBufferBuilder::EMPTY(); };
+#endif
+
+private:
+    ImageSource imageSource_;
+    std::shared_ptr<ImageRequest> imageRequest_;
+};
+
+} // namespace react
+} // namespace facebook

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

@@ -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.
+ */
+
+#include "RNSVGImageModule.h"
+#include "utils/StringUtils.h"
+
+using namespace facebook;
+
+namespace rnoh {
+namespace svg {
+RNSVGImageModule::RNSVGImageModule(const ArkTSTurboModule::Context ctx, const std::string name)
+    : ArkTSTurboModule(ctx, name) {
+    methodMap_ = {
+        ARK_ASYNC_METHOD_METADATA(getCacheDir, 0),
+    };
+
+    // 获取缓存路径前缀
+    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;
+    // 将已有的缓存文件名放入remoteImageSourceMap
+    if (fs::exists(directoryPath) && fs::is_directory(directoryPath)) {
+        for (const auto &entry : fs::directory_iterator(directoryPath)) {
+            if (fs::is_regular_file(entry.path())) {
+                m_imageSourceResolver->remoteImageSourceMap_.put(entry.path().filename(), true);
+            }
+        }
+    }
+}
+
+/**
+ *
+ * @param uri 图片uri
+ * @param headers 请求头
+ */
+void RNSVGImageModule::downloadImage(const std::string &uri, const std::map<std::string, std::string> &headers) {
+    HttpTaskProcessor *processor = new HttpTaskProcessor();
+    processor->instance_ = m_imageSourceResolver;
+    processor->filePath_ = m_fileCacheDir + StringUtils::generateHash(uri);
+
+    if (headers.empty()) {
+        processor->launchHttpRequest(uri.c_str());
+    } else {
+        processor->launchHttpRequestWithHeaders(uri.c_str(), headers);
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,32 @@
+/*
+ * 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 <ReactCommon/TurboModule.h>
+#include "RNOH/ArkTSTurboModule.h"
+#include "downloadUtils/ImageSourceResolver.h"
+#include "downloadUtils/HttpTaskProcessor.h"
+
+namespace rnoh {
+namespace svg {
+
+class JSI_EXPORT RNSVGImageModule : public ArkTSTurboModule {
+public:
+    RNSVGImageModule(const ArkTSTurboModule::Context ctx, const std::string name);
+
+    ~RNSVGImageModule() { HttpTaskProcessor::destroyAllTask(); }
+
+    void downloadImage(const std::string &uri, const std::map<std::string, std::string> &headers);
+
+    std::shared_ptr<ImageSourceResolver> getImageSourceResolver() { return m_imageSourceResolver; }
+
+private:
+    std::string m_fileCacheDir;
+    std::shared_ptr<ImageSourceResolver> m_imageSourceResolver = nullptr;
+};
+} // namespace svg
+} // namespace rnoh