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

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

@@ -3,9 +3,8 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
-
 #include "BlurhashViewComponentInstance.h"
-#include "Blurhash.hpp"
+#include "Blurhash.h"
 #include "Props.h"
 #include <filemanagement/file_uri/oh_file_uri.h>
 #include "RNBlurhashTurboModule.h"
@@ -13,125 +12,100 @@
 #include <iomanip>
 #include <react/renderer/core/ConcreteState.h>
 #include <sstream>
-#include <cstdio>
 
 namespace rnoh {
 
-BlurhashViewComponentInstance::BlurhashViewComponentInstance(Context context) : CppComponentInstance(std::move(context)) {
+BlurhashViewComponentInstance::BlurhashViewComponentInstance(Context context)
+    : CppComponentInstance(std::move(context))
+{
     this->getLocalRootArkUINode().setNodeDelegate(this);
 }
 
-void BlurhashViewComponentInstance::onPropsChanged(SharedConcreteProps const &props) {
-
+void BlurhashViewComponentInstance::onPropsChanged(SharedConcreteProps const &props)
+{
     CppComponentInstance::onPropsChanged(props);
 
     if (!m_props || m_props->resizeMode != props->resizeMode) {
         this->getLocalRootArkUINode().setResizeMode(convertToImageResizeMode(props->resizeMode));
     }
-    // Validate inputs and early-return to avoid passing null/invalid data into ArkUI
     if (props->blurhash == "") {
-        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "The provided Blurhash string must not be empty!"});
-        return;
-    }
+        m_eventEmitter->onLoadError({"The provided Blurhash string must not be null!"});
+    };
     if (props->decodeWidth <= 0) {
-        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodeWidth must be greater than 0!"});
-        return;
-    }
+        m_eventEmitter->onLoadError({"decodeWidth must be greater than 0!"});
+    };
     if (props->decodeHeight <= 0) {
-        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodeHeight must be greater than 0!"});
-        return;
-    }
+        m_eventEmitter->onLoadError({"decodeHeight must be greater than 0!"});
+    };
     if (props->decodePunch <= 0) {
-        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodePunch must be greater than 0!"});
-        return;
-    }
-
-    std::string filePath = decodeImageByBlurhash(props->blurhash, props->decodeWidth, props->decodeHeight, props->decodePunch);
-    if (filePath.empty()) {
-        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "Failed to decode blurhash to image."});
-        return;
-    }
-    
-
-    // If filePath is already a URI, use it directly
-    if (filePath.find("://") != std::string::npos) {
-    this->getLocalRootArkUINode().setSource(filePath);
-        return;
-    }
-    // If filePath is an absolute path, use it as-is; otherwise prefix cache dir
-    std::string absPath = filePath;
-    if (!(absPath.rfind("/", 0) == 0)) {
-        absPath = "/data/storage/el2/base/haps/entry/cache/" + absPath;
-    }
-
-    const char *path = absPath.c_str();
-    unsigned int length = static_cast<unsigned int>(absPath.size());
+        m_eventEmitter->onLoadError({"decodePunch must be greater than 0!"});
+    };
+    std::string filePath = decodeImageByBlurhash(props->blurhash,
+        props->decodeWidth, props->decodeHeight, props->decodePunch);
+    std::string tempPath = "/data/storage/el2/base/haps/entry/cache/" + filePath;
+    char *path = new char[tempPath.size() + 1];
+    std::strcpy(path, tempPath.c_str());
+    unsigned int length = strlen(path);
     char *result = nullptr;
     FileManagement_ErrCode ret = OH_FileUri_GetUriFromPath(path, length, &result);
-    if (ret != FileManagement_ErrCode::ERR_OK || result == nullptr) {
-        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "Failed to convert path to file URI."});
-        return;
+    this->getLocalRootArkUINode().setSource(std::string(result));
+    if (result != nullptr) {
+        free(result);
     }
-    std::string uriStr(result);
-    this->getLocalRootArkUINode().setSource(uriStr);
-    free(result);
 }
 
-std::string BlurhashViewComponentInstance::decodeImageByBlurhash(const std::string &blurhash, const int &width, const int &height, const float &punch) {
-    std::string expectedName = blurhash + ".bmp";
+std::string BlurhashViewComponentInstance::decodeImageByBlurhash(const std::string &blurhash,
+    const int &width, const int &height, const float &punch)
+{
     blurhash::decode(blurhash, width, height, punch);
     auto rnInstance = m_deps->rnInstance.lock();
     auto turboModule = rnInstance->getTurboModule("ImageLoader");
     auto arkTsTurboModule = std::dynamic_pointer_cast<rnoh::ArkTSTurboModule>(turboModule);
-    if (!arkTsTurboModule) {
-        return expectedName; // fallback filename
-    }
-    auto cache = arkTsTurboModule->callSync("getPrefetchResult", {expectedName});
-    std::string result;
-    if (cache.isString()) {
-        result = cache.asString();
-    }
-    if (result.empty()) {
-        // in case non-string/unsupported shape returned, fallback
-        result = expectedName;
-    }
-    return result;
+    auto cache = arkTsTurboModule->callSync("getPrefetchResult", {blurhash + ".bmp"});
+    return cache.asString();
 }
 
-BlurhashNode &BlurhashViewComponentInstance::getLocalRootArkUINode() { return m_imageNode; }
+BlurhashNode &BlurhashViewComponentInstance::getLocalRootArkUINode()
+{
+    return m_imageNode;
+}
 
-void BlurhashViewComponentInstance::onComplete() {
-    if (m_eventEmitter) {
-        m_eventEmitter->onLoadStart({});
-        m_eventEmitter->onLoadEnd({});
+void BlurhashViewComponentInstance::onComplete()
+{
+    m_eventEmitter->onLoadStart({});
+    if (m_eventEmitter == nullptr) {
+        return;
     }
+    m_eventEmitter->onLoadEnd({});
 }
 
-void BlurhashViewComponentInstance::onError(int32_t errorCode) {
+void BlurhashViewComponentInstance::onError(int32_t errorCode)
+{
     if (m_eventEmitter) {
-    m_eventEmitter->onLoadError({.message = ""});
+        m_eventEmitter->onLoadError({""});
     }
 }
 
-void BlurhashViewComponentInstance::onLoadStart(SharedConcreteProps const &props) {
+void BlurhashViewComponentInstance::onLoadStart(SharedConcreteProps const &props)
+{
     if (m_eventEmitter) {
-    // RN 0.77: DirectEventHandler<null>
-    m_eventEmitter->onLoadStart({});
+        m_eventEmitter->onLoadStart({props->blurhash,
+            props->decodeWidth, props->decodeHeight, props->decodePunch});
     }
 }
 
-facebook::react::ImageResizeMode BlurhashViewComponentInstance::convertToImageResizeMode(facebook::react::BlurhashViewResizeMode mode) {
+facebook::react::ImageResizeMode BlurhashViewComponentInstance::convertToImageResizeMode(
+    facebook::react::BlurhashViewResizeMode mode)
+{
     switch (mode) {
-    case facebook::react::BlurhashViewResizeMode::Contain:
-        return facebook::react::ImageResizeMode::Contain;
-    case facebook::react::BlurhashViewResizeMode::Cover:
-        return facebook::react::ImageResizeMode::Cover;
-    case facebook::react::BlurhashViewResizeMode::Stretch:
-        return facebook::react::ImageResizeMode::Stretch;
-    case facebook::react::BlurhashViewResizeMode::Center:
-        return facebook::react::ImageResizeMode::Center;
+        case facebook::react::BlurhashViewResizeMode::Contain:
+            return facebook::react::ImageResizeMode::Contain;
+        case facebook::react::BlurhashViewResizeMode::Cover:
+            return facebook::react::ImageResizeMode::Cover;
+        case facebook::react::BlurhashViewResizeMode::Stretch:
+            return facebook::react::ImageResizeMode::Stretch;
+        case facebook::react::BlurhashViewResizeMode::Center:
+            return facebook::react::ImageResizeMode::Center;
     }
-    // Fallback to avoid undefined behavior
-    return facebook::react::ImageResizeMode::Cover;
 }
 } // namespace rnoh

package/harmony/blurhash/src/main/cpp/BlurhashViewComponentInstance.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 BLURHASHVIEWCOMPONENTINSTANCE_H
+#define BLURHASHVIEWCOMPONENTINSTANCE_H
 #pragma once
 
 #include "EventEmitters.h"
@@ -13,15 +14,16 @@
 #include "RNOH/arkui/ImageNode.h"
 
 namespace rnoh {
-class BlurhashViewComponentInstance : public CppComponentInstance<facebook::react::BlurhashViewShadowNode>, public BlurhashNodeDelegate {
+class BlurhashViewComponentInstance : public CppComponentInstance<
+    facebook::react::BlurhashViewShadowNode>, public BlurhashNodeDelegate {
 private:
     BlurhashNode m_imageNode;
     std::string m_uri;
 
-    std::string decodeImageByBlurhash(std::string const &blurhash, int const &width, int const &height, float const &punch);
-
+    std::string decodeImageByBlurhash(std::string const &blurhash,
+        int const &width, int const &height, float const &punch);
 public:
-    BlurhashViewComponentInstance(Context context);
+    explicit BlurhashViewComponentInstance(Context context);
     void onPropsChanged(SharedConcreteProps const &props) override;
     void onComplete() override;
     void onLoadStart(SharedConcreteProps const &props);
@@ -32,3 +34,4 @@ public:
     BlurhashNode &getLocalRootArkUINode() override;
 };
 } // namespace rnoh
+#endif

package/harmony/blurhash/src/main/cpp/BlurhashViewJSIBinder.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 BLURHASHVIEWJSIBINDER_H
+#define BLURHASHVIEWJSIBINDER_H
 #pragma once
 
 #include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
@@ -11,7 +12,8 @@
 namespace rnoh {
 class BlurhashViewJSIBinder : public ViewComponentJSIBinder {
 protected:
-    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override
+    {
         auto object = ViewComponentJSIBinder::createNativeProps(rt);
         object.setProperty(rt, "imgUri", true);
         object.setProperty(rt, "blurhash", true);
@@ -23,12 +25,14 @@ protected:
         return object;
     }
 
-    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override
+    {
         facebook::jsi::Object events(rt);
-        events.setProperty(rt, "topLoadStart", createDirectEvent(rt, "onLoadStart"));
-        events.setProperty(rt, "topLoadEnd", createDirectEvent(rt, "onLoadEnd"));
-        events.setProperty(rt, "topLoadError", createDirectEvent(rt, "onLoadError"));
+        events.setProperty(rt, "topOnLoadStart", createDirectEvent(rt, "onLoadStart"));
+        events.setProperty(rt, "topOnLoadEnd", createDirectEvent(rt, "onLoadEnd"));
+        events.setProperty(rt, "topOnLoadError", createDirectEvent(rt, "onLoadError"));
         return events;
     }
 };
-} // namespace rnoh
+} // namespace rnoh
+#endif

package/harmony/blurhash/src/main/cpp/ComponentDescriptors.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 COMPONENTDESCRIPTORS_H
+#define COMPONENTDESCRIPTORS_H
 #pragma once
 
 #include "ShadowNodes.h"
@@ -15,4 +16,5 @@ namespace react {
 using BlurhashViewComponentDescriptor = ConcreteComponentDescriptor<BlurhashViewShadowNode>;
 
 } // namespace react
-} // namespace facebook
+} // namespace facebook
+#endif

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

@@ -10,27 +10,28 @@
 namespace facebook {
 namespace react {
 
-void BlurhashViewEventEmitter::onLoadError(OnLoadError event) const {
-    dispatchEvent("LoadError", [event = std::move(event)](jsi::Runtime &runtime) {
+void BlurhashViewEventEmitter::onLoadError(OnLoadError event) const
+{
+    dispatchEvent("onLoadError", [event = std::move(event)](jsi::Runtime &runtime) {
         auto payload = jsi::Object(runtime);
         payload.setProperty(runtime, "message", event.message);
         return payload;
     });
 }
 
-void BlurhashViewEventEmitter::onLoadEnd(OnLoadEnd event) const {
-    dispatchEvent("LoadEnd", [](jsi::Runtime &runtime) {
+void BlurhashViewEventEmitter::onLoadEnd(OnLoadEnd event) const
+{
+    dispatchEvent("onLoadEnd", [](jsi::Runtime &runtime) {
         auto payload = jsi::Object(runtime);
         return payload;
     });
 }
-void BlurhashViewEventEmitter::onLoadStart(OnLoadStart event) const {
-    dispatchEvent("LoadStart", [](jsi::Runtime &runtime) {
+void BlurhashViewEventEmitter::onLoadStart(OnLoadStart event) const
+{
+    dispatchEvent("onLoadStart", [](jsi::Runtime &runtime) {
         auto payload = jsi::Object(runtime);
         return payload;
     });
 }
-
-
 } // namespace react
 } // namespace facebook

package/harmony/blurhash/src/main/cpp/EventEmitters.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_EVENTEMITTERS_H
+#define BLURHASH_EVENTEMITTERS_H
 #pragma once
 
 #include <react/renderer/components/view/ViewEventEmitter.h>
@@ -15,7 +16,6 @@ namespace react {
 class JSI_EXPORT BlurhashViewEventEmitter : public ViewEventEmitter {
 public:
     using ViewEventEmitter::ViewEventEmitter;
-
     struct OnLoadStart {
         std::string blurhash;
         int decodeWidth;
@@ -35,6 +35,6 @@ public:
 
     void onLoadStart(OnLoadStart value) const;
 };
-
 } // namespace react
-} // namespace facebook
+} // namespace facebook
+#endif

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

@@ -11,15 +11,16 @@
 namespace facebook {
 namespace react {
 
-BlurhashViewProps::BlurhashViewProps(const PropsParserContext &context, const BlurhashViewProps &sourceProps, const RawProps &rawProps)
-    : ViewProps(context, sourceProps, rawProps), 
-      imgUri(convertRawProp(context, rawProps, "imgUri", sourceProps.imgUri, {})),
-      blurhash(convertRawProp(context, rawProps, "blurhash", sourceProps.blurhash, {})),
-      decodeWidth(convertRawProp(context, rawProps, "decodeWidth", sourceProps.decodeWidth, {})),
-      decodeHeight(convertRawProp(context, rawProps, "decodeHeight", sourceProps.decodeHeight, {})),
-      decodePunch(convertRawProp(context, rawProps, "decodePunch", sourceProps.decodePunch, {})),
-      decodeAsync(convertRawProp(context, rawProps, "decodeAsync", sourceProps.decodeAsync, {})),
-      resizeMode(convertRawProp(context, rawProps, "resizeMode", sourceProps.resizeMode, {facebook::react::BlurhashViewResizeMode::Cover})) {}
-
+BlurhashViewProps::BlurhashViewProps(const PropsParserContext &context,
+    const BlurhashViewProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+    imgUri(convertRawProp(context, rawProps, "imgUri", sourceProps.imgUri, {})),
+    blurhash(convertRawProp(context, rawProps, "blurhash", sourceProps.blurhash, {})),
+    decodeWidth(convertRawProp(context, rawProps, "decodeWidth", sourceProps.decodeWidth, {})),
+    decodeHeight(convertRawProp(context, rawProps, "decodeHeight", sourceProps.decodeHeight, {})),
+    decodePunch(convertRawProp(context, rawProps, "decodePunch", sourceProps.decodePunch, {})),
+    decodeAsync(convertRawProp(context, rawProps, "decodeAsync", sourceProps.decodeAsync, {})),
+    resizeMode(convertRawProp(context, rawProps, "resizeMode", sourceProps.resizeMode,
+        {facebook::react::BlurhashViewResizeMode::Cover})) {}
 } // namespace react
 } // namespace facebook

package/harmony/blurhash/src/main/cpp/Props.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_PROPS_H
+#define BLURHASH_PROPS_H
 #pragma once
 
 #include <jsi/jsi.h>
@@ -18,7 +19,9 @@ namespace react {
 
 enum class BlurhashViewResizeMode { Contain, Cover, Stretch, Center };
 
-static inline void fromRawValue(const PropsParserContext &context, const RawValue &value, BlurhashViewResizeMode &result) {
+inline void fromRawValue(const PropsParserContext &context,
+    const RawValue &value, BlurhashViewResizeMode &result)
+{
     auto string = (std::string)value;
     if (string == "contain") {
         result = BlurhashViewResizeMode::Contain;
@@ -36,19 +39,20 @@ static inline void fromRawValue(const PropsParserContext &context, const RawValu
         result = BlurhashViewResizeMode::Center;
         return;
     }
-    abort();
+    throw std::runtime_error("Invalid display type");
 }
 
-static inline std::string toString(const BlurhashViewResizeMode &value) {
+inline std::string toString(const BlurhashViewResizeMode &value)
+{
     switch (value) {
-    case BlurhashViewResizeMode::Contain:
-        return "contain";
-    case BlurhashViewResizeMode::Cover:
-        return "cover";
-    case BlurhashViewResizeMode::Stretch:
-        return "stretch";
-    case BlurhashViewResizeMode::Center:
-        return "center";
+        case BlurhashViewResizeMode::Contain:
+            return "contain";
+        case BlurhashViewResizeMode::Cover:
+            return "cover";
+        case BlurhashViewResizeMode::Stretch:
+            return "stretch";
+        case BlurhashViewResizeMode::Center:
+            return "center";
     }
 }
 
@@ -57,7 +61,8 @@ enum class decodeWeight { defaltWeight };
 class JSI_EXPORT BlurhashViewProps final : public ViewProps {
 public:
     BlurhashViewProps() = default;
-    BlurhashViewProps(const PropsParserContext &context, const BlurhashViewProps &sourceProps, const RawProps &rawProps);
+    BlurhashViewProps(const PropsParserContext &context,
+        const BlurhashViewProps &sourceProps, const RawProps &rawProps);
 
 #pragma mark - Props
     std::string imgUri{};
@@ -71,3 +76,4 @@ public:
 
 } // namespace react
 } // namespace facebook
+#endif

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

@@ -5,7 +5,7 @@
  */
 
 #include "RNBlurhashTurboModule.h"
-#include "Blurhash.hpp"
+#include "Blurhash.h"
 #include <sstream>
 #include <jsi/jsi.h>
 #include <react/renderer/components/view/ViewProps.h>
@@ -18,25 +18,31 @@ using namespace facebook;
 
 using Object = std::optional<jsi::Object>;
 
-static jsi::Value __hostFunction_RNBlurhashInstallModule_createBlurhashFromImage(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args,
-                                                                                 size_t count) {
-    
+static jsi::Value hostFunction_RNBlurhashInstallModule_createBlurhashFromImage(jsi::Runtime &rt,
+    react::TurboModule &turboModule, const jsi::Value *args,
+    size_t count)
+{
     return static_cast<ArkTSTurboModule &>(turboModule).callAsync(rt, "createBlurhashFromImage", args, count);
 }
 
-
-void RNBlurhashTurboModule::clearCosineCache() {
+void RNBlurhashTurboModule::clearCosineCache()
+{
     ::blurhash::clearCache();
     return;
 }
 
-static jsi::Value __hostFunction_RNBlurhashInstallModule_clearCosineCache(jsi::Runtime &rt, react::TurboModule &turboModule, const jsi::Value *args, size_t count) {
+static jsi::Value hostFunction_RNBlurhashInstallModule_clearCosineCache(jsi::Runtime &rt,
+    react::TurboModule &turboModule, const jsi::Value *args, size_t count)
+{
     static_cast<RNBlurhashTurboModule *>(&turboModule)->clearCosineCache();
     return jsi::Value::undefined();
 };
 
 
-RNBlurhashTurboModule::RNBlurhashTurboModule(const ArkTSTurboModule::Context ctx, const std::string name) : ArkTSTurboModule(ctx, name) {
-    methodMap_["clearCosineCache"] = MethodMetadata{0, __hostFunction_RNBlurhashInstallModule_clearCosineCache};
-    methodMap_["createBlurhashFromImage"] = MethodMetadata{4, __hostFunction_RNBlurhashInstallModule_createBlurhashFromImage};
+RNBlurhashTurboModule::RNBlurhashTurboModule(const ArkTSTurboModule::Context ctx,
+    const std::string name) : ArkTSTurboModule(ctx, name)
+{
+    methodMap_["clearCosineCache"] = MethodMetadata{0, hostFunction_RNBlurhashInstallModule_clearCosineCache};
+    methodMap_["createBlurhashFromImage"] = MethodMetadata{
+        4, hostFunction_RNBlurhashInstallModule_createBlurhashFromImage};
 }

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

@@ -3,17 +3,17 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
+#ifndef RNBLURHASHTURBOMODULE_H
+#define RNBLURHASHTURBOMODULE_H
 #pragma once
 
 #include <ReactCommon/TurboModule.h>
 #include "RNOH/ArkTSTurboModule.h"
 namespace rnoh {
-
 class JSI_EXPORT RNBlurhashTurboModule : public ArkTSTurboModule {
 public:
     RNBlurhashTurboModule(const ArkTSTurboModule::Context ctx, const std::string name);
-
     void clearCosineCache();
-
 };
 } // namespace rnoh
+#endif

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

@@ -8,8 +8,7 @@
 
 namespace facebook {
 namespace react {
-
-extern const char BlurhashViewComponentName[] = "BlurhashView";
+const char BlurhashViewComponentName[] = "BlurhashView";
 
 } // namespace react
 } // namespace facebook

package/harmony/blurhash/src/main/cpp/ShadowNodes.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_SHADOWNODES_H
+#define BLURHASH_SHADOWNODES_H
 #pragma once
 #include "Props.h"
 #include "EventEmitters.h"
@@ -13,8 +14,7 @@
 namespace facebook {
 namespace react {
 
-JSI_EXPORT extern const char BlurhashViewComponentName[];
-
+JSI_EXPORT extern const char BlurhashViewComponentName[32];
 /*
  * `ShadowNode` for <BlurhashView> component.
  */
@@ -22,6 +22,6 @@ using BlurhashViewShadowNode = ConcreteViewShadowNode<
     BlurhashViewComponentName,
     BlurhashViewProps,
     BlurhashViewEventEmitter>;
-
 } // namespace react
-} // namespace facebook
+} // namespace facebook
+#endif

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

@@ -9,7 +9,8 @@
 
 template <typename T> void SparseArray<T>::set(int key, const T &value) { data[key] = value; }
 
-template <typename T> T SparseArray<T>::get(int key) const {
+template <typename T> T SparseArray<T>::get(int key) const
+{
     auto it = data.find(key);
     if (it != data.end()) {
         return it->second;
@@ -21,8 +22,10 @@ template <typename T> void SparseArray<T>::remove(int key) { data.erase(key); }
 
 template <typename T> void SparseArray<T>::clear() { data.clear(); }
 
-template <typename T> bool SparseArray<T>::containsKey(int key) const { return data.find(key) != data.end(); }
-
+template <typename T> bool SparseArray<T>::containsKey(int key) const
+{
+    return data.find(key) != data.end();
+}
 // 显式实例化模板类
 template class SparseArray<std::vector<double>>;
-template class SparseArray<std::vector<int>>;
+template class SparseArray<std::vector<int>>;

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

@@ -4,8 +4,8 @@
  * found in the LICENSE file.
  */
 
-#ifndef SPARSEARRAY_H
-#define SPARSEARRAY_H
+#ifndef BLURHASH_SPARSEARRAY_H
+#define BLURHASH_SPARSEARRAY_H
 
 #include <unordered_map>
 #include <vector>

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

@@ -23,19 +23,18 @@
  */
 
 #include "RNOH/ArkJS.h"
-#include "Blurhash.hpp"
+#include "Blurhash.h"
 #include "napi/native_api.h"
 
 
-static napi_value getEncode(napi_env env, napi_callback_info info){
+static napi_value getEncode(napi_env env, napi_callback_info info)
+{
     ArkJS arkJs(env);
     auto args = arkJs.getCallbackArgs(info, 3);
     std::string filename = arkJs.getString(args[0]);
     int components_x = arkJs.getInteger(args[1]);
     int components_y = arkJs.getInteger(args[2]);
-    
-    std::string blurhashcode = blurhash::encode(filename.c_str(),components_x,components_y);
-    
+    std::string blurhashcode = blurhash::encode(filename.c_str(), components_x, components_y);
     napi_value val;
     napi_create_string_utf8(env, blurhashcode.c_str(), blurhashcode.size(), &val);
     return val;

package/harmony/blurhash/src/main/ets/{BlurhashPackage.ts → BlurhashPackage.ets}

@@ -32,6 +32,7 @@ import type {
 import { RNBlurhashModule } from './BlurhashTurboModule';
 import { BlurhashModule } from './TMSpecs'
 import { BlurhashView} from './RNCSpecs'
+import { RNOHPackage } from '@rnoh/react-native-openharmony'
 
 class BlurhashTurboModulesFactory extends TurboModulesFactory {
   createTurboModule(name: string): TurboModule | null {
@@ -46,13 +47,13 @@ class BlurhashTurboModulesFactory extends TurboModulesFactory {
   }
 }
 
-export class BlurhashPackage extends RNPackage {
+export class BlurhashPackage extends RNOHPackage {
   createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
     return new BlurhashTurboModulesFactory(ctx);
   }
   createDescriptorWrapperFactoryByDescriptorType(ctx: DescriptorWrapperFactoryByDescriptorTypeCtx): DescriptorWrapperFactoryByDescriptorType {
     return {
-      [BlurhashView.NAME]: (ctx) => new BlurhashView.DescriptorWrapper(ctx.descriptor)
+      "BlurhashView": (ctx) => new BlurhashView.DescriptorWrapper(ctx.descriptor)
     }
   }
 }

package/harmony/blurhash/{ts.ts → ts.ets}

@@ -22,5 +22,5 @@
  * SOFTWARE.
  */
 
-export * from "./src/main/ets/BlurhashPackage"
+export * from "./src/main/ets/BlurhashPackage.ets"
 export * from "./src/main/ets/BlurhashTurboModule"