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

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

@@ -3,8 +3,9 @@
  * Use of this source code is governed by a MIT license that can be
  * found in the LICENSE file.
  */
+
 #include "BlurhashViewComponentInstance.h"
-#include "Blurhash.h"
+#include "Blurhash.hpp"
 #include "Props.h"
 #include <filemanagement/file_uri/oh_file_uri.h>
 #include "RNBlurhashTurboModule.h"
@@ -12,100 +13,125 @@
 #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 == "") {
-        m_eventEmitter->onLoadError({"The provided Blurhash string must not be null!"});
-    };
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "The provided Blurhash string must not be empty!"});
+        return;
+    }
     if (props->decodeWidth <= 0) {
-        m_eventEmitter->onLoadError({"decodeWidth must be greater than 0!"});
-    };
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodeWidth must be greater than 0!"});
+        return;
+    }
     if (props->decodeHeight <= 0) {
-        m_eventEmitter->onLoadError({"decodeHeight must be greater than 0!"});
-    };
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "decodeHeight must be greater than 0!"});
+        return;
+    }
     if (props->decodePunch <= 0) {
-        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);
+        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/rn_image_cache/" + absPath;
+    }
+
+    const char *path = absPath.c_str();
+    unsigned int length = static_cast<unsigned int>(absPath.size());
     char *result = nullptr;
     FileManagement_ErrCode ret = OH_FileUri_GetUriFromPath(path, length, &result);
-    this->getLocalRootArkUINode().setSource(std::string(result));
-    if (result != nullptr) {
-        free(result);
+    if (ret != FileManagement_ErrCode::ERR_OK || result == nullptr) {
+        if (m_eventEmitter) m_eventEmitter->onLoadError({.message = "Failed to convert path to file URI."});
+        return;
     }
+    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 BlurhashViewComponentInstance::decodeImageByBlurhash(const std::string &blurhash, const int &width, const int &height, const float &punch) {
+    std::string expectedName = blurhash + ".bmp";
     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);
-    auto cache = arkTsTurboModule->callSync("getPrefetchResult", {blurhash + ".bmp"});
-    return cache.asString();
+    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;
 }
 
-BlurhashNode &BlurhashViewComponentInstance::getLocalRootArkUINode()
-{
-    return m_imageNode;
-}
+BlurhashNode &BlurhashViewComponentInstance::getLocalRootArkUINode() { return m_imageNode; }
 
-void BlurhashViewComponentInstance::onComplete()
-{
-    m_eventEmitter->onLoadStart({});
-    if (m_eventEmitter == nullptr) {
-        return;
+void BlurhashViewComponentInstance::onComplete() {
+    if (m_eventEmitter) {
+        m_eventEmitter->onLoadStart({});
+        m_eventEmitter->onLoadEnd({});
     }
-    m_eventEmitter->onLoadEnd({});
 }
 
-void BlurhashViewComponentInstance::onError(int32_t errorCode)
-{
+void BlurhashViewComponentInstance::onError(int32_t errorCode) {
     if (m_eventEmitter) {
-        m_eventEmitter->onLoadError({""});
+    m_eventEmitter->onLoadError({.message = ""});
     }
 }
 
-void BlurhashViewComponentInstance::onLoadStart(SharedConcreteProps const &props)
-{
+void BlurhashViewComponentInstance::onLoadStart(SharedConcreteProps const &props) {
     if (m_eventEmitter) {
-        m_eventEmitter->onLoadStart({props->blurhash,
-            props->decodeWidth, props->decodeHeight, props->decodePunch});
+    // RN 0.77: DirectEventHandler<null>
+    m_eventEmitter->onLoadStart({});
     }
 }
 
-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,8 +3,7 @@
  * 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"
@@ -14,16 +13,15 @@
 #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:
-    explicit BlurhashViewComponentInstance(Context context);
+    BlurhashViewComponentInstance(Context context);
     void onPropsChanged(SharedConcreteProps const &props) override;
     void onComplete() override;
     void onLoadStart(SharedConcreteProps const &props);
@@ -34,4 +32,3 @@ public:
     BlurhashNode &getLocalRootArkUINode() override;
 };
 } // namespace rnoh
-#endif

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

@@ -3,8 +3,7 @@
  * 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"
@@ -12,8 +11,7 @@
 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);
@@ -25,14 +23,12 @@ 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, "topOnLoadStart", createDirectEvent(rt, "onLoadStart"));
-        events.setProperty(rt, "topOnLoadEnd", createDirectEvent(rt, "onLoadEnd"));
-        events.setProperty(rt, "topOnLoadError", createDirectEvent(rt, "onLoadError"));
+        events.setProperty(rt, "topLoadStart", createDirectEvent(rt, "onLoadStart"));
+        events.setProperty(rt, "topLoadEnd", createDirectEvent(rt, "onLoadEnd"));
+        events.setProperty(rt, "topLoadError", createDirectEvent(rt, "onLoadError"));
         return events;
     }
 };
-} // namespace rnoh
-#endif
+} // namespace rnoh

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

@@ -3,8 +3,7 @@
  * 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"
@@ -16,5 +15,4 @@ namespace react {
 using BlurhashViewComponentDescriptor = ConcreteComponentDescriptor<BlurhashViewShadowNode>;
 
 } // namespace react
-} // namespace facebook
-#endif
+} // namespace facebook

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

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

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

@@ -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_EVENTEMITTERS_H
-#define BLURHASH_EVENTEMITTERS_H
+
 #pragma once
 
 #include <react/renderer/components/view/ViewEventEmitter.h>
@@ -16,6 +15,7 @@ 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
-#endif
+} // namespace facebook

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

@@ -11,16 +11,15 @@
 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,8 +3,7 @@
  * 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>
@@ -19,9 +18,7 @@ namespace react {
 
 enum class BlurhashViewResizeMode { Contain, Cover, Stretch, Center };
 
-inline void fromRawValue(const PropsParserContext &context,
-    const RawValue &value, BlurhashViewResizeMode &result)
-{
+static inline void fromRawValue(const PropsParserContext &context, const RawValue &value, BlurhashViewResizeMode &result) {
     auto string = (std::string)value;
     if (string == "contain") {
         result = BlurhashViewResizeMode::Contain;
@@ -39,20 +36,19 @@ inline void fromRawValue(const PropsParserContext &context,
         result = BlurhashViewResizeMode::Center;
         return;
     }
-    throw std::runtime_error("Invalid display type");
+    abort();
 }
 
-inline std::string toString(const BlurhashViewResizeMode &value)
-{
+static 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";
     }
 }
 
@@ -61,8 +57,7 @@ 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{};
@@ -76,4 +71,3 @@ public:
 
 } // namespace react
 } // namespace facebook
-#endif

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

@@ -5,7 +5,7 @@
  */
 
 #include "RNBlurhashTurboModule.h"
-#include "Blurhash.h"
+#include "Blurhash.hpp"
 #include <sstream>
 #include <jsi/jsi.h>
 #include <react/renderer/components/view/ViewProps.h>
@@ -18,31 +18,25 @@ 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,7 +8,8 @@
 
 namespace facebook {
 namespace react {
-const char BlurhashViewComponentName[] = "BlurhashView";
+
+extern const char BlurhashViewComponentName[] = "BlurhashView";
 
 } // namespace react
 } // namespace facebook

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

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

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

@@ -9,8 +9,7 @@
 
 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;
@@ -22,10 +21,8 @@ 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 BLURHASH_SPARSEARRAY_H
-#define BLURHASH_SPARSEARRAY_H
+#ifndef SPARSEARRAY_H
+#define SPARSEARRAY_H
 
 #include <unordered_map>
 #include <vector>

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

@@ -23,18 +23,19 @@
  */
 
 #include "RNOH/ArkJS.h"
-#include "Blurhash.h"
+#include "Blurhash.hpp"
 #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 filepath = arkJs.getString(args[0]);
+    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(filepath.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/cpp/types/libblurhash/Index.d.ts

@@ -1 +1 @@
-export const getEncode: (filepath: String, components_x: Number, components_y: Number) => string;
+export const getEncode: (filename: String, components_x: Number, components_y: Number) => string;

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

@@ -32,7 +32,6 @@ 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 {
@@ -47,13 +46,13 @@ class BlurhashTurboModulesFactory extends TurboModulesFactory {
   }
 }
 
-export class BlurhashPackage extends RNOHPackage {
+export class BlurhashPackage extends RNPackage {
   createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
     return new BlurhashTurboModulesFactory(ctx);
   }
   createDescriptorWrapperFactoryByDescriptorType(ctx: DescriptorWrapperFactoryByDescriptorTypeCtx): DescriptorWrapperFactoryByDescriptorType {
     return {
-      "BlurhashView": (ctx) => new BlurhashView.DescriptorWrapper(ctx.descriptor)
+      [BlurhashView.NAME]: (ctx) => new BlurhashView.DescriptorWrapper(ctx.descriptor)
     }
   }
 }

package/harmony/blurhash/src/main/ets/BlurhashTurboModule.ts

@@ -40,7 +40,8 @@ export class RNBlurhashModule extends TurboModule implements BlurhashModule.Spec
     const RemoteImageLoader = this.ctx.rnInstance.getTurboModule<RemoteImageLoader>("ImageLoader");
     await imageLoader.prefetchImage(imageUri)
     const filePath = RemoteImageLoader.getPrefetchResult(imageUri)
-    const blurhashcode = rnKeysCPPLib.getEncode(filePath.replace('file://', ''),componentsX,componentsY)
+    const fileName = filePath.split('/').pop();
+    const blurhashcode = rnKeysCPPLib.getEncode(fileName,componentsX,componentsY)
     return (blurhashcode);
   }