react-native-update 10.38.3 → 10.38.4

package/harmony/pushy/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,70 @@
+cmake_minimum_required(VERSION 3.13)
+project(rnupdate LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(PUSHY_MODULE_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
+set(PUSHY_ABI ${CMAKE_OHOS_ARCH_ABI})
+if(NOT PUSHY_ABI)
+    set(PUSHY_ABI ${OHOS_ARCH})
+endif()
+set(PREBUILT_RNUPDATE_PATH ${PUSHY_MODULE_ROOT}/libs/${PUSHY_ABI}/librnupdate.so)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(REPO_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../)
+set(STAGED_NATIVE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/android-generated)
+set(ANDROID_JNI_DIR ${REPO_ROOT}/android/jni)
+if(NOT EXISTS ${ANDROID_JNI_DIR}/hpatch.c)
+    set(ANDROID_JNI_DIR ${STAGED_NATIVE_DIR}/jni)
+endif()
+set(PATCH_CORE_DIR ${REPO_ROOT}/cpp/patch_core)
+if(NOT EXISTS ${PATCH_CORE_DIR}/patch_core.cpp)
+    set(PATCH_CORE_DIR ${STAGED_NATIVE_DIR}/patch_core)
+endif()
+
+if(EXISTS ${PREBUILT_RNUPDATE_PATH})
+    add_library(rnupdate SHARED IMPORTED GLOBAL)
+    set_target_properties(rnupdate PROPERTIES IMPORTED_LOCATION ${PREBUILT_RNUPDATE_PATH})
+else()
+    # When building the HAR itself, native sources are compiled from the repo checkout.
+    set(HDIFFPATCH_DIR ${ANDROID_JNI_DIR}/HDiffPatch)
+    set(LZMA_DIR ${ANDROID_JNI_DIR}/lzma)
+    set(HDP_SOURCES
+         ${CMAKE_CURRENT_SOURCE_DIR}/pushy.cpp
+         ${PATCH_CORE_DIR}/archive_patch_core.cpp
+         ${PATCH_CORE_DIR}/patch_core.cpp
+         ${PATCH_CORE_DIR}/state_core.cpp
+         ${ANDROID_JNI_DIR}/hpatch.c
+         ${HDIFFPATCH_DIR}/libHDiffPatch/HPatch/patch.c
+         ${HDIFFPATCH_DIR}/file_for_patch.c
+         ${LZMA_DIR}/C/LzmaDec.c
+         ${LZMA_DIR}/C/Lzma2Dec.c
+    )
+
+    add_library(rnupdate SHARED
+        ${HDP_SOURCES}
+    )
+
+    target_include_directories(rnupdate PRIVATE
+         ${CMAKE_CURRENT_SOURCE_DIR}
+         ${PATCH_CORE_DIR}
+         ${ANDROID_JNI_DIR}
+         ${HDIFFPATCH_DIR}
+         ${HDIFFPATCH_DIR}/libHDiffPatch/HPatch
+         ${LZMA_DIR}/C
+    )
+
+    target_link_libraries(rnupdate PUBLIC
+        libace_napi.z.so
+    )
+endif()
+
+if(TARGET rnoh)
+    add_library(rnoh_pushy SHARED
+        ${CMAKE_CURRENT_SOURCE_DIR}/PushyTurboModule.cpp
+    )
+    target_include_directories(rnoh_pushy PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+    target_link_libraries(rnoh_pushy PUBLIC rnoh)
+endif()

package/harmony/pushy/src/main/cpp/PushyPackage.h

@@ -0,0 +1,55 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef GEO_LOCATION_PACKAGE_H
+#define GEO_LOCATION_PACKAGE_H
+
+#include "RNOH/Package.h"
+#include "PushyTurboModule.h"
+
+using namespace rnoh;
+using namespace facebook;
+
+class PushyTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override
+    {
+        if (name == "Pushy") {
+        return std::make_shared<PushyTurboModule>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+
+namespace rnoh {
+class PushyPackage : public Package {
+public:
+    PushyPackage(Package::Context ctx) : Package(ctx){}
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override
+    {
+    return std::make_unique<PushyTurboModuleFactoryDelegate>();
+    }
+};
+} // namespace rnoh
+#endif

package/harmony/pushy/src/main/cpp/PushyTurboModule.cpp

@@ -0,0 +1,142 @@
+
+#include "PushyTurboModule.h"
+
+using namespace rnoh;
+using namespace facebook;
+
+static jsi::Value _hostFunction_PushyTurboModule_getConstants(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"getConstants", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_setLocalHashInfo(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"setLocalHashInfo", args, count));
+    }
+    
+static jsi::Value _hostFunction_PushyTurboModule_getLocalHashInfo(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"getLocalHashInfo", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_setUuid(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"setUuid", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_reloadUpdate(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"reloadUpdate", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_setNeedUpdate(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"setNeedUpdate", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_markSuccess(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"markSuccess", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_downloadPatchFromPpk(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).callAsync(rt,"downloadPatchFromPpk", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_downloadPatchFromPackage(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).callAsync(rt,"downloadPatchFromPackage", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_downloadFullUpdate(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).callAsync(rt,"downloadFullUpdate", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_downloadAndInstallApk(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).callAsync(rt,"downloadAndInstallApk", args, count));
+    }
+
+
+
+static jsi::Value _hostFunction_PushyTurboModule_addListener(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"addListener", args, count));
+    }
+
+static jsi::Value _hostFunction_PushyTurboModule_removeListeners(
+    jsi::Runtime &rt,
+    react::TurboModule & turboModule,
+    const jsi::Value* args,
+    size_t count)
+    {
+        return jsi::Value(static_cast<ArkTSTurboModule &> (turboModule).call(rt,"removeListeners", args, count));
+    }
+
+PushyTurboModule::PushyTurboModule(const ArkTSTurboModule::Context ctx, const std::string name)
+    : ArkTSTurboModule(ctx,name)
+{
+    methodMap_["getConstants"]= MethodMetadata{1, _hostFunction_PushyTurboModule_getConstants};
+    methodMap_["setLocalHashInfo"]= MethodMetadata{2, _hostFunction_PushyTurboModule_setLocalHashInfo};
+    methodMap_["getLocalHashInfo"]= MethodMetadata{3, _hostFunction_PushyTurboModule_getLocalHashInfo};
+    methodMap_["setUuid"]= MethodMetadata{1, _hostFunction_PushyTurboModule_setUuid};
+    methodMap_["reloadUpdate"]= MethodMetadata{0, _hostFunction_PushyTurboModule_reloadUpdate};
+    methodMap_["setNeedUpdate"]= MethodMetadata{0, _hostFunction_PushyTurboModule_setNeedUpdate};
+    methodMap_["markSuccess"]= MethodMetadata{0, _hostFunction_PushyTurboModule_markSuccess};
+    methodMap_["downloadPatchFromPpk"]= MethodMetadata{0, _hostFunction_PushyTurboModule_downloadPatchFromPpk};
+    methodMap_["downloadPatchFromPackage"]= MethodMetadata{0, _hostFunction_PushyTurboModule_downloadPatchFromPackage};
+    methodMap_["downloadFullUpdate"]= MethodMetadata{0, _hostFunction_PushyTurboModule_downloadFullUpdate};
+    methodMap_["downloadAndInstallApk"]= MethodMetadata{0, _hostFunction_PushyTurboModule_downloadAndInstallApk};
+    methodMap_["addListener"]= MethodMetadata{1, _hostFunction_PushyTurboModule_addListener};
+    methodMap_["removeListeners"]= MethodMetadata{1, _hostFunction_PushyTurboModule_removeListeners};
+}

package/harmony/pushy/src/main/cpp/PushyTurboModule.h

@@ -0,0 +1,38 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef GEO_LOCATION_TURBOMODULE_H
+#define GEO_LOCATION_TURBOMODULE_H
+
+#include <ReactCommon/TurboModule.h>
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+class JSI_EXPORT PushyTurboModule : public ArkTSTurboModule {
+    public:
+        PushyTurboModule(const ArkTSTurboModule::Context ctx, const std::string name);
+};
+} // namespace rnoh
+
+#endif

package/harmony/pushy/src/main/cpp/pushy.c

@@ -0,0 +1,117 @@
+#include "pushy.h"
+#include "hpatch.h"
+#include <napi/native_api.h>
+#include <js_native_api.h>
+#include <js_native_api_types.h>
+
+#define _check(v,errInfo) do { \
+    if (!(v)) { \
+        _isError = hpatch_TRUE; \
+        _errInfo = errInfo; \
+        goto _clear; \
+    } \
+} while(0)
+
+napi_value HdiffPatch(napi_env env, napi_callback_info info) {
+    napi_status status;
+    size_t argc = 2;
+    napi_value args[2];
+    hpatch_BOOL _isError = hpatch_FALSE;
+    const char* _errInfo = "";
+
+    // 获取参数
+    status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+    if (status != napi_ok || argc < 2) {
+        napi_throw_error(env, NULL, "Wrong number of arguments");
+        return NULL;
+    }
+
+    // 获取origin buffer
+    bool isTypedArray;
+    status = napi_is_typedarray(env, args[0], &isTypedArray);
+    if (status != napi_ok || !isTypedArray) {
+        napi_throw_error(env, NULL, "First argument must be a TypedArray");
+        return NULL;
+    }
+
+    uint8_t* originPtr;
+    size_t originLength;
+    status = napi_get_typedarray_info(env, args[0], NULL, &originLength, 
+                                     (void**)&originPtr, NULL, NULL);
+    if (status != napi_ok) {
+        napi_throw_error(env, NULL, "Failed to get origin buffer");
+        return NULL;
+    }
+
+    // 获取patch buffer
+    status = napi_is_typedarray(env, args[1], &isTypedArray);
+    if (status != napi_ok || !isTypedArray) {
+        napi_throw_error(env, NULL, "Second argument must be a TypedArray");
+        return NULL;
+    }
+
+    uint8_t* patchPtr;
+    size_t patchLength;
+    status = napi_get_typedarray_info(env, args[1], NULL, &patchLength, 
+                                     (void**)&patchPtr, NULL, NULL);
+    if (status != napi_ok) {
+        napi_throw_error(env, NULL, "Failed to get patch buffer");
+        return NULL;
+    }
+
+    // 执行patch操作
+    hpatch_singleCompressedDiffInfo patInfo;
+    
+    _check(((originLength==0)||originPtr) && patchPtr && (patchLength>0), "Corrupt patch");
+    _check(kHPatch_ok==hpatch_getInfo_by_mem(&patInfo, patchPtr, patchLength), "Error info in hpatch");
+    _check(originLength==patInfo.oldDataSize, "Error oldDataSize in hpatch");
+    size_t newsize = (size_t)patInfo.newDataSize;
+    if (sizeof(size_t)!=sizeof(hpatch_StreamPos_t))
+        _check(newsize==patInfo.newDataSize, "Error newDataSize in hpatch");
+
+    // 创建结果buffer
+    napi_value resultBuffer;
+    uint8_t* outPtr;
+    void* data;
+
+    status = napi_create_arraybuffer(env, newsize, &data, &resultBuffer);
+    if (status != napi_ok) {
+        napi_throw_error(env, NULL, "Failed to create result buffer");
+        return NULL;
+    }
+    outPtr = (uint8_t*)data;
+
+    // 执行patch
+    _check(kHPatch_ok==hpatch_by_mem(originPtr, originLength, outPtr, newsize,
+                                    patchPtr, patchLength, &patInfo), "hpatch");
+    return resultBuffer;
+
+_clear:
+    if (_isError) {
+        napi_throw_error(env, NULL, _errInfo);
+        return NULL;
+    }
+    return NULL;
+}
+
+// 模块初始化
+napi_value Init(napi_env env, napi_value exports) {
+    napi_status status;
+    napi_value fn;
+
+    status = napi_create_function(env, NULL, 0, HdiffPatch, NULL, &fn);
+    if (status != napi_ok) {
+        napi_throw_error(env, NULL, "Unable to wrap native function");
+        return NULL;
+    }
+
+    status = napi_set_named_property(env, exports, "hdiffPatch", fn);
+    if (status != napi_ok) {
+        napi_throw_error(env, NULL, "Unable to populate exports");
+        return NULL;
+    }
+
+    return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)