react-native-update 10.39.0 → 10.40.0-beta.0

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

@@ -1,142 +1,96 @@
-
 #include "PushyTurboModule.h"
 
-using namespace rnoh;
 using namespace facebook;
+using namespace rnoh;
 
-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));
-    }
-
-
+namespace {
 
-static jsi::Value _hostFunction_PushyTurboModule_addListener(
+jsi::Value CallSync(
     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(
+    react::TurboModule &turboModule,
+    const char *methodName,
+    const jsi::Value *args,
+    size_t count) {
+  return jsi::Value(
+      static_cast<ArkTSTurboModule &>(turboModule).call(
+          rt, methodName, args, count));
+}
+
+jsi::Value CallAsync(
     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};
-}
+    react::TurboModule &turboModule,
+    const char *methodName,
+    const jsi::Value *args,
+    size_t count) {
+  return jsi::Value(
+      static_cast<ArkTSTurboModule &>(turboModule).callAsync(
+          rt, methodName, args, count));
+}
+
+#define PUSHY_SYNC_METHOD(method_name)                                   \
+  static jsi::Value HostFunction_##method_name(                          \
+      jsi::Runtime &rt,                                                  \
+      react::TurboModule &turboModule,                                   \
+      const jsi::Value *args,                                            \
+      size_t count) {                                                    \
+    return CallSync(rt, turboModule, #method_name, args, count);         \
+  }
+
+#define PUSHY_ASYNC_METHOD(method_name)                                  \
+  static jsi::Value HostFunction_##method_name(                          \
+      jsi::Runtime &rt,                                                  \
+      react::TurboModule &turboModule,                                   \
+      const jsi::Value *args,                                            \
+      size_t count) {                                                    \
+    return CallAsync(rt, turboModule, #method_name, args, count);        \
+  }
+
+PUSHY_SYNC_METHOD(getConstants)
+PUSHY_SYNC_METHOD(setLocalHashInfo)
+PUSHY_SYNC_METHOD(getLocalHashInfo)
+PUSHY_SYNC_METHOD(setUuid)
+PUSHY_SYNC_METHOD(setNeedUpdate)
+PUSHY_SYNC_METHOD(markSuccess)
+PUSHY_SYNC_METHOD(addListener)
+PUSHY_SYNC_METHOD(removeListeners)
+
+PUSHY_ASYNC_METHOD(reloadUpdate)
+PUSHY_ASYNC_METHOD(restartApp)
+PUSHY_ASYNC_METHOD(downloadPatchFromPpk)
+PUSHY_ASYNC_METHOD(downloadPatchFromPackage)
+PUSHY_ASYNC_METHOD(downloadFullUpdate)
+PUSHY_ASYNC_METHOD(downloadAndInstallApk)
+
+#undef PUSHY_SYNC_METHOD
+#undef PUSHY_ASYNC_METHOD
+
+} // namespace
+
+PushyTurboModule::PushyTurboModule(
+    const ArkTSTurboModule::Context ctx,
+    const std::string name)
+    : ArkTSTurboModule(ctx, name) {
+  const auto registerMethod =
+      [this](const std::string &methodName,
+             size_t argCount,
+             auto hostFunction) {
+        methodMap_[methodName] = MethodMetadata{argCount, hostFunction};
+      };
+
+  registerMethod("getConstants", 0, HostFunction_getConstants);
+  registerMethod("setLocalHashInfo", 2, HostFunction_setLocalHashInfo);
+  registerMethod("getLocalHashInfo", 1, HostFunction_getLocalHashInfo);
+  registerMethod("setUuid", 1, HostFunction_setUuid);
+  registerMethod("reloadUpdate", 1, HostFunction_reloadUpdate);
+  registerMethod("restartApp", 0, HostFunction_restartApp);
+  registerMethod("setNeedUpdate", 1, HostFunction_setNeedUpdate);
+  registerMethod("markSuccess", 0, HostFunction_markSuccess);
+  registerMethod("downloadPatchFromPpk", 1, HostFunction_downloadPatchFromPpk);
+  registerMethod(
+      "downloadPatchFromPackage", 1, HostFunction_downloadPatchFromPackage);
+  registerMethod("downloadFullUpdate", 1, HostFunction_downloadFullUpdate);
+  registerMethod(
+      "downloadAndInstallApk", 1, HostFunction_downloadAndInstallApk);
+  registerMethod("addListener", 1, HostFunction_addListener);
+  registerMethod("removeListeners", 1, HostFunction_removeListeners);
+}

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

@@ -22,17 +22,17 @@
  * SOFTWARE.
  */
 
-#ifndef GEO_LOCATION_TURBOMODULE_H
-#define GEO_LOCATION_TURBOMODULE_H
+#ifndef PUSHY_TURBOMODULE_H
+#define PUSHY_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);
+ public:
+  PushyTurboModule(const ArkTSTurboModule::Context ctx, const std::string name);
 };
 } // namespace rnoh
 
-#endif
+#endif

package/harmony/pushy/src/main/ets/DownloadTaskParams.ts

@@ -9,11 +9,11 @@ export class DownloadTaskParams {
   static readonly TASK_TYPE_PATCH_FROM_PPK: number = 3; // 从PPK补丁
   static readonly TASK_TYPE_PLAIN_DOWNLOAD: number = 4; // 普通下载
 
-  type: number; // 任务类型
-  url: string; // 下载URL
-  hash: string; // 文件哈希值
-  originHash: string; // 原始文件哈希值
-  targetFile: string; // 目标文件路径
-  unzipDirectory: string; // 解压目录路径
-  originDirectory: string; // 原始文件目录路径
+  type: number = DownloadTaskParams.TASK_TYPE_CLEANUP; // 任务类型
+  url: string = ''; // 下载URL
+  hash: string = ''; // 文件哈希值
+  originHash: string = ''; // 原始文件哈希值
+  targetFile: string = ''; // 目标文件路径
+  unzipDirectory: string = ''; // 解压目录路径
+  originDirectory: string = ''; // 原始文件目录路径
 }

package/harmony/pushy/src/main/ets/PushyPackage.ets

@@ -1,16 +1,10 @@
 import {
   RNOHPackage,
-  UITurboModule,
-  UITurboModuleContext,
 } from '@rnoh/react-native-openharmony';
-import { PushyTurboModule } from './PushyTurboModule';
+import { createPushyTurboModuleFactoryMap } from './PushyPackageFactory';
 
 export class PushyPackage extends RNOHPackage {
-  override getUITurboModuleFactoryByNameMap(): Map<
-    string,
-    (ctx: UITurboModuleContext) => UITurboModule | null
-  > {
-    return new Map<string, (ctx: UITurboModuleContext) => UITurboModule>()
-      .set(PushyTurboModule.NAME, (ctx) => new PushyTurboModule(ctx));
+  override getUITurboModuleFactoryByNameMap() {
+    return createPushyTurboModuleFactoryMap();
   }
 }

package/harmony/pushy/src/main/ets/PushyPackageCompat.ts

@@ -1,16 +1,10 @@
 import {
   RNPackage,
-  UITurboModule,
-  UITurboModuleContext,
 } from '@rnoh/react-native-openharmony/ts';
-import { PushyTurboModule } from './PushyTurboModule';
+import { createPushyTurboModuleFactoryMap } from './PushyPackageFactory';
 
 export class PushyPackage extends RNPackage {
-  override getUITurboModuleFactoryByNameMap(): Map<
-    string,
-    (ctx: UITurboModuleContext) => UITurboModule | null
-  > {
-    return new Map<string, (ctx: UITurboModuleContext) => UITurboModule>()
-      .set(PushyTurboModule.NAME, (ctx) => new PushyTurboModule(ctx));
+  override getUITurboModuleFactoryByNameMap() {
+    return createPushyTurboModuleFactoryMap();
   }
 }

package/harmony/pushy/src/main/ets/PushyPackageFactory.ts

@@ -0,0 +1,14 @@
+import {
+  UITurboModule,
+  UITurboModuleContext,
+} from '@rnoh/react-native-openharmony/ts';
+import { PushyTurboModule } from './PushyTurboModule';
+
+export function createPushyTurboModuleFactoryMap(): Map<
+  string,
+  (ctx: UITurboModuleContext) => UITurboModule | null
+> {
+  return new Map<string, (ctx: UITurboModuleContext) => UITurboModule | null>([
+    [PushyTurboModule.NAME, (ctx) => new PushyTurboModule(ctx)],
+  ]);
+}

package/harmony/pushy/src/main/ets/PushyTurboModule.ts

@@ -5,7 +5,6 @@ import {
 import common from '@ohos.app.ability.common';
 import { bundleManager } from '@kit.AbilityKit';
 import logger from './Logger';
-import { UpdateModuleImpl } from './UpdateModuleImpl';
 import { UpdateContext } from './UpdateContext';
 import { EventHub } from './EventHub';
 import { util } from '@kit.ArkTS';
@@ -26,29 +25,78 @@ export class PushyTurboModule extends UITurboModule {
     EventHub.getInstance().setRNInstance(ctx.rnInstance);
   }
 
-  getConstants(): Object {
-    logger.debug(TAG, ',call getConstants');
-    const context = this.mUiCtx;
-    let bundleFlags =
-      bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION;
-    let packageVersion = '';
+  private getBundleFlags(): bundleManager.BundleFlag {
+    return bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION;
+  }
+
+  private getErrorMessage(error: any): string {
+    if (error && typeof error === 'object' && 'message' in error) {
+      return String(error.message);
+    }
+    return String(error);
+  }
+
+  private getPackageVersion(): string {
     try {
-      const bundleInfo = bundleManager.getBundleInfoForSelfSync(bundleFlags);
-      packageVersion = bundleInfo?.versionName || 'Unknown';
+      const bundleInfo = bundleManager.getBundleInfoForSelfSync(
+        this.getBundleFlags(),
+      );
+      return bundleInfo?.versionName || 'Unknown';
     } catch (error) {
       console.error('Failed to get bundle info:', error);
+      return '';
     }
-    let buildTime = '';
+  }
+
+  private getBuildTime(): string {
     try {
-      const resourceManager = this.mUiCtx.resourceManager;
-      const content = resourceManager.getRawFileContentSync('meta.json');
+      const content = this.mUiCtx.resourceManager.getRawFileContentSync(
+        'meta.json',
+      );
       const metaData = JSON.parse(
         new util.TextDecoder().decodeToString(content),
-      );
+      ) as Record<string, string | number | boolean | null | undefined>;
       if (metaData.pushy_build_time) {
-        buildTime = String(metaData.pushy_build_time);
+        return String(metaData.pushy_build_time);
       }
     } catch {}
+    return '';
+  }
+
+  private requireHash(hash: string, methodName: string): string {
+    if (!hash) {
+      throw Error(`${methodName}: empty hash`);
+    }
+    return hash;
+  }
+
+  private validateHashInfo(info: string): void {
+    try {
+      const parsed = JSON.parse(info);
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw Error('invalid json string');
+      }
+    } catch {
+      throw Error('invalid json string');
+    }
+  }
+
+  private async restartAbility(): Promise<void> {
+    const bundleInfo = await bundleManager.getBundleInfoForSelf(
+      this.getBundleFlags(),
+    );
+    const want = {
+      bundleName: bundleInfo.name,
+      abilityName: this.mUiCtx.abilityInfo?.name,
+    };
+    await this.mUiCtx.terminateSelf();
+    await this.mUiCtx.startAbility(want);
+  }
+
+  getConstants(): Object {
+    logger.debug(TAG, ',call getConstants');
+    const packageVersion = this.getPackageVersion();
+    const buildTime = this.getBuildTime();
     this.context.syncStateWithBinaryVersion(packageVersion, buildTime);
 
     const currentVersion = this.context.getCurrentVersion();
@@ -65,7 +113,7 @@ export class PushyTurboModule extends UITurboModule {
     }
 
     return {
-      downloadRootDir: `${context.filesDir}/_update`,
+      downloadRootDir: `${this.mUiCtx.filesDir}/_update`,
       currentVersionInfo,
       packageVersion,
       currentVersion,
@@ -79,31 +127,67 @@ export class PushyTurboModule extends UITurboModule {
 
   setLocalHashInfo(hash: string, info: string): boolean {
     logger.debug(TAG, ',call setLocalHashInfo');
-    return UpdateModuleImpl.setLocalHashInfo(this.context, hash, info);
+    this.validateHashInfo(info);
+    this.context.setKv(`hash_${hash}`, info);
+    return true;
   }
 
   getLocalHashInfo(hash: string): string {
-    return UpdateModuleImpl.getLocalHashInfo(this.context, hash);
+    const value = this.context.getKv(`hash_${hash}`);
+    this.validateHashInfo(value);
+    return value;
   }
 
   async setUuid(uuid: string): Promise<void> {
     logger.debug(TAG, ',call setUuid');
-    return UpdateModuleImpl.setUuid(this.context, uuid);
+    this.context.setKv('uuid', uuid);
   }
 
   async reloadUpdate(options: { hash: string }): Promise<void> {
     logger.debug(TAG, ',call reloadUpdate');
-    return UpdateModuleImpl.reloadUpdate(this.context, this.mUiCtx, options);
+    const hash = this.requireHash(options.hash, 'reloadUpdate');
+
+    try {
+      this.context.switchVersion(hash);
+      await this.restartAbility();
+    } catch (error) {
+      logger.error(TAG, `reloadUpdate failed: ${this.getErrorMessage(error)}`);
+      throw Error(`switchVersion failed ${this.getErrorMessage(error)}`);
+    }
+  }
+
+  async restartApp(): Promise<void> {
+    logger.debug(TAG, ',call restartApp');
+    try {
+      await this.restartAbility();
+    } catch (error) {
+      logger.error(TAG, `restartApp failed: ${this.getErrorMessage(error)}`);
+      throw Error(`restartApp failed ${this.getErrorMessage(error)}`);
+    }
   }
 
   async setNeedUpdate(options: { hash: string }): Promise<boolean> {
     logger.debug(TAG, ',call setNeedUpdate');
-    return UpdateModuleImpl.setNeedUpdate(this.context, options);
+    const hash = this.requireHash(options.hash, 'setNeedUpdate');
+
+    try {
+      this.context.switchVersion(hash);
+      return true;
+    } catch (error) {
+      logger.error(TAG, `setNeedUpdate failed: ${this.getErrorMessage(error)}`);
+      throw Error(`switchVersionLater failed: ${this.getErrorMessage(error)}`);
+    }
   }
 
   async markSuccess(): Promise<boolean> {
     logger.debug(TAG, ',call markSuccess');
-    return UpdateModuleImpl.markSuccess(this.context);
+    try {
+      this.context.markSuccess();
+      return true;
+    } catch (error) {
+      logger.error(TAG, `markSuccess failed: ${this.getErrorMessage(error)}`);
+      throw error;
+    }
   }
 
   async downloadPatchFromPpk(options: {
@@ -112,7 +196,11 @@ export class PushyTurboModule extends UITurboModule {
     originHash: string;
   }): Promise<void> {
     logger.debug(TAG, ',call downloadPatchFromPpk');
-    return UpdateModuleImpl.downloadPatchFromPpk(this.context, options);
+    return this.context.downloadPatchFromPpk(
+      options.updateUrl,
+      options.hash,
+      options.originHash,
+    );
   }
 
   async downloadPatchFromPackage(options: {
@@ -120,7 +208,10 @@ export class PushyTurboModule extends UITurboModule {
     hash: string;
   }): Promise<void> {
     logger.debug(TAG, ',call downloadPatchFromPackage');
-    return UpdateModuleImpl.downloadPatchFromPackage(this.context, options);
+    return this.context.downloadPatchFromPackage(
+      options.updateUrl,
+      options.hash,
+    );
   }
 
   async downloadFullUpdate(options: {
@@ -128,7 +219,16 @@ export class PushyTurboModule extends UITurboModule {
     hash: string;
   }): Promise<void> {
     logger.debug(TAG, ',call downloadFullUpdate');
-    return UpdateModuleImpl.downloadFullUpdate(this.context, options);
+    return this.context.downloadFullUpdate(options.updateUrl, options.hash);
+  }
+
+  async downloadAndInstallApk(_options: {
+    url: string;
+    target: string;
+    hash: string;
+  }): Promise<void> {
+    logger.debug(TAG, ',call downloadAndInstallApk');
+    throw Error('downloadAndInstallApk is only supported on Android');
   }
 
   addListener(_eventName: string): void {