@react-native-ohos/react-native-blurhash 2.0.4-rc.2 → 2.0.4-rc.3

package/harmony/blurhash/index.ets

@@ -1,2 +1,4 @@
+import { BlurhashPackage } from './src/main/ets/BlurhashPackage.ets'
 export * from './ts'
 // export * from './src/main/ets/BlurhashView'
+export default BlurhashPackage

package/harmony/blurhash/oh-package.json5

@@ -5,7 +5,7 @@
   description: '',
   main: 'index.ets',
   type: 'module',
-  version: '2.0.4-rc.2',
+  version: '2.0.4-rc.3',
   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

@@ -4,7 +4,7 @@
  * found in the LICENSE file.
  */
 
-#include "Blurhash.hpp"
+#include "Blurhash.h"
 
 #include <algorithm>
 #include <array>
@@ -21,16 +21,58 @@
 #include "stb_image_write.h"
 #include "stb_image.h"
 #include <glog/logging.h>
+#define MIN_BLURHASH_SIZE 6
+#define AC_VALUE_MULTIPLIER 166
+#define MIN_COMPONENT 1
+#define MAX_COMPONENT 9
+#define COMPONENT_3 3
+#define CHANNELS_PER_PIXEL 3
+#define CONSTANT_SIZE  2
+#define MAX_PIXEL_VALUE 255
+#define MAX_AC_SIZE 4
+#define MAX_ENCODED_VALUE 82
+#define BASE 83
+#define DEFAULT_CHANNELS 3
+#define LEFT_PADDING_2 2
+#define LEFT_PADDING_4 4
+#define RED_SHIFT 16
+#define GREEN_SHIFT 8
+#define MAX_X 9
+#define HEX_DIGITS_PER_CHAR 2
+#define QUANT_STEP 19
+#define RED_CHANNEL 0
+#define GREEN_CHANNEL 1
+#define BLUE_CHANNEL 2
+#define AC_COMPONENT_SIZE 2
+#define EXPECTEDSIZE 4
 
 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)
+constexpr std::array<char, 84> int_to_b83{
+    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"};
+
+inline bool NearEqual(const float left, const float right, const float epsilon)
+{
+    return (std::abs(left - right) <= epsilon);
+}
+inline bool NearZero(const float value, const float epsilon)
+{
+    return NearEqual(value, 0.0, epsilon);
+}
+inline bool NearZero(const float value)
+{
+    constexpr float epsilon = 0.001f;
+    return NearZero(value, epsilon);
+}
+
+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 {
@@ -42,129 +84,178 @@ constexpr std::array<int, 255> b83_to_int = []() constexpr {
     }
     return a;
 }();
-std::string encode83(int value) {
+std::string encode83(int value)
+{
     std::string buffer;
     do {
-        buffer += int_to_b83[value % 83];
-    } while ((value = value / 83));
+        buffer += int_to_b83[value % BASE];
+    } while ((value = value / BASE));
     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 packComponents(const Components &c) noexcept
+{
+    return (c.x - 1) + (c.y - 1) * MAX_X;
+}
+Components unpackComponents(int c) noexcept
+{
+    return {c % MAX_X + 1, c / MAX_X + 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)];
+        temp = temp * BASE + 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);
+float decodeMaxAC(int quantizedMaxAC) noexcept
+{
+    return static_cast<float>(quantizedMaxAC + 1) / 166.f;
+}
+float decodeMaxAC(std::string_view maxAC)
+{
+    if (maxAC.size() != 1) {
+        return 0.0f;
+    }
     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 {
+int encodeMaxAC(float maxAC) noexcept
+{
+    return std::max(0, std::min(MAX_ENCODED_VALUE, int(maxAC * AC_VALUE_MULTIPLIER - 0.5f)));
+}
+float srgbToLinear(int value) noexcept
+{
     auto srgbToLinearF = [](float x) {
-        if (x <= 0.0f)
+        if (x <= 0.0f) {
             return 0.0f;
-        else if (x >= 1.0f)
+        } else if (x >= 1.0f) {
             return 1.0f;
-        else if (x < 0.04045f)
+        } else if (x < 0.04045f) {
             return x / 12.92f;
-        else
+        } else {
             return std::pow((x + 0.055f) / 1.055f, 2.4f);
+        }
     };
     return srgbToLinearF(static_cast<float>(value) / 255.f);
 }
-int linearToSrgb(float value) noexcept {
+int linearToSrgb(float value) noexcept
+{
     auto linearToSrgbF = [](float x) -> float {
-        if (x <= 0.0f)
+        if (x <= 0.0f) {
             return 0.0f;
-        else if (x >= 1.0f)
+        } else if (x >= 1.0f) {
             return 1.0f;
-        else if (x < 0.0031308f)
+        } else if (x < 0.0031308f) {
             return x * 12.92f;
-        else
+        } 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) {
+    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) {
+    friend Color operator*(Color lhs, float rhs)
+    {
+        return (lhs *= rhs);
+    }
+    Color &operator/=(float scale)
+    {
+        if (NearZero(scale)) {
+            return *this;
+        }
         r /= scale;
         g /= scale;
         b /= scale;
         return *this;
     }
-    Color &operator+=(const Color &rhs) {
+    Color &operator+=(const Color &rhs)
+    {
         r += rhs.r;
         g += rhs.g;
         b += rhs.b;
         return *this;
     }
 };
-Color decodeDC(int value) {
+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);
+Color decodeDC(std::string_view value)
+{
+    if (value.size() != EXPECTEDSIZE) {
+        return Color{0.0f, 0.0f, 0.0f};
+    }
     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) {
+int encodeDC(const Color &c)
+{
+    return (linearToSrgb(c.r) << RED_SHIFT) + (linearToSrgb(c.g) << GREEN_SHIFT) + 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)
+{
+    if (maximumValue == 0) {
+        return -1;
+    }
     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;
+    return quantR * QUANT_STEP * QUANT_STEP + quantG * QUANT_STEP + 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(int value, float maximumValue)
+{
+    auto quantR = value / (QUANT_STEP * QUANT_STEP);
+    auto quantG = (value / QUANT_STEP) % QUANT_STEP;
+    auto quantB = value % QUANT_STEP;
+    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);
 }
-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_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(), [&]() {
+        if (components == 0) {
+            throw std::invalid_argument("components cannot be zero");
+        }
         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/rn_image_cache/";
+std::string path = "/data/storage/el2/base/haps/entry/cache/";
 /**
  * @brief 解码Blurhash为图像
  * @param blurhash 待解码的Blurhash字符串
@@ -178,28 +269,30 @@ std::string path = "/data/storage/el2/base/haps/entry/cache/rn_image_cache/";
  * 如果解码失败，则返回空图像。接着解码最大AC值和平均颜色值。然后解码AC值并将其添加到值向量中。
  * 最后使用解码的值和基础函数计算图像的每个像素的颜色，并将其存储在图像的image数组中。
  */
-std::string decode(std::string_view blurhash, size_t width, size_t height, float punch, bool useCache) noexcept {
+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)
+    if (blurhash.size() < MIN_BLURHASH_SIZE)
         return "";
     Components components{};
     std::vector<Color> values;
-    values.reserve(blurhash.size() / 2);
+    values.reserve(blurhash.size() / HEX_DIGITS_PER_CHAR);
     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))
+        if (components.x < 1 || components.y < 1 ||
+            blurhash.size() != size_t(1 + 1 + MAX_AC_SIZE + (components.x * components.y - 1) * AC_COMPONENT_SIZE))
             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));
+        for (size_t c = 6; c < blurhash.size(); c += CONSTANT_SIZE)
+            values.push_back(decodeAC(blurhash.substr(c, CONSTANT_SIZE), maxAC));
     } catch (std::invalid_argument &) {
         return {};
     }
-    i.image = decltype(i.image)(height * width * bytesPerPixel, 255);
+    i.image = decltype(i.image)(height * width * bytesPerPixel, MAX_PIXEL_VALUE);
     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++) {
@@ -211,20 +304,18 @@ std::string decode(std::string_view blurhash, size_t width, size_t height, float
                     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.image[(y * width + x) * bytesPerPixel + RED_CHANNEL] = static_cast<unsigned char>(linearToSrgb(c.r));
+            i.image[(y * width + x) * bytesPerPixel + GREEN_CHANNEL] = static_cast<unsigned char>(linearToSrgb(c.g));
+            i.image[(y * width + x) * bytesPerPixel + BLUE_CHANNEL] = 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());
+    stbi_write_bmp(filename.c_str(), i.width, i.height, CHANNELS_PER_PIXEL, (void *)i.image.data());
     return filename;
 }
-
-
 /**
  * 对图像进行编码的函数
  * @param image 待编码的图像数据
@@ -234,15 +325,19 @@ std::string decode(std::string_view blurhash, size_t width, size_t height, float
  * @param components_y 在y方向上的分量数
  * @return 编码后的字符串
  */
-std::string encode(char const *filename, int components_x, int components_y) {
+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)
+    int width;
+    int height;
+    int n;
+    unsigned char *data = stbi_load((path + filename).c_str(), &width, &height, &n, DEFAULT_CHANNELS);
+    if (components_x < MIN_COMPONENT || components_x > MAX_COMPONENT ||
+        components_y < MIN_COMPONENT || components_y > MAX_COMPONENT)
         return "";
     while (width < 1 || height < 1 || !data) {
-        data = stbi_load((path + filename).c_str(), &width, &height, &n, 3);
+        data = stbi_load((path + filename).c_str(), &width, &height, &n, COMPONENT_3);
         auto now = std::chrono::steady_clock::now();
         if (now - start >= duration) {
             return "";
@@ -253,7 +348,8 @@ std::string encode(char const *filename, int components_x, int 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])};
+            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++) {
@@ -268,7 +364,9 @@ std::string encode(char const *filename, int components_x, int components_y) {
         float scale = normalisation / static_cast<float>(height);
         factors[i] *= scale;
     }
-    assert(factors.size() > 0);
+    if (factors.size() <= 0) {
+        throw std::runtime_error("Factors array is empty");
+    }
     auto dc = factors.front();
     factors.erase(factors.begin());
     std::string h;
@@ -285,30 +383,26 @@ std::string encode(char const *filename, int components_x, int components_y) {
             });
         }
         int quantisedMaximumValue = encodeMaxAC(actualMaximumValue);
-        maximumValue = ((float)quantisedMaximumValue + 1) / 166;
+        maximumValue = ((float)quantisedMaximumValue + 1) / AC_VALUE_MULTIPLIER;
         h += leftPad(encode83(quantisedMaximumValue), 1);
     } else {
         maximumValue = 1;
         h += leftPad(encode83(0), 1);
     }
-    h += leftPad(encode83(encodeDC(dc)), 4);
+    h += leftPad(encode83(encodeDC(dc)), LEFT_PADDING_4);
     for (auto ac : factors)
-        h += leftPad(encode83(encodeAC(ac, maximumValue)), 2);
-
+        h += leftPad(encode83(encodeAC(ac, maximumValue)), LEFT_PADDING_2);
     return h;
 }
-
-
-void clearCache() {
-
+void clearCache()
+{
     DLOG(INFO) << "clearCosineCache:SparseArray<std::vector<double>> Object";
     DLOG(INFO) << "clearCosineCache:SparseArray<std::vector<double>> Object";
     cacheCosinesX.clear();
-    cacheCosinesY.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 → Blurhash.h}

@@ -3,7 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef BLURHASH_H
+#define BLURHASH_H
 #pragma once
 
 #include <__functional/function.h>
@@ -18,10 +19,12 @@ struct Image {
     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 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
+#endif

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

@@ -9,29 +9,32 @@
 #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};
+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) {
+    : 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() {
+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) {
+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) {
@@ -44,9 +47,13 @@ BlurhashNode &BlurhashNode::setSource(std::string const &uri, std::string prefix
     return *this;
 }
 
-void BlurhashNode::setNodeDelegate(BlurhashNodeDelegate *blurhashNodeDelegate) { m_blurhashNodeDelegate = blurhashNodeDelegate; }
+void BlurhashNode::setNodeDelegate(BlurhashNodeDelegate *blurhashNodeDelegate)
+{
+    m_blurhashNodeDelegate = blurhashNodeDelegate;
+}
 
-void BlurhashNode::onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventArgs){
+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();
@@ -66,7 +73,8 @@ void BlurhashNode::onNodeEvent(ArkUI_NodeEventType eventType, EventArgs &eventAr
     }
 }
 
-BlurhashNode &BlurhashNode::setResizeMode(facebook::react::ImageResizeMode const &mode) {
+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;
@@ -77,11 +85,9 @@ BlurhashNode &BlurhashNode::setResizeMode(facebook::react::ImageResizeMode const
     } 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
+} // namespace rnoh

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

@@ -3,14 +3,14 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef BLURHASHNODE_H
+#define BLURHASHNODE_H
 #pragma once
 #include <cstdint>
 #include <react/renderer/imagemanager/primitives.h>
 #include "RNOH/arkui/ArkUINode.h"
 
 namespace rnoh {
-
 class BlurhashNodeDelegate {
 public:
     virtual ~BlurhashNodeDelegate() = default;
@@ -33,3 +33,4 @@ public:
     void setNodeDelegate(BlurhashNodeDelegate *blurhashNodeDelegate);
 };
 } // namespace rnoh
+#endif

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

@@ -3,20 +3,20 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
+#ifndef BLURHASHPACKAGE_H
+#define BLURHASHPACKAGE_H
 #include "RNOH/Package.h"
 #include "ComponentDescriptors.h"
 #include "BlurhashViewJSIBinder.h"
 #include "RNBlurhashTurboModule.h"
 #include "BlurhashViewComponentInstance.h"
-
-using namespace rnoh;
+namespace rnoh{
 
 class BlurhashViewComponentInstanceFactoryDelegate : public ComponentInstanceFactoryDelegate {
 public:
     using ComponentInstanceFactoryDelegate::ComponentInstanceFactoryDelegate;
-
-    ComponentInstance::Shared create(ComponentInstance::Context ctx) override {
+    ComponentInstance::Shared create(ComponentInstance::Context ctx) override
+    {
         if (ctx.componentName == "BlurhashView") {
             return std::make_shared<BlurhashViewComponentInstance>(std::move(ctx));
         }
@@ -26,7 +26,8 @@ public:
 
 class BlurhashTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
 public:
-    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
         if (name == "BlurhashModule") {
             return std::make_shared<RNBlurhashTurboModule>(ctx, name);
         }
@@ -38,16 +39,26 @@ class BlurhashPackage : public Package {
 public:
     BlurhashPackage(Package::Context ctx) : Package(ctx) {}
 
-    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override { return std::make_unique<BlurhashTurboModuleFactoryDelegate>(); }
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override
+    {
+        return std::make_unique<BlurhashTurboModuleFactoryDelegate>();
+    }
 
-    ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate() override {
+    ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate() override
+    {
         return std::make_shared<BlurhashViewComponentInstanceFactoryDelegate>();
     }
 
-    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override {
-        return {facebook::react::concreteComponentDescriptorProvider<facebook::react::BlurhashViewComponentDescriptor>()};
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override
+    {
+        return {facebook::react::concreteComponentDescriptorProvider<
+            facebook::react::BlurhashViewComponentDescriptor>()};
     }
 
-    ComponentJSIBinderByString createComponentJSIBinderByName() override { return {{"BlurhashView", std::make_shared<BlurhashViewJSIBinder>()}}; }
+    ComponentJSIBinderByString createComponentJSIBinderByName() override
+    {
+        return {{"BlurhashView", std::make_shared<BlurhashViewJSIBinder>()}};
+    }
 };
-// namespace rnoh
+}// namespace rnoh
+#endif