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

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

@@ -0,0 +1,134 @@
+/*
+ * 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(std::shared_ptr<ImageSourceUpdateListener> listener, std::string uri) {
+    // 判断是否还在下载中
+    if (m_pendingSet.find(uri) != m_pendingSet.end()) {
+        removeListener(listener);
+        addListenerForURI(uri, listener);
+        return "";
+    }
+    // 生成图像的哈希缓存文件名
+    auto hashedFileName = StringUtils::generateHash(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, std::shared_ptr<ImageSourceUpdateListener> listener) {
+    listener->observedUri = uri;
+    auto it = m_uriListenersMap.find(uri);
+    if (it == m_uriListenersMap.end()) {
+        m_uriListenersMap.emplace(uri, std::vector<std::weak_ptr<ImageSourceUpdateListener>>{listener});
+        return;
+    }
+    
+    auto alreadyThere = std::find_if(it->second.begin(), it->second.end(),[&listener]  
+    (const std::weak_ptr<ImageSourceUpdateListener> &wk )
+    {   
+        auto sp = wk.lock();
+        return sp == listener;
+
+    });
+    if (alreadyThere != it->second.end())
+    {
+        return;
+    }
+    it->second.push_back(listener);
+}
+
+void ImageSourceResolver::removeListenerForURI(const std::string &uri, std::shared_ptr<ImageSourceUpdateListener> listener) {
+    auto it = m_uriListenersMap.find(uri);
+    if (it == m_uriListenersMap.end()) {
+        return;
+    }
+    auto &listeners = it->second;
+    auto listenerPos = std::find_if(listeners.begin(), listeners.end(), [&listener](const std::weak_ptr<ImageSourceUpdateListener> &wk)
+    {
+        auto sp = wk.lock();
+        return sp == listener;
+
+    });
+    if (listenerPos != listeners.end()) {
+        listeners.erase(listenerPos);
+        if (listeners.empty()) {
+            m_uriListenersMap.erase(uri);
+        }
+    }
+}
+
+void ImageSourceResolver::removeListener(std::shared_ptr<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::generateHash(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) {
+        
+        if (auto weaklistener = listener.lock())
+        {
+            weaklistener->onImageSourceCacheUpdate(fileUri);
+            removeListenerForURI(uri, weaklistener);
+        }
+
+    }
+}
+
+void ImageSourceResolver::imageDownloadFail(std::string uri) {
+    if (uri.empty()) {
+        return;
+    }
+    if (!m_pendingSet.empty()) {
+        auto pend = m_pendingSet.find(uri);
+        if (pend != m_pendingSet.end()) {
+            m_pendingSet.erase(uri);
+        }
+    }
+    if (!m_uriListenersMap.empty()) {
+        auto it = m_uriListenersMap.find(uri);
+        if (it == m_uriListenersMap.end()) {
+            return;
+        }
+        auto &listeners = it->second;
+        for (auto listener : listeners) {
+            auto weaklistener = listener.lock();
+            if (weaklistener) {
+                weaklistener->onImageSourceCacheDownloadFileFail();
+                removeListenerForURI(uri, weaklistener);
+            }
+        }
+    }
+}
+
+} // namespace svg
+} // namespace rnoh

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

@@ -0,0 +1,93 @@
+/*
+ * 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() = default;
+
+        // 监听图像缓存更新
+        virtual void onImageSourceCacheUpdate(std::string imageUri) = 0;
+
+        // 监听图像下载失败
+        virtual void onImageSourceCacheDownloadFileFail() = 0;
+
+    private:
+        ImageSourceResolver::Shared const &m_imageSourceResolver;
+    };
+
+    // 解析图像源的缓存路径
+    std::string resolveImageSources(std::shared_ptr<ImageSourceUpdateListener> listener, std::string uri);
+
+    // 为URI添加监听器
+    void addListenerForURI(const std::string &uri, std::shared_ptr<ImageSourceUpdateListener> listener);
+
+    // 从URI移除监听器
+    void removeListenerForURI(const std::string &uri, std::shared_ptr<ImageSourceUpdateListener> listener);
+
+    // 从解析器中移除监听器
+    void removeListener(std::shared_ptr<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<std::weak_ptr<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

package/harmony/svg/src/main/cpp/drawing/Brush.cpp

@@ -0,0 +1,50 @@
+/*
+ * 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 "Brush.h"
+
+namespace rnoh::drawing {
+
+Brush::Brush() : brush_(UniqueNativeBrush(OH_Drawing_BrushCreate(), &OH_Drawing_BrushDestroy)) {}
+
+Brush::Brush(Brush const &other)
+    : brush_(UniqueNativeBrush(OH_Drawing_BrushCopy(other.brush_.get()), &OH_Drawing_BrushDestroy)) {}
+
+Brush &Brush::operator=(Brush const &) {
+    brush_ = UniqueNativeBrush(OH_Drawing_BrushCopy(brush_.get()), &OH_Drawing_BrushDestroy);
+    return *this;
+}
+
+void Brush::SetAntiAlias(bool antiAlias) { OH_Drawing_BrushSetAntiAlias(brush_.get(), antiAlias); }
+
+void Brush::SetColor(uint32_t color) { OH_Drawing_BrushSetColor(brush_.get(), color); }
+
+void Brush::SetAlpha(uint8_t alpha) { OH_Drawing_BrushSetAlpha(brush_.get(), alpha); }
+
+void Brush::SetLinearShaderEffect(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                                  const uint32_t *colors, const float *pos, uint32_t size, OH_Drawing_TileMode mode,
+                                  const OH_Drawing_Matrix *mat) {
+    brushShaderEffect_.ShaderEffectCreateLinearGradient(startPt, endPt, colors, pos, size, mode, mat);
+    OH_Drawing_BrushSetShaderEffect(brush_.get(), brushShaderEffect_.get());
+}
+
+void Brush::SetRadialShaderEffect(const OH_Drawing_Point2D *startPt, float startRadius, const OH_Drawing_Point2D *endPt,
+                                  float endRadius, const uint32_t *colors, const float *pos, uint32_t size,
+                                  OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat) {
+    brushShaderEffect_.ShaderEffectCreateRadialGradient(startPt, startRadius, endPt, endRadius, colors, pos, size, mode,
+                                                        mat);
+    OH_Drawing_BrushSetShaderEffect(brush_.get(), brushShaderEffect_.get());
+}
+
+void Brush::SetImageShaderEffect(OH_Drawing_Image *image, OH_Drawing_TileMode tileX, OH_Drawing_TileMode tileY,
+                                 const OH_Drawing_SamplingOptions *opt, const OH_Drawing_Matrix *mat) {
+    brushShaderEffect_.ShaderEffectCreateImageShader(image, tileX, tileY, opt, mat);
+    OH_Drawing_BrushSetShaderEffect(brush_.get(), brushShaderEffect_.get());
+}
+
+void Brush::Reset() { OH_Drawing_BrushReset(brush_.get()); }
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Brush.h

@@ -0,0 +1,52 @@
+/*
+ * 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 <native_drawing/drawing_brush.h>
+#include "ShaderEffect.h"
+
+namespace rnoh::drawing {
+
+class Brush final {
+
+    using UniqueNativeBrush = std::unique_ptr<OH_Drawing_Brush, decltype(&OH_Drawing_BrushDestroy)>;
+
+public:
+    Brush();
+
+    Brush(Brush const &);
+    Brush &operator=(Brush const &);
+
+    Brush(Brush &&) = default;
+    Brush &operator=(Brush &&) = default;
+
+    ~Brush() noexcept = default;
+
+    void SetAntiAlias(bool antiAlias);
+    void SetColor(uint32_t color);
+    void SetAlpha(uint8_t alpha);
+
+    void SetLinearShaderEffect(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                               const uint32_t *colors, const float *pos, uint32_t size, OH_Drawing_TileMode mode,
+                               const OH_Drawing_Matrix *mat);
+    void SetRadialShaderEffect(const OH_Drawing_Point2D *startPt, float startRadius, const OH_Drawing_Point2D *endPt,
+                               float endRadius, const uint32_t *colors, const float *pos, uint32_t size,
+                               OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat);
+    void SetImageShaderEffect(OH_Drawing_Image *image, OH_Drawing_TileMode tileX, OH_Drawing_TileMode tileY,
+                              const OH_Drawing_SamplingOptions *opt, const OH_Drawing_Matrix *mat);
+
+    void Reset();
+
+    OH_Drawing_Brush *get() const { return brush_.get(); }
+
+private:
+    UniqueNativeBrush brush_;
+    ShaderEffect brushShaderEffect_;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/GlyPathBag.cpp

@@ -0,0 +1,20 @@
+/*
+ * 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 "GlyPathBag.h"
+#include "Path.h"
+
+namespace rnoh::drawing {
+
+
+int GlyPathBag::getIndex(char ch) {
+    auto it = data.find(ch);
+    return it == data.end() ? 0 : it->second;
+}
+
+drawing::Path GlyPathBag::getOrCreateAndCache(const char &ch, const std::string &current) { return drawing::Path(); }
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/GlyPathBag.h

@@ -0,0 +1,31 @@
+/*
+ * 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 <vector>
+#include "drawing/Path.h"
+#include "drawing/Pen.h"
+
+namespace rnoh::drawing {
+
+class GlyPathBag {
+private:
+    int getIndex(char ch);
+    std::vector<drawing::Path> paths;
+    std::unordered_map<char, int> data;
+    drawing::Pen paint;
+
+public:
+    GlyPathBag(drawing::Pen const &paint) {
+        // Make indexed-by-one, to allow zero to represent non-cached
+        paths.push_back(drawing::Path());
+    }
+    drawing::Path getOrCreateAndCache(const char &ch, const std::string &current);
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Matrix.cpp

@@ -0,0 +1,100 @@
+/*
+ * 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 "Matrix.h"
+
+namespace rnoh::drawing {
+
+Matrix::Matrix() : matrix_(UniqueNativeMatrix(OH_Drawing_MatrixCreate(), &OH_Drawing_MatrixDestroy)) {}
+
+Matrix::Matrix(Matrix const &other) : Matrix() { *this = other; }
+
+Matrix &Matrix::operator=(Matrix const &other) {
+    if (this != &other) {
+        auto scaleX = OH_Drawing_MatrixGetValue(other.matrix_.get(), 0);
+        auto skewX = OH_Drawing_MatrixGetValue(other.matrix_.get(), 1);
+        auto transX = OH_Drawing_MatrixGetValue(other.matrix_.get(), 2);
+        auto skewY = OH_Drawing_MatrixGetValue(other.matrix_.get(), 3);
+        auto scaleY = OH_Drawing_MatrixGetValue(other.matrix_.get(), 4);
+        auto transY = OH_Drawing_MatrixGetValue(other.matrix_.get(), 5);
+        auto persp0 = OH_Drawing_MatrixGetValue(other.matrix_.get(), 6);
+        auto persp1 = OH_Drawing_MatrixGetValue(other.matrix_.get(), 7);
+        auto persp2 = OH_Drawing_MatrixGetValue(other.matrix_.get(), 8);
+        OH_Drawing_MatrixSetMatrix(matrix_.get(), scaleX, skewX, transX, skewY, scaleY, transY, persp0, persp1, persp2);
+    }
+    return *this;
+}
+
+
+Matrix Matrix::CreateRotation(float deg, float x, float y) {
+    return Matrix(OH_Drawing_MatrixCreateRotation(deg, x, y));
+}
+Matrix Matrix::CreateScale(float sx, float sy, float px, float py) {
+    return Matrix(OH_Drawing_MatrixCreateScale(sx, sy, px, py));
+}
+Matrix Matrix::CreateTranslation(float dx, float dy) { return Matrix(OH_Drawing_MatrixCreateTranslation(dx, dy)); }
+
+void Matrix::PreRotate(float degree, float px, float py) { OH_Drawing_MatrixPreRotate(matrix_.get(), degree, px, py); }
+void Matrix::PreScale(float sx, float sy, float px, float py) {
+    OH_Drawing_MatrixPreScale(matrix_.get(), sx, sy, px, py);
+}
+void Matrix::PreTranslate(float dx, float dy) { OH_Drawing_MatrixPreTranslate(matrix_.get(), dx, dy); }
+
+void Matrix::PostRotate(float degree, float px, float py) {
+    OH_Drawing_MatrixPostRotate(matrix_.get(), degree, px, py);
+}
+void Matrix::PostScale(float sx, float sy, float px, float py) {
+    OH_Drawing_MatrixPostScale(matrix_.get(), sx, sy, px, py);
+}
+void Matrix::PostTranslate(float dx, float dy) { OH_Drawing_MatrixPostTranslate(matrix_.get(), dx, dy); }
+
+void Matrix::Rotate(float degree, float px, float py) { OH_Drawing_MatrixRotate(matrix_.get(), degree, px, py); }
+void Matrix::Translate(float dx, float dy) { OH_Drawing_MatrixTranslate(matrix_.get(), dx, dy); }
+void Matrix::Scale(float sx, float sy, float px, float py) { OH_Drawing_MatrixScale(matrix_.get(), sx, sy, px, py); }
+
+Matrix Matrix::Concat(const Matrix &other) const {
+    Matrix result;
+    OH_Drawing_MatrixConcat(result.matrix_.get(), matrix_.get(), other.matrix_.get());
+    return result;
+}
+
+std::optional<Matrix> Matrix::Invert() const {
+    Matrix result;
+    if (OH_Drawing_MatrixInvert(matrix_.get(), result.matrix_.get())) {
+        return result;
+    }
+    return std::nullopt;
+}
+
+float Matrix::GetValue(int index) const { return OH_Drawing_MatrixGetValue(matrix_.get(), index); }
+
+void Matrix::SetMatrix(float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float persp0,
+                       float persp1, float persp2) {
+    OH_Drawing_MatrixSetMatrix(matrix_.get(), scaleX, skewX, transX, skewY, scaleY, transY, persp0, persp1, persp2);
+}
+
+Matrix::Point drawing::Matrix::MapPoint(const Matrix::Point &point) const {
+    Point result;
+    OH_Drawing_MatrixMapPoints(matrix_.get(), &point, &result, 1);
+    return result;
+}
+
+std::vector<Matrix::Point> drawing::Matrix::MapPoints(const std::vector<Matrix::Point> &points) const {
+    std::vector<Matrix::Point> result(points.size());
+    OH_Drawing_MatrixMapPoints(matrix_.get(), points.data(), result.data(), points.size());
+    return result;
+}
+
+drawing::Rect drawing::Matrix::MapRect(const drawing::Rect &rect) const {
+    Rect result;
+    OH_Drawing_MatrixMapRect(matrix_.get(), rect.get(), result.get());
+    return result;
+}
+
+void Matrix::Reset() { OH_Drawing_MatrixReset(matrix_.get()); }
+
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Matrix.h

@@ -0,0 +1,68 @@
+/*
+ * 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 "Rect.h"
+#include <memory>
+#include <optional>
+#include <vector>
+#include <native_drawing/drawing_matrix.h>
+
+namespace rnoh::drawing {
+
+class Matrix final {
+    using UniqueNativeMatrix = std::unique_ptr<OH_Drawing_Matrix, decltype(&OH_Drawing_MatrixDestroy)>;
+    using Point = OH_Drawing_Point2D;
+
+public:
+    Matrix();
+
+    Matrix(Matrix const &);
+    Matrix &operator=(Matrix const &);
+
+    Matrix(Matrix &&) = default;
+    Matrix &operator=(Matrix &&) = default;
+
+    ~Matrix() noexcept = default;
+
+    static Matrix CreateRotation(float deg, float x, float y);
+    static Matrix CreateScale(float sx, float sy, float px, float py);
+    static Matrix CreateTranslation(float dx, float dy);
+    void PreRotate(float degree, float px, float py);
+    void PreScale(float sx, float sy, float px, float py);
+    void PreTranslate(float dx, float dy);
+    void PostRotate(float degree, float px, float py);
+    void PostScale(float sx, float sy, float px, float py);
+    void PostTranslate(float dx, float dy);
+    void Rotate(float degree, float px, float py);
+    void Translate(float dx, float dy);
+    void Scale(float sx, float sy, float px, float py);
+
+    Matrix Concat(const Matrix &other) const;
+    std::optional<Matrix> Invert() const;
+
+    float GetValue(int index) const;
+
+    void SetMatrix(float scaleX, float skewX, float transX, float skewY, float scaleY, float transY, float persp0,
+                   float persp1, float persp2);
+
+    Point MapPoint(const Point &point) const;
+    std::vector<Point> MapPoints(const std::vector<Point> &points) const;
+
+    drawing::Rect MapRect(const drawing::Rect &rect) const;
+
+    void Reset();
+
+    OH_Drawing_Matrix *get() const { return matrix_.get(); }
+
+private:
+    Matrix(OH_Drawing_Matrix *rawMatrix) : matrix_(UniqueNativeMatrix(rawMatrix, &OH_Drawing_MatrixDestroy)) {}
+
+    UniqueNativeMatrix matrix_;
+};
+
+} // namespace rnoh::drawing