@react-native-ohos/react-native-blurhash 2.0.4-rc.4 → 2.1.0

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.1.0';
+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/index.ets

@@ -1,4 +1,2 @@
-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.4',
+  version: '2.1.0',
   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.h"
+#include "Blurhash.hpp"
 
 #include <algorithm>
 #include <array>
@@ -21,58 +21,16 @@
 #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#$%*+,-.:;=?@[]^_{|}~"};
-
-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) {
+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 {
@@ -84,178 +42,129 @@ 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 % BASE];
-    } while ((value = value / BASE));
+        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) * MAX_X;
-}
-Components unpackComponents(int c) noexcept
-{
-    return {c % MAX_X + 1, c / MAX_X + 1};
-}
-int decode83(std::string_view value)
-{
+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 * BASE + b83_to_int[static_cast<unsigned char>(c)];
+        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)
-{
-    if (maxAC.size() != 1) {
-        return 0.0f;
-    }
+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(MAX_ENCODED_VALUE, int(maxAC * AC_VALUE_MULTIPLIER - 0.5f)));
-}
-float srgbToLinear(int value) noexcept
-{
+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) {
+        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)
-    {
-        if (NearZero(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)
-    {
+    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)
-{
-    if (value.size() != EXPECTEDSIZE) {
-        return Color{0.0f, 0.0f, 0.0f};
-    }
+Color decodeDC(std::string_view value) {
+    assert(value.size() == 4);
     return decodeDC(decode83(value));
 }
-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;
-    }
+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 * QUANT_STEP * QUANT_STEP + quantG * QUANT_STEP + quantB;
+    return quantR * 19 * 19 + quantG * 19 + quantB;
 }
-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(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_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/";
+std::string path = "/data/storage/el2/base/haps/entry/cache/rn_image_cache/";
 /**
  * @brief 解码Blurhash为图像
  * @param blurhash 待解码的Blurhash字符串
@@ -269,30 +178,28 @@ std::string path = "/data/storage/el2/base/haps/entry/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() < MIN_BLURHASH_SIZE)
+    if (blurhash.size() < 6)
         return "";
     Components components{};
     std::vector<Color> values;
-    values.reserve(blurhash.size() / HEX_DIGITS_PER_CHAR);
+    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 + MAX_AC_SIZE + (components.x * components.y - 1) * AC_COMPONENT_SIZE))
+        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 += CONSTANT_SIZE)
-            values.push_back(decodeAC(blurhash.substr(c, CONSTANT_SIZE), maxAC));
+        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, MAX_PIXEL_VALUE);
+    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++) {
@@ -304,18 +211,20 @@ 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 + 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.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, CHANNELS_PER_PIXEL, (void *)i.image.data());
+    stbi_write_bmp(filename.c_str(), i.width, i.height, 3, (void *)i.image.data());
     return filename;
 }
+
+
 /**
  * 对图像进行编码的函数
  * @param image 待编码的图像数据
@@ -325,19 +234,15 @@ std::string decode(std::string_view blurhash, size_t width, size_t height, float
  * @param components_y 在y方向上的分量数
  * @return 编码后的字符串
  */
-std::string encode(char const *filepath, 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;
-    int height;
-    int n;
-    unsigned char *data = stbi_load(filepath, &width, &height, &n, DEFAULT_CHANNELS);
-    if (components_x < MIN_COMPONENT || components_x > MAX_COMPONENT ||
-        components_y < MIN_COMPONENT || components_y > MAX_COMPONENT)
+    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(filepath, &width, &height, &n, COMPONENT_3);
+        data = stbi_load((path + filename).c_str(), &width, &height, &n, 3);
         auto now = std::chrono::steady_clock::now();
         if (now - start >= duration) {
             return "";
@@ -348,8 +253,7 @@ std::string encode(char const *filepath, 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++) {
@@ -364,9 +268,7 @@ std::string encode(char const *filepath, int components_x, int components_y)
         float scale = normalisation / static_cast<float>(height);
         factors[i] *= scale;
     }
-    if (factors.size() <= 0) {
-        throw std::runtime_error("Factors array is empty");
-    }
+    assert(factors.size() > 0);
     auto dc = factors.front();
     factors.erase(factors.begin());
     std::string h;
@@ -383,26 +285,30 @@ std::string encode(char const *filepath, int components_x, int components_y)
             });
         }
         int quantisedMaximumValue = encodeMaxAC(actualMaximumValue);
-        maximumValue = ((float)quantisedMaximumValue + 1) / AC_VALUE_MULTIPLIER;
+        maximumValue = ((float)quantisedMaximumValue + 1) / 166;
         h += leftPad(encode83(quantisedMaximumValue), 1);
     } else {
         maximumValue = 1;
         h += leftPad(encode83(0), 1);
     }
-    h += leftPad(encode83(encodeDC(dc)), LEFT_PADDING_4);
+    h += leftPad(encode83(encodeDC(dc)), 4);
     for (auto ac : factors)
-        h += leftPad(encode83(encodeAC(ac, maximumValue)), LEFT_PADDING_2);
+        h += leftPad(encode83(encodeAC(ac, maximumValue)), 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.h → Blurhash.hpp}

@@ -3,8 +3,7 @@
  * 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>
@@ -19,12 +18,10 @@ 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 *filepath, int components_x, int components_y);
+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,32 +9,29 @@
 #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) {
@@ -47,13 +44,9 @@ 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();
@@ -73,8 +66,7 @@ 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;
@@ -85,9 +77,11 @@ 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,4 +33,3 @@ 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"
-namespace rnoh{
+
+using 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,8 +26,7 @@ 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);
         }
@@ -39,26 +38,16 @@ 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
-#endif
+// namespace rnoh