@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/componentInstances/RNSVGSymbolComponentInstance.h

@@ -0,0 +1,27 @@
+/*
+ * 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 "RNSVGBaseComponentInstance.h"
+#include "SvgSymbol.h"
+
+namespace rnoh {
+namespace svg {
+
+class RNSVGSymbolComponentInstance : public RNSVGBaseComponentInstance<facebook::react::RNSVGSymbolShadowNode> {
+public:
+    explicit RNSVGSymbolComponentInstance(Context context);
+
+protected:
+    void UpdateElementProps() override;
+
+private:
+    std::shared_ptr<SvgSymbol> m_svgSymbol = std::make_shared<SvgSymbol>();
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,27 @@
+/*
+ * 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 "RNSVGTSpanComponentInstance.h"
+#include "SvgTSpan.h"
+#include <react/renderer/components/react_native_svg/Props.h>
+
+namespace rnoh {
+namespace svg {
+
+RNSVGTSpanComponentInstance::RNSVGTSpanComponentInstance(Context context)
+    : RNSVGBaseComponentInstance(std::move(context)) {
+    SetSvgNode(m_svgTSpan);
+}
+
+void RNSVGTSpanComponentInstance::UpdateElementProps() {
+    m_svgTSpan->UpdateCommonProps(m_props);
+    m_svgTSpan->content_ = m_props->content;
+    m_svgTSpan->UpdateFontProps(m_props);
+    m_svgTSpan->UpdateTextProps(m_props);
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,27 @@
+/*
+ * 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 "RNSVGBaseComponentInstance.h"
+#include "SvgTSpan.h"
+
+namespace rnoh {
+namespace svg {
+
+class RNSVGTSpanComponentInstance : public RNSVGBaseComponentInstance<facebook::react::RNSVGTSpanShadowNode> {
+public:
+    explicit RNSVGTSpanComponentInstance(Context context);
+
+protected:
+    void UpdateElementProps() override;
+
+private:
+    std::shared_ptr<SvgTSpan> m_svgTSpan = std::make_shared<SvgTSpan>();
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,25 @@
+/*
+ * 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 "RNSVGTextComponentInstance.h"
+#include <react/renderer/components/react_native_svg/Props.h>
+
+namespace rnoh {
+namespace svg {
+
+RNSVGTextComponentInstance::RNSVGTextComponentInstance(Context context)
+    : RNSVGBaseComponentInstance(std::move(context)) {
+    SetSvgNode(m_svgText);
+}
+
+void RNSVGTextComponentInstance::UpdateElementProps() {
+    m_svgText->UpdateCommonProps(m_props);
+    m_svgText->UpdateFontProps(m_props);
+    m_svgText->UpdateTextProps(m_props);
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,27 @@
+/*
+ * 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 "RNSVGBaseComponentInstance.h"
+#include "SvgText.h"
+
+namespace rnoh {
+namespace svg {
+
+class RNSVGTextComponentInstance : public RNSVGBaseComponentInstance<facebook::react::RNSVGTextShadowNode> {
+public:
+    explicit RNSVGTextComponentInstance(Context context);
+
+protected:
+    void UpdateElementProps() override;
+
+private:
+    std::shared_ptr<SvgText> m_svgText = std::make_shared<SvgText>();
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -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.
+ */
+
+#include "RNSVGTextPathComponentInstance.h"
+#include "utils/DynamicUtils.h"
+#include "SvgTSpan.h"
+#include <react/renderer/components/react_native_svg/Props.h>
+
+namespace rnoh {
+namespace svg {
+
+RNSVGTextPathComponentInstance::RNSVGTextPathComponentInstance(Context context)
+    : RNSVGBaseComponentInstance(std::move(context)) {
+    SetSvgNode(m_svgTP);
+}
+
+void RNSVGTextPathComponentInstance::UpdateElementProps() {
+    m_svgTP->UpdateCommonProps(m_props);
+    m_svgTP->UpdateFontProps(m_props);
+    m_svgTP->UpdateTextProps(m_props);
+    m_svgTP->href_ = m_props->href;
+    m_svgTP->startOffset_ = StringUtils::FromString(DynamicUtils::DynamicToString(m_props->startOffset)).ConvertToPx(m_layoutMetrics.pointScaleFactor);
+    m_svgTP->spacing_ = textPathSpacingFromStr(m_props->spacing);
+    m_svgTP->midLine_ = textPathMidLineFromStr(m_props->midLine);
+    m_svgTP->side_ = textPathSideFromStr(m_props->side);
+    m_svgTP->method_ = textPathMethodFromStr(m_props->method);
+}
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,27 @@
+/*
+ * 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 "RNSVGBaseComponentInstance.h"
+#include "SvgTextPath.h"
+
+namespace rnoh {
+namespace svg {
+
+class RNSVGTextPathComponentInstance : public RNSVGBaseComponentInstance<facebook::react::RNSVGTextPathShadowNode> {
+public:
+    explicit RNSVGTextPathComponentInstance(Context context);
+
+protected:
+    void UpdateElementProps() override;
+
+private:
+    std::shared_ptr<SvgTextPath> m_svgTP = std::make_shared<SvgTextPath>();
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -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.
+ */
+
+#include "RNSVGUseComponentInstance.h"
+#include "utils/DynamicUtils.h"
+
+
+namespace rnoh {
+namespace svg {
+
+RNSVGUseComponentInstance::RNSVGUseComponentInstance(Context context) : RNSVGBaseComponentInstance(std::move(context)) {
+    SetSvgNode(m_svgUse);
+}
+
+void RNSVGUseComponentInstance::UpdateElementProps() {
+    m_svgUse->UpdateCommonProps(m_props);
+    std::string xStr = DynamicUtils::DynamicToString(m_props->x);
+    std::string yStr = DynamicUtils::DynamicToString(m_props->y);
+    std::string widthStr = DynamicUtils::DynamicToString(m_props->width);
+    std::string heightStr = DynamicUtils::DynamicToString(m_props->height);
+    m_svgUse->x = xStr.empty() ? 0.0f : std::stof(xStr);
+    m_svgUse->y = yStr.empty() ? 0.0f : std::stof(yStr);
+    m_svgUse->width = widthStr.empty() ? 0.0f : std::stof(widthStr);
+    m_svgUse->height = heightStr.empty() ? 0.0f : std::stof(heightStr);
+    m_svgUse->href = m_props->href;
+}
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/build/default/cache/default/default@PackageHar/src/main/cpp/componentInstances/RNSVGUseComponentInstance.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 "RNSVGBaseComponentInstance.h"
+#include "SvgUse.h"
+
+namespace rnoh {
+namespace svg {
+
+class RNSVGUseComponentInstance : public RNSVGBaseComponentInstance<facebook::react::RNSVGUseShadowNode> {
+public:
+    explicit RNSVGUseComponentInstance(Context context);
+
+protected:
+    void UpdateElementProps() override;
+
+    void onChildInserted(ComponentInstance::Shared const &childComponentInstance, std::size_t index) override {
+        CppComponentInstance::onChildInserted(childComponentInstance, index);
+        // svgUse don't draw children elements
+    }
+
+private:
+    std::shared_ptr<SvgUse> m_svgUse = std::make_shared<SvgUse>();
+};
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,266 @@
+/*
+ * 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 <unistd.h>
+#include <sstream>
+#include "HttpTaskProcessor.h"
+
+namespace rnoh {
+namespace svg {
+std::vector<HttpTaskProcessor *> HttpTaskProcessor::taskList_;
+std::unordered_set<std::string> HttpTaskProcessor::threadIds_;
+
+void ResponseCallback(void *usrCtx, Rcp_Response *response, uint32_t errCode) {
+    HttpTaskProcessor *processor = static_cast<HttpTaskProcessor *>(usrCtx);
+
+    // 记录当前线程的ID
+    std::ostringstream oss;
+    oss << std::this_thread::get_id();
+    processor->pushThreadID(oss.str());
+
+    if (response != NULL) {
+        if (response->statusCode == RCP_OK) {
+            size_t status = processor->saveImage(response->body.buffer, response->body.length);
+            if (processor->instance_ && status != 0) {
+                processor->instance_->imageDownloadComplete(processor->uri_, processor->filePath_);
+            } else if (processor->instance_) {
+                LOG(WARNING) << "[SVGImage] ResponseCallback imageDownloadFail, status: " << status;
+                processor->instance_->imageDownloadFail(processor->uri_);
+            }
+        }
+
+        response->destroyResponse(response);
+    } else {
+        LOG(ERROR) << "[SVGImage] Callback Response is NULL, errCode: " << errCode;
+        if (processor->instance_) {
+            processor->instance_->imageDownloadFail(processor->uri_);
+        }
+    }
+
+    processor->markEnd();
+}
+
+void HttpTaskProcessor::createParentPath(const fs::path &filePath) {
+    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;
+    }
+}
+
+size_t HttpTaskProcessor::saveImage(const char *buffer, uint32_t length) {
+    size_t status = 0;
+    if (filePath_ == "")
+        return status;
+    
+    // 验证输入参数
+    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;
+}
+
+void HttpTaskProcessor::markStart() {
+    finished_ = false;
+    auto now = std::chrono::high_resolution_clock::now();
+    startTime_ = std::chrono::time_point_cast<std::chrono::nanoseconds>(now).time_since_epoch();
+}
+
+void HttpTaskProcessor::markEnd() {
+    // 记录时间戳，标记任务结束使得keep() 返回false
+    auto now = std::chrono::high_resolution_clock::now();
+    endTime_ = std::chrono::time_point_cast<std::chrono::nanoseconds>(now).time_since_epoch();
+    finished_ = true;
+}
+
+bool HttpTaskProcessor::initializeRequestAndSession(const char *uri,
+                                                    const std::map<std::string, std::string> *headers) {
+    // 创建http request 对象
+    request_ = HMS_Rcp_CreateRequest(uri);
+    if (request_ == nullptr) {
+        LOG(ERROR) << "[SVGImage] Failed to create HTTP request!";
+        return false;
+    }
+
+    // 如果有 headers 参数，初始化 headers
+    if (headers) {
+        Rcp_Headers *header = HMS_Rcp_CreateHeaders();
+        for (const auto &it : *headers) {
+            if (auto errorCode = HMS_Rcp_SetHeaderValue(header, it.first.c_str(), it.second.c_str())) {
+                LOG(ERROR) << "[SVGImage] launchHttpRequestWithHeaders create headers error: " << errorCode;
+                return false;
+            }
+        }
+        request_->headers = header;
+    }
+
+    // 创建http 会话对象
+    uint32_t errorCode = 0;
+    session_ = HMS_Rcp_CreateSession(nullptr, &errorCode);
+    if (errorCode) {
+        LOG(ERROR) << "[SVGImage] Failed to create HTTP session, error code: " << errorCode;
+        return false;
+    }
+
+    return true;
+}
+
+void HttpTaskProcessor::setResponseCallback() {
+    // 设置响应数据处理的回调函数
+    responseCallback_.callback = ResponseCallback;
+    responseCallback_.usrCtx = this;
+}
+
+void HttpTaskProcessor::launchHttpRequest(const char *uri) {
+    markStart();
+    this->uri_ = uri;
+    if (!initializeRequestAndSession(uri)) {
+        if (instance_) {
+            instance_->imageDownloadFail(uri);
+        }
+        markEnd();
+        return;
+    }
+
+    // 设置响应数据处理的回调函数
+    setResponseCallback();
+
+    // API异步发起请求
+    if (auto errCode = HMS_Rcp_Fetch(session_, request_, &responseCallback_)) {
+        LOG(ERROR) << "[SVGImage] launchHttpRequest HMS_Rcp_Fetch error: " << errCode;
+        if (instance_) {
+            instance_->imageDownloadFail(uri);
+        }
+        markEnd();
+    }
+}
+
+void HttpTaskProcessor::launchHttpRequestWithHeaders(const char *uri,
+                                                     const std::map<std::string, std::string> &headers) {
+    markStart();
+    this->uri_ = uri;
+    if (!initializeRequestAndSession(uri, &headers)) {
+        if (instance_) {
+            instance_->imageDownloadFail(uri);
+        }
+        markEnd();
+        return;
+    }
+
+    // 设置响应数据处理的回调函数
+    setResponseCallback();
+
+    // API异步发起请求
+    if (auto errCode = HMS_Rcp_Fetch(session_, request_, &responseCallback_)) {
+        LOG(ERROR) << "[SVGImage] launchHttpRequest HMS_Rcp_Fetch error: " << errCode;
+        if (instance_) {
+            instance_->imageDownloadFail(uri);
+        }
+        markEnd();
+    }
+}
+
+// static
+void HttpTaskProcessor::waitAllTask() {
+    bool wait = true;
+    while (wait) {
+        wait = false;
+        for (auto *processor : taskList_) {
+            if (processor->keep())
+                wait = true;
+        }
+        if (wait) {
+            usleep(1000 * 1000);
+            echoThreadIds();
+        }
+    }
+}
+
+// static
+void HttpTaskProcessor::destroyAllTask() {
+    for (auto *processor : taskList_) {
+        processor->echoSpendTime();
+        delete processor;
+    }
+
+    taskList_.clear();
+    threadIds_.clear();
+}
+
+// static
+void HttpTaskProcessor::echoThreadIds() {
+    for (auto id : threadIds_) {
+        DLOG(INFO) << "[SVGImage] NetDownload Task Thread ID: " << id.c_str();
+    }
+
+    DLOG(INFO) << "[SVGImage] NetDownload Number Of Thread : " << threadIds_.size();
+}
+
+void HttpTaskProcessor::pushThreadID(std::string id) { threadIds_.insert(id); }
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,88 @@
+/*
+ * 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 <cstdio>
+#include <map>
+#include <string>
+#include <string.h>
+#include <stdio.h>
+#include <unordered_set>
+#include <filesystem>
+#include <glog/logging.h>
+#include "RemoteCommunicationKit/rcp.h"
+#include "ImageSourceResolver.h"
+#include "utils/StringUtils.h"
+
+namespace fs = std::filesystem;
+namespace rnoh {
+namespace svg {
+class HttpTaskProcessor {
+public:
+    HttpTaskProcessor() { taskList_.push_back(this); }
+
+    ~HttpTaskProcessor() {
+        if (request_ != nullptr) {
+            // 释放请求资源
+            HMS_Rcp_DestroyRequest(request_);
+            request_ = nullptr;
+        }
+    }
+
+    static void clearTaskList() { taskList_.clear(); }
+
+    void createParentPath(const fs::path &filePath);
+
+    size_t saveImage(const char *buffer, uint32_t length);
+
+    void markStart();
+
+    void markEnd();
+
+    bool keep() { return !finished_; }
+
+    void echoSpendTime() {
+        DLOG(INFO) << "[SVGImage] HttpTaskProcessor Spend Time(ns): " << endTime_.count() - startTime_.count();
+    }
+
+    bool initializeRequestAndSession(const char *uri, const std::map<std::string, std::string> *headers = nullptr);
+    void setResponseCallback();
+
+    void launchHttpRequest(const char *uri);
+    void launchHttpRequestWithHeaders(const char *uri, const std::map<std::string, std::string> &headers);
+
+
+    void pushThreadID(std::string id);
+
+    static void waitAllTask();
+    static void destroyAllTask();
+    static void echoThreadIds();
+
+    std::shared_ptr<ImageSourceResolver> instance_;
+
+    std::string uri_;
+    std::string filePath_;
+
+private:
+    static std::vector<HttpTaskProcessor *> taskList_;
+    static std::unordered_set<std::string> threadIds_;
+
+    FILE *fp_ = nullptr;
+
+    std::chrono::nanoseconds startTime_;
+    std::chrono::nanoseconds endTime_;
+
+    bool finished_ = false;
+
+    Rcp_Request *request_ = nullptr;
+    Rcp_Session *session_ = nullptr;
+
+    Rcp_ResponseCallbackObject responseCallback_;
+};
+
+} // namespace svg
+} // namespace rnoh