@react-native-ohos/react-native-svg 15.12.1-rc.1

package/harmony/svg/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/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/src/main/cpp/downloadUtils/HttpTaskProcessor.cpp

@@ -0,0 +1,207 @@
+/*
+ * 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) {
+    fs::path parentPath = filePath.parent_path();
+    if (!parentPath.empty() && !fs::exists(parentPath)) {
+        fs::create_directories(parentPath);
+    }
+}
+
+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_;
+    }
+    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/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

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

@@ -0,0 +1,106 @@
+/*
+ * 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 <fstream>
+#include "ImageSourceResolver.h"
+
+namespace rnoh {
+namespace svg {
+
+std::string ImageSourceResolver::resolveImageSources(ImageSourceUpdateListener &listener, std::string uri) {
+    // 判断是否还在下载中
+    if (m_pendingSet.find(uri) != m_pendingSet.end()) {
+        removeListener(&listener);
+        addListenerForURI(uri, &listener);
+        return "";
+    }
+    // 生成图像的哈希缓存文件名
+    auto hashedFileName = StringUtils::generateHashedFileName(uri);
+
+    bool exist = remoteImageSourceMap_.get(hashedFileName);
+    if (exist) {
+        auto cacheUri = "file://" + fileCacheDir_ + hashedFileName;
+        return cacheUri;
+    }
+    removeListener(&listener);
+    addListenerForURI(uri, &listener);
+    return "";
+}
+
+void ImageSourceResolver::addListenerForURI(const std::string &uri, ImageSourceUpdateListener *listener) {
+    listener->observedUri = uri;
+    auto it = m_uriListenersMap.find(uri);
+    if (it == m_uriListenersMap.end()) {
+        m_uriListenersMap.emplace(uri, std::initializer_list<ImageSourceUpdateListener *>{listener});
+        return;
+    }
+    if (std::find(it->second.begin(), it->second.end(), listener) != it->second.end()) {
+        return;
+    }
+    it->second.push_back(listener);
+}
+
+void ImageSourceResolver::removeListenerForURI(const std::string &uri, ImageSourceUpdateListener *listener) {
+    auto it = m_uriListenersMap.find(uri);
+    if (it == m_uriListenersMap.end()) {
+        return;
+    }
+    auto &listeners = it->second;
+    auto listenerPos = std::find(listeners.begin(), listeners.end(), listener);
+    if (listenerPos != listeners.end()) {
+        listeners.erase(listenerPos);
+        if (listeners.empty()) {
+            m_uriListenersMap.erase(uri);
+        }
+    }
+}
+
+void ImageSourceResolver::removeListener(ImageSourceUpdateListener *listener) {
+    if (!listener->observedUri.empty()) {
+        removeListenerForURI(listener->observedUri, listener);
+    }
+}
+
+void ImageSourceResolver::imageDownloadComplete(std::string uri, std::string fileUri) {
+    auto pend = m_pendingSet.find(uri);
+    if (pend != m_pendingSet.end()) {
+        m_pendingSet.erase(uri);
+    }
+    // 生成图像的哈希缓存文件名
+    auto hashedFileName = StringUtils::generateHashedFileName(uri);
+    DLOG(INFO) << "[SVGImage] remoteImageSourceMap PUT: " << hashedFileName;
+    remoteImageSourceMap_.put(hashedFileName, true);
+    auto it = m_uriListenersMap.find(uri);
+    if (it == m_uriListenersMap.end()) {
+        return;
+    }
+
+    auto &listeners = it->second;
+    for (auto listener : listeners) {
+        listener->onImageSourceCacheUpdate(fileUri);
+        removeListenerForURI(uri, listener);
+    }
+}
+
+void ImageSourceResolver::imageDownloadFail(std::string uri) {
+    auto pend = m_pendingSet.find(uri);
+    if (pend != m_pendingSet.end()) {
+        m_pendingSet.erase(uri);
+    }
+
+    auto it = m_uriListenersMap.find(uri);
+    if (it == m_uriListenersMap.end()) {
+        return;
+    }
+    auto &listeners = it->second;
+    for (auto listener : listeners) {
+        listener->onImageSourceCacheDownloadFileFail();
+        removeListenerForURI(uri, listener);
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,97 @@
+/*
+ * 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 <memory>
+#include <unordered_set>
+#include <filesystem>
+#include "RNOH/RNInstance.h"
+#include "downloadUtils/LRUCache.h"
+#include "utils/StringUtils.h"
+
+namespace fs = std::filesystem;
+
+namespace rnoh {
+namespace svg {
+
+// ImageSourceResolver 类用于管理图像源的缓存与下载
+class ImageSourceResolver {
+public:
+    using Shared = std::shared_ptr<ImageSourceResolver>;
+
+    // 构造函数，初始化缓存目录以及设置LRU缓存
+    explicit ImageSourceResolver(std::string fileCacheDir)
+        : m_uriListenersMap(), fileCacheDir_(fileCacheDir),
+          remoteImageSourceMap_(128, [this](std::string fileUri, bool a) {
+              // 删除缓存文件（LRU缓存淘汰回调）
+              fs::path filePath = this->fileCacheDir_ + fileUri;
+              if (fs::exists(filePath) && fs::is_regular_file(filePath)) {
+                  LOG(INFO) << "[SVGImage] remoteImageSourceMap delete: " << filePath;
+                  return fs::remove(filePath);
+              }
+              return false;
+          }) {}
+
+    // 图像源更新的监听器基类
+    class ImageSourceUpdateListener {
+    public:
+        std::string observedUri; // 监听的图像URI
+
+        ImageSourceUpdateListener(ImageSourceResolver::Shared const &ImageSourceResolver)
+            : m_imageSourceResolver(ImageSourceResolver) {}
+
+        // 注销监听器
+        ~ImageSourceUpdateListener() {
+            if (!m_imageSourceResolver) {
+                m_imageSourceResolver->removeListener(this);
+            }
+        }
+
+        // 监听图像缓存更新
+        virtual void onImageSourceCacheUpdate(std::string imageUri) = 0;
+
+        // 监听图像下载失败
+        virtual void onImageSourceCacheDownloadFileFail() = 0;
+
+    private:
+        ImageSourceResolver::Shared const &m_imageSourceResolver;
+    };
+
+    // 解析图像源的缓存路径
+    std::string resolveImageSources(ImageSourceUpdateListener &listener, std::string uri);
+
+    // 为URI添加监听器
+    void addListenerForURI(const std::string &uri, ImageSourceUpdateListener *listener);
+
+    // 从URI移除监听器
+    void removeListenerForURI(const std::string &uri, ImageSourceUpdateListener *listener);
+
+    // 从解析器中移除监听器
+    void removeListener(ImageSourceUpdateListener *listener);
+
+    // 下载完成后更新图像缓存
+    void imageDownloadComplete(std::string uri, std::string fileUri);
+
+    // 下载失败时，通知图像源更新失败
+    void imageDownloadFail(std::string uri);
+
+    // 使用LRU缓存来管理磁盘文件路径与URI的映射
+    LRUCache<std::string, bool> remoteImageSourceMap_;
+
+    // 存储图像缓存目录路径
+    std::string fileCacheDir_;
+
+private:
+    // 存储URI与对应的监听器（支持多个监听器）
+    std::unordered_map<std::string, std::vector<ImageSourceUpdateListener *>> m_uriListenersMap;
+
+    // 存储正在下载的图像URI集合
+    std::unordered_set<std::string> m_pendingSet;
+};
+
+} // namespace svg
+} // namespace rnoh

package/harmony/svg/src/main/cpp/downloadUtils/LRUCache.h

@@ -0,0 +1,98 @@
+/*
+ * 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 <unordered_map>
+#include <list>
+#include <mutex>
+
+namespace rnoh {
+namespace svg {
+template <typename KeyType, typename ValueType, int defaultCapacity = 10> class LRUCache {
+private:
+    std::unordered_map<KeyType, std::pair<ValueType, typename std::list<KeyType>::iterator>> m_cache;
+    std::list<KeyType> m_lruList;
+    std::mutex m_mtx; // 用于同步的互斥锁
+    std::function<bool(KeyType, ValueType)> m_deleteCallback;
+    int m_cacheCapacity; // 成员变量的容量
+
+public:
+    // 构造函数，允许设置自定义容量和删除回调函数
+    LRUCache(int customCapacity = defaultCapacity, std::function<bool(KeyType, ValueType)> callback = nullptr)
+        : m_cacheCapacity(customCapacity), m_deleteCallback(callback) {}
+
+    ValueType get(const KeyType &key) {
+        std::lock_guard<std::mutex> lock(m_mtx);
+        if (m_cache.find(key) != m_cache.end()) {
+            m_lruList.erase(m_cache[key].second);
+            m_lruList.push_front(key);
+            m_cache[key].second = m_lruList.begin();
+            return m_cache[key].first;
+        }
+        return ValueType(); // 如果没找到，返回默认构造的值
+    }
+
+    void put(const KeyType &key, const ValueType &value) {
+        std::lock_guard<std::mutex> lock(m_mtx);
+        if (m_cache.find(key) != m_cache.end()) {
+            m_cache[key].first = value;
+            m_lruList.erase(m_cache[key].second);
+            m_lruList.push_front(key);
+            m_cache[key].second = m_lruList.begin();
+        } else {
+            if (m_cache.size() >= m_cacheCapacity) {
+                KeyType lruKey = m_lruList.back();
+
+                // 调用删除回调函数
+                if (m_deleteCallback) {
+                    m_deleteCallback(lruKey, m_cache[lruKey].first);
+                }
+
+                m_cache.erase(lruKey);
+                m_lruList.pop_back();
+            }
+            m_lruList.push_front(key);
+            m_cache[key] = std::make_pair(value, m_lruList.begin());
+        }
+    }
+
+    bool remove(const KeyType &key) {
+        std::lock_guard<std::mutex> lock(m_mtx);
+        bool status = false;
+        if (m_cache.find(key) != m_cache.end()) {
+            ValueType value = m_cache[key].first;
+            m_lruList.erase(m_cache[key].second);
+            if (m_deleteCallback) {
+                status = m_deleteCallback(key, value);
+            }
+
+            m_cache.erase(key);
+        }
+        return status;
+    }
+    bool clearAll() {
+        std::lock_guard<std::mutex> lock(m_mtx);
+        // 从后向前遍历 lruList
+        for (auto it = m_lruList.end(); it != m_lruList.begin();) {
+            --it;              // 先向前移动迭代器
+            KeyType key = *it; // 获取当前键
+            if (m_deleteCallback) {
+                // 调用删除回调并检查返回值
+                if (!m_deleteCallback(key, m_cache[key].first)) {
+                    return false; // 如果删除失败，返回 false
+                }
+            }
+            m_cache.erase(key);       // 从 cache 中删除该键
+            it = m_lruList.erase(it); // 删除当前节点并更新迭代器
+        }
+        return true; // 成功删除所有元素，返回 true
+    }
+    size_t size() { return m_cache.size(); }
+};
+
+} // namespace svg
+} // namespace rnoh