@react-native-ohos/react-native-blurhash 2.0.4-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Marc Rousavy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.OpenSource

@@ -0,0 +1,11 @@
+[
+    {
+        "Name": "react-native-blurhash",
+        "License": "MIT License",
+        "License File": "https://github.com/mrousavy/react-native-blurhash/blob/master/LICENSE",
+        "Version Number": "2.0.3",
+        "Owner" : "xiafeng@huawei.com",
+        "Upstream URL": "https://github.com/mrousavy/react-native-blurhash",
+        "Description": "🖼 Blurhash is a compact representation of a placeholder for an image. This is a Native UI Module for React Native to asynchronously wrap the Blurhash implementations and make them usable in React Native. Also supports encoding!"
+    }
+]

package/README.md

@@ -0,0 +1,13 @@
+# @react-native-ohos/react-native-blurhash
+
+本项目基于 [react-native-blurhash](https://github.com/TiHxdvt/react-native-blurhash)
+
+## 文档地址 / Documentation URL 
+
+[中文 / Chinese](https://gitee.com/react-native-oh-library/usage-docs/blob/master/zh-cn/react-native-blurhash.md)
+
+[英文 / English](https://gitee.com/react-native-oh-library/usage-docs/blob/master/zh-en/react-native-blurhash.md)
+
+## 请悉知 / Acknowledgements
+
+本项目基于 [The MIT License (MIT)](https://github.com/mrousavy/react-native-blurhash/blob/master/LICENSE) ，请自由地享受和参与开源。

package/harmony/blurhash/BuildProfile.ets

@@ -0,0 +1,17 @@
+/**
+ * Use these variables when you tailor your ArkTS code. They must be of the const type.
+ */
+export const HAR_VERSION = '2.0.3-0.0.2';
+export const BUILD_MODE_NAME = 'debug';
+export const DEBUG = true;
+export const TARGET_NAME = 'default';
+
+/**
+ * BuildProfile Class is used only for compatibility purposes.
+ */
+export default class BuildProfile { 
+	static readonly HAR_VERSION = HAR_VERSION;
+	static readonly BUILD_MODE_NAME = BUILD_MODE_NAME;
+	static readonly DEBUG = DEBUG;
+	static readonly TARGET_NAME = TARGET_NAME;
+}

package/harmony/blurhash/build-profile.json5

@@ -0,0 +1,9 @@
+{
+  "apiType": "stageMode",
+  "targets": [
+    {
+      "name": "default",
+      "runtimeOS": "HarmonyOS"
+    }
+  ]
+}

package/harmony/blurhash/hvigorfile.ts

@@ -0,0 +1,2 @@
+// Script for compiling build behavior. It is built in the build plug-in and cannot be modified currently.
+export { harTasks } from '@ohos/hvigor-ohos-plugin';

package/harmony/blurhash/index.ets

@@ -0,0 +1,2 @@
+export * from './ts'
+// export * from './src/main/ets/BlurhashView'

package/harmony/blurhash/oh-package.json5

@@ -0,0 +1,13 @@
+{
+  license: 'ISC',
+  types: '',
+  name: '@react-native-ohos/react-native-blurhash',
+  description: '',
+  main: 'index.ets',
+  type: 'module',
+  version: '2.0.4-rc.1',
+  dependencies: {
+    "@rnoh/react-native-openharmony": 'file:../react_native_openharmony',
+    "librnoh_blurhash.so": "file:./src/main/cpp/types/libblurhash"
+  },
+}

package/harmony/blurhash/src/main/cpp/Blurhash.cpp

@@ -0,0 +1,314 @@
+/*
+ * 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 "Blurhash.hpp"
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cmath>
+#include <stdexcept>
+#include <string>
+#ifdef __clang__
+#define STBIWDEF static inline
+#endif
+#define STB_IMAGE_WRITE_STATIC
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image_write.h"
+#include "stb_image.h"
+#include <glog/logging.h>
+
+using namespace std::literals;
+
+namespace {
+SparseArray<std::vector<double>> cacheCosinesX;
+SparseArray<std::vector<double>> cacheCosinesY;
+constexpr std::array<char, 84> int_to_b83{"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"};
+std::string leftPad(std::string str, size_t len) {
+    if (str.size() >= len)
+        return str;
+    return str.insert(0, len - str.size(), '0');
+}
+constexpr std::array<int, 255> b83_to_int = []() constexpr {
+    std::array<int, 255> a{};
+    for (auto &e : a)
+        e = -1;
+    for (int i = 0; i < 83; i++) {
+        a[static_cast<unsigned char>(int_to_b83[i])] = i;
+    }
+    return a;
+}();
+std::string encode83(int value) {
+    std::string buffer;
+    do {
+        buffer += int_to_b83[value % 83];
+    } while ((value = value / 83));
+    std::reverse(buffer.begin(), buffer.end());
+    return buffer;
+}
+struct Components {
+    int x, y;
+};
+int packComponents(const Components &c) noexcept { return (c.x - 1) + (c.y - 1) * 9; }
+Components unpackComponents(int c) noexcept { return {c % 9 + 1, c / 9 + 1}; }
+int decode83(std::string_view value) {
+    int temp = 0;
+    for (char c : value)
+        if (b83_to_int[static_cast<unsigned char>(c)] < 0)
+            throw std::invalid_argument("invalid character in blurhash");
+    for (char c : value)
+        temp = temp * 83 + b83_to_int[static_cast<unsigned char>(c)];
+    return temp;
+}
+float decodeMaxAC(int quantizedMaxAC) noexcept { return static_cast<float>(quantizedMaxAC + 1) / 166.f; }
+float decodeMaxAC(std::string_view maxAC) {
+    assert(maxAC.size() == 1);
+    return decodeMaxAC(decode83(maxAC));
+}
+int encodeMaxAC(float maxAC) noexcept { return std::max(0, std::min(82, int(maxAC * 166 - 0.5f))); }
+float srgbToLinear(int value) noexcept {
+    auto srgbToLinearF = [](float x) {
+        if (x <= 0.0f)
+            return 0.0f;
+        else if (x >= 1.0f)
+            return 1.0f;
+        else if (x < 0.04045f)
+            return x / 12.92f;
+        else
+            return std::pow((x + 0.055f) / 1.055f, 2.4f);
+    };
+    return srgbToLinearF(static_cast<float>(value) / 255.f);
+}
+int linearToSrgb(float value) noexcept {
+    auto linearToSrgbF = [](float x) -> float {
+        if (x <= 0.0f)
+            return 0.0f;
+        else if (x >= 1.0f)
+            return 1.0f;
+        else if (x < 0.0031308f)
+            return x * 12.92f;
+        else
+            return std::pow(x, 1.0f / 2.4f) * 1.055f - 0.055f;
+    };
+    return int(linearToSrgbF(value) * 255.f + 0.5f);
+}
+struct Color {
+    float r, g, b;
+    Color &operator*=(float scale) {
+        r *= scale;
+        g *= scale;
+        b *= scale;
+        return *this;
+    }
+    friend Color operator*(Color lhs, float rhs) { return (lhs *= rhs); }
+    Color &operator/=(float scale) {
+        r /= scale;
+        g /= scale;
+        b /= scale;
+        return *this;
+    }
+    Color &operator+=(const Color &rhs) {
+        r += rhs.r;
+        g += rhs.g;
+        b += rhs.b;
+        return *this;
+    }
+};
+Color decodeDC(int value) {
+    const int intR = value >> 16;
+    const int intG = (value >> 8) & 255;
+    const int intB = value & 255;
+    return {srgbToLinear(intR), srgbToLinear(intG), srgbToLinear(intB)};
+}
+Color decodeDC(std::string_view value) {
+    assert(value.size() == 4);
+    return decodeDC(decode83(value));
+}
+int encodeDC(const Color &c) { return (linearToSrgb(c.r) << 16) + (linearToSrgb(c.g) << 8) + linearToSrgb(c.b); }
+float signPow(float value, float exp) { return std::copysign(std::pow(std::abs(value), exp), value); }
+int encodeAC(const Color &c, float maximumValue) {
+    auto quantR = int(std::max(0., std::min(18., std::floor(signPow(c.r / maximumValue, 0.5) * 9 + 9.5))));
+    auto quantG = int(std::max(0., std::min(18., std::floor(signPow(c.g / maximumValue, 0.5) * 9 + 9.5))));
+    auto quantB = int(std::max(0., std::min(18., std::floor(signPow(c.b / maximumValue, 0.5) * 9 + 9.5))));
+    return quantR * 19 * 19 + quantG * 19 + quantB;
+}
+Color decodeAC(int value, float maximumValue) {
+    auto quantR = value / (19 * 19);
+    auto quantG = (value / 19) % 19;
+    auto quantB = value % 19;
+
+    return {signPow((float(quantR) - 9) / 9, 2) * maximumValue, signPow((float(quantG) - 9) / 9, 2) * maximumValue, signPow((float(quantB) - 9) / 9, 2) * maximumValue};
+}
+Color decodeAC(std::string_view value, float maximumValue) { return decodeAC(decode83(value), maximumValue); }
+const float pi = std::acos(-1.0f);
+std::vector<float> bases_for(size_t dimension, size_t components) {
+    std::vector<float> bases(dimension * components);
+
+    float scale = pi / float(dimension);
+
+    size_t index = 0;
+    std::generate(bases.begin(), bases.end(), [&]() {
+        size_t x = index / components;
+        size_t nx = index % components;
+        index++;
+        return std::cos(scale * float(nx * x));
+    });
+
+    return bases;
+}
+
+
+} // namespace
+namespace blurhash {
+std::string path = "/data/storage/el2/base/haps/entry/cache/";
+/**
+ * @brief 解码Blurhash为图像
+ * @param blurhash 待解码的Blurhash字符串
+ * @param width 图像宽度
+ * @param height 图像高度
+ * @param bytesPerPixel 每个像素的字节数
+ * @param useCache 是否使用缓存
+ * @return 解码后的图像
+ * @note
+ * 此函数首先检查Blurhash的长度，如果长度小于6，则返回空图像。然后尝试解码Blurhash的组件，
+ * 如果解码失败，则返回空图像。接着解码最大AC值和平均颜色值。然后解码AC值并将其添加到值向量中。
+ * 最后使用解码的值和基础函数计算图像的每个像素的颜色，并将其存储在图像的image数组中。
+ */
+std::string decode(std::string_view blurhash, size_t width, size_t height, float punch, bool useCache) noexcept {
+    size_t bytesPerPixel = 3;
+    Image i{};
+    if (blurhash.size() < 6)
+        return "";
+    Components components{};
+    std::vector<Color> values;
+    values.reserve(blurhash.size() / 2);
+    try {
+        components = unpackComponents(decode83(blurhash.substr(0, 1)));
+        if (components.x < 1 || components.y < 1 || blurhash.size() != size_t(1 + 1 + 4 + (components.x * components.y - 1) * 2))
+            return {};
+        auto maxAC = decodeMaxAC(blurhash.substr(1, 1));
+        maxAC *= punch;
+        Color average = decodeDC(blurhash.substr(2, 4));
+        values.push_back(average);
+        for (size_t c = 6; c < blurhash.size(); c += 2)
+            values.push_back(decodeAC(blurhash.substr(c, 2), maxAC));
+    } catch (std::invalid_argument &) {
+        return {};
+    }
+    i.image = decltype(i.image)(height * width * bytesPerPixel, 255);
+    std::vector<float> basis_x = bases_for(width, components.x);
+    std::vector<float> basis_y = bases_for(height, components.y);
+    for (size_t y = 0; y < height; y++) {
+        for (size_t x = 0; x < width; x++) {
+            Color c{};
+            for (size_t nx = 0; nx < size_t(components.x); nx++) {
+                for (size_t ny = 0; ny < size_t(components.y); ny++) {
+                    float basis = basis_x[x * components.x + nx] * basis_y[y * components.y + ny];
+                    c += values[nx + ny * components.x] * basis;
+                }
+            }
+            i.image[(y * width + x) * bytesPerPixel + 0] = static_cast<unsigned char>(linearToSrgb(c.r));
+            i.image[(y * width + x) * bytesPerPixel + 1] = static_cast<unsigned char>(linearToSrgb(c.g));
+            i.image[(y * width + x) * bytesPerPixel + 2] = static_cast<unsigned char>(linearToSrgb(c.b));
+        }
+    }
+    i.height = height;
+    i.width = width;
+
+    std::string filename = path + std::string(blurhash) + ".bmp";
+    stbi_write_bmp(filename.c_str(), i.width, i.height, 3, (void *)i.image.data());
+    return filename;
+}
+
+
+/**
+ * 对图像进行编码的函数
+ * @param image 待编码的图像数据
+ * @param width 图像的宽度
+ * @param height 图像的高度
+ * @param components_x 在x方向上的分量数
+ * @param components_y 在y方向上的分量数
+ * @return 编码后的字符串
+ */
+std::string encode(char const *filename, int components_x, int components_y) {
+    auto start = std::chrono::steady_clock::now();
+    auto duration = std::chrono::seconds(5);
+    int width, height, n;
+    unsigned char *data = stbi_load((path + filename).c_str(), &width, &height, &n, 3);
+    if (components_x < 1 || components_x > 9 || components_y < 1 || components_y > 9)
+        return "";
+    while (width < 1 || height < 1 || !data) {
+        data = stbi_load((path + filename).c_str(), &width, &height, &n, 3);
+        auto now = std::chrono::steady_clock::now();
+        if (now - start >= duration) {
+            return "";
+        }
+    }
+    std::vector<float> basis_x = bases_for(width, components_x);
+    std::vector<float> basis_y = bases_for(height, components_y);
+    std::vector<Color> factors(components_x * components_y, Color{});
+    for (size_t y = 0; y < height; y++) {
+        for (size_t x = 0; x < width; x++) {
+            Color linear{srgbToLinear(data[3 * x + 0 + y * width * 3]), srgbToLinear(data[3 * x + 1 + y * width * 3]), srgbToLinear(data[3 * x + 2 + y * width * 3])};
+            linear *= 1.f / static_cast<float>(width);
+            for (size_t ny = 0; ny < size_t(components_y); ny++) {
+                for (size_t nx = 0; nx < size_t(components_x); nx++) {
+                    float basis = basis_x[x * size_t(components_x) + nx] * basis_y[y * size_t(components_y) + ny];
+                    factors[ny * components_x + nx] += linear * basis;
+                }
+            }
+        }
+    }
+    for (size_t i = 0; i < factors.size(); i++) {
+        float normalisation = (i == 0) ? 1 : 2;
+        float scale = normalisation / static_cast<float>(height);
+        factors[i] *= scale;
+    }
+    assert(factors.size() > 0);
+    auto dc = factors.front();
+    factors.erase(factors.begin());
+    std::string h;
+    h += leftPad(encode83(packComponents({components_x, components_y})), 1);
+    float maximumValue;
+    if (!factors.empty()) {
+        float actualMaximumValue = 0;
+        for (auto ac : factors) {
+            actualMaximumValue = std::max({
+                std::abs(ac.r),
+                std::abs(ac.g),
+                std::abs(ac.b),
+                actualMaximumValue,
+            });
+        }
+        int quantisedMaximumValue = encodeMaxAC(actualMaximumValue);
+        maximumValue = ((float)quantisedMaximumValue + 1) / 166;
+        h += leftPad(encode83(quantisedMaximumValue), 1);
+    } else {
+        maximumValue = 1;
+        h += leftPad(encode83(0), 1);
+    }
+    h += leftPad(encode83(encodeDC(dc)), 4);
+    for (auto ac : factors)
+        h += leftPad(encode83(encodeAC(ac, maximumValue)), 2);
+
+    return h;
+}
+
+
+void clearCache() {
+
+    DLOG(INFO) << "clearCosineCache:SparseArray<std::vector<double>> Object";
+    DLOG(INFO) << "clearCosineCache:SparseArray<std::vector<double>> Object";
+    cacheCosinesX.clear();
+    cacheCosinesY.clear(); 
+    DLOG(INFO) << "clearCosineCache:null";
+    DLOG(INFO) << "clearCosineCache:null";
+}
+} // namespace blurhash
+
+#ifdef DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#endif

package/harmony/blurhash/src/main/cpp/Blurhash.hpp

@@ -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 <__functional/function.h>
+#include <string>
+#include <string_view>
+#include <vector>
+#include "SparseArray.h"
+
+namespace blurhash {
+struct Image {
+    size_t width, height;
+    std::vector<unsigned char> image; // pixels rgb
+};
+
+std::string decode(std::string_view blurhash, size_t width = 32, size_t height = 32, float punch = 1.0, bool useCache = true) noexcept;
+
+std::string encode(char const *filename, int components_x, int components_y);
+
+void clearCache();
+
+} // namespace blurhash

package/harmony/blurhash/src/main/cpp/BlurhashNode.cpp

@@ -0,0 +1,87 @@
+/*
+ * 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 "BlurhashNode.h"
+
+#include <string_view>
+#include "RNOH/arkui/NativeNodeApi.h"
+
+
+static constexpr ArkUI_NodeEventType IMAGE_NODE_EVENT_TYPES[] = {NODE_IMAGE_ON_COMPLETE, NODE_IMAGE_ON_ERROR, NODE_IMAGE_ON_DOWNLOAD_PROGRESS};
+
+namespace rnoh {
+
+using namespace std::literals;
+constexpr std::string_view ASSET_PREFIX = "asset://"sv;
+const std::string RAWFILE_PREFIX = "resource://RAWFILE/assets/";
+
+BlurhashNode::BlurhashNode()
+    : ArkUINode(NativeNodeApi::getInstance()->createNode(ArkUI_NodeType::ARKUI_NODE_IMAGE)), m_childArkUINodeHandle(nullptr), m_blurhashNodeDelegate(nullptr) {
+    for (auto eventType : IMAGE_NODE_EVENT_TYPES) {
+        maybeThrow(NativeNodeApi::getInstance()->registerNodeEvent(m_nodeHandle, eventType, eventType, this));
+    }
+}
+
+BlurhashNode::~BlurhashNode() {
+    for (auto eventType : IMAGE_NODE_EVENT_TYPES) {
+        NativeNodeApi::getInstance()->unregisterNodeEvent(m_nodeHandle, eventType);
+    }
+}
+
+BlurhashNode &BlurhashNode::setSource(std::string const &uri, std::string prefix) {
+    ArkUI_AttributeItem item;
+    std::string absolutePath = prefix == "" ? RAWFILE_PREFIX : prefix;
+    if (uri.rfind(ASSET_PREFIX, 0) == 0) {
+        absolutePath += uri.substr(ASSET_PREFIX.size());
+        item = {.string = absolutePath.c_str()};
+    } else {
+        item = {.string = uri.c_str()};
+    }
+    maybeThrow(NativeNodeApi::getInstance()->setAttribute(m_nodeHandle, NODE_IMAGE_SRC, &item));
+    return *this;
+}
+
+void BlurhashNode::setNodeDelegate(BlurhashNodeDelegate *blurhashNodeDelegate) { m_blurhashNodeDelegate = blurhashNodeDelegate; }
+
+void BlurhashNode::onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs){
+    if (eventType == ArkUI_NodeEventType::NODE_IMAGE_ON_COMPLETE) {
+        if (m_blurhashNodeDelegate != nullptr && eventArgs[0].i32 == 1) {
+            m_blurhashNodeDelegate->onComplete();
+        }
+    }
+
+    if (eventType == ArkUI_NodeEventType::NODE_IMAGE_ON_ERROR) {
+        if (m_blurhashNodeDelegate != nullptr) {
+            m_blurhashNodeDelegate->onError(eventArgs[0].i32);
+        }
+    }
+
+    if (eventType == ArkUI_NodeEventType::NODE_IMAGE_ON_DOWNLOAD_PROGRESS) {
+        if (m_blurhashNodeDelegate != nullptr) {
+            m_blurhashNodeDelegate->onProgress(eventArgs[0].u32, eventArgs[1].u32);
+        }
+    }
+}
+
+BlurhashNode &BlurhashNode::setResizeMode(facebook::react::ImageResizeMode const &mode) {
+    int32_t val = ARKUI_OBJECT_FIT_COVER;
+    if (mode == facebook::react::ImageResizeMode::Cover) {
+        val = ARKUI_OBJECT_FIT_COVER;
+    } else if (mode == facebook::react::ImageResizeMode::Contain) {
+        val = ARKUI_OBJECT_FIT_CONTAIN;
+    } else if (mode == facebook::react::ImageResizeMode::Stretch) {
+        val = ARKUI_OBJECT_FIT_FILL;
+    } else if (mode == facebook::react::ImageResizeMode::Center || mode == facebook::react::ImageResizeMode::Repeat) {
+        val = ARKUI_OBJECT_FIT_NONE;
+    }
+
+    ArkUI_NumberValue value[] = {{.i32 = val}};
+    ArkUI_AttributeItem item = {value, sizeof(value) / sizeof(ArkUI_NumberValue)};
+    maybeThrow(NativeNodeApi::getInstance()->setAttribute(m_nodeHandle, NODE_IMAGE_OBJECT_FIT, &item));
+    return *this;
+}
+
+} // namespace rnoh

package/harmony/blurhash/src/main/cpp/BlurhashNode.h

@@ -0,0 +1,35 @@
+/*
+ * 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 <cstdint>
+#include <react/renderer/imagemanager/primitives.h>
+#include "RNOH/arkui/ArkUINode.h"
+
+namespace rnoh {
+
+class BlurhashNodeDelegate {
+public:
+    virtual ~BlurhashNodeDelegate() = default;
+    virtual void onComplete(){};
+    virtual void onError(int32_t errorCode){};
+    virtual void onProgress(uint32_t loaded, uint32_t total){};
+};
+
+class BlurhashNode : public ArkUINode {
+protected:
+    ArkUI_NodeHandle m_childArkUINodeHandle;
+    BlurhashNodeDelegate *m_blurhashNodeDelegate;
+
+public:
+    BlurhashNode();
+    ~BlurhashNode();
+    BlurhashNode &setSource(std::string const &uri, std::string prefix = "");
+    BlurhashNode &setResizeMode(facebook::react::ImageResizeMode const &mode);
+    void onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs) override;
+    void setNodeDelegate(BlurhashNodeDelegate *blurhashNodeDelegate);
+};
+} // namespace rnoh

package/harmony/blurhash/src/main/cpp/BlurhashPackage.h

@@ -0,0 +1,53 @@
+/*
+ * 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 "RNOH/Package.h"
+#include "ComponentDescriptors.h"
+#include "BlurhashViewJSIBinder.h"
+#include "RNBlurhashTurboModule.h"
+#include "BlurhashViewComponentInstance.h"
+
+using namespace rnoh;
+
+class BlurhashViewComponentInstanceFactoryDelegate : public ComponentInstanceFactoryDelegate {
+public:
+    using ComponentInstanceFactoryDelegate::ComponentInstanceFactoryDelegate;
+
+    ComponentInstance::Shared create(ComponentInstance::Context ctx) override {
+        if (ctx.componentName == "BlurhashView") {
+            return std::make_shared<BlurhashViewComponentInstance>(std::move(ctx));
+        }
+        return nullptr;
+    }
+};
+
+class BlurhashTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+        if (name == "BlurhashModule") {
+            return std::make_shared<RNBlurhashTurboModule>(ctx, name);
+        }
+        return nullptr;
+    }
+};
+
+class BlurhashPackage : public Package {
+public:
+    BlurhashPackage(Package::Context ctx) : Package(ctx) {}
+
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override { return std::make_unique<BlurhashTurboModuleFactoryDelegate>(); }
+
+    ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate() override {
+        return std::make_shared<BlurhashViewComponentInstanceFactoryDelegate>();
+    }
+
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override {
+        return {facebook::react::concreteComponentDescriptorProvider<facebook::react::BlurhashViewComponentDescriptor>()};
+    }
+
+    ComponentJSIBinderByString createComponentJSIBinderByName() override { return {{"BlurhashView", std::make_shared<BlurhashViewJSIBinder>()}}; }
+};
+// namespace rnoh