react-native-update 10.42.3 → 10.42.5

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

@@ -7,7 +7,6 @@ import { bundleManager } from '@kit.AbilityKit';
 import logger from './Logger';
 import { UpdateContext } from './UpdateContext';
 import { EventHub } from './EventHub';
-import { util } from '@kit.ArkTS';
 
 const TAG = 'PushyTurboModule';
 
@@ -47,33 +46,6 @@ export class PushyTurboModule extends UITurboModule {
     return bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION;
   }
 
-  private getPackageVersion(): string {
-    try {
-      const bundleInfo = bundleManager.getBundleInfoForSelfSync(
-        this.getBundleFlags(),
-      );
-      return bundleInfo?.versionName || 'Unknown';
-    } catch (error) {
-      console.error('Failed to get bundle info:', error);
-      return '';
-    }
-  }
-
-  private getBuildTime(): string {
-    try {
-      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) {
-        return String(metaData.pushy_build_time);
-      }
-    } catch {}
-    return '';
-  }
-
   private requireHash(hash: string, methodName: string): string {
     if (!hash) {
       throw Error(`${methodName}: empty hash`);
@@ -95,15 +67,15 @@ export class PushyTurboModule extends UITurboModule {
 
   getConstants(): Object {
     logger.debug(TAG, ',call getConstants');
-    const packageVersion = this.getPackageVersion();
-    const buildTime = this.getBuildTime();
+    const packageVersion = this.context.getPackageVersion();
+    const buildTime = this.context.getBuildTime();
     this.context.syncStateWithBinaryVersion(packageVersion, buildTime);
 
     const currentVersion = this.context.getCurrentVersion();
     const currentVersionInfo = currentVersion
       ? this.context.getKv(`hash_${currentVersion}`)
       : '';
-    const isFirstTime = this.context.isFirstTime();
+    const isFirstTime = this.context.consumeFirstLoadMarker();
     const rolledBackVersion = this.context.rolledBackVersion();
     const uuid = this.context.getKv('uuid');
     const isUsingBundleUrl = this.context.getIsUsingBundleUrl();

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

@@ -3,6 +3,8 @@ import fileIo from '@ohos.file.fs';
 import { DownloadTask } from './DownloadTask';
 import common from '@ohos.app.ability.common';
 import { DownloadTaskParams } from './DownloadTaskParams';
+import { bundleManager } from '@kit.AbilityKit';
+import { util } from '@kit.ArkTS';
 import NativePatchCore, {
   STATE_OP_CLEAR_FIRST_TIME,
   STATE_OP_CLEAR_ROLLBACK_MARK,
@@ -13,12 +15,17 @@ import NativePatchCore, {
   StateCoreResult,
 } from './NativePatchCore';
 
+type FlushablePreferences = preferences.Preferences & {
+  flushSync?: () => void;
+};
+
 export class UpdateContext {
   private context: common.UIAbilityContext;
   private rootDir: string;
   private preferences!: preferences.Preferences;
   private static DEBUG: boolean = false;
   private static isUsingBundleUrl: boolean = false;
+  private static ignoreRollback: boolean = false;
 
   constructor(context: common.UIAbilityContext) {
     this.context = context;
@@ -32,6 +39,10 @@ export class UpdateContext {
       console.error('Failed to create root directory:', e);
     }
     this.initPreferences();
+    this.syncStateWithBinaryVersion(
+      this.getPackageVersion(),
+      this.getBuildTime(),
+    );
   }
 
   private initPreferences() {
@@ -44,6 +55,36 @@ export class UpdateContext {
     }
   }
 
+  private getBundleFlags(): bundleManager.BundleFlag {
+    return bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION;
+  }
+
+  public getPackageVersion(): string {
+    try {
+      const bundleInfo = bundleManager.getBundleInfoForSelfSync(
+        this.getBundleFlags(),
+      );
+      return bundleInfo?.versionName || 'Unknown';
+    } catch (error) {
+      console.error('Failed to get bundle info:', error);
+      return '';
+    }
+  }
+
+  public getBuildTime(): string {
+    try {
+      const content =
+        this.context.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) {
+        return String(metaData.pushy_build_time);
+      }
+    } catch {}
+    return '';
+  }
+
   private readString(key: string): string {
     const value = this.preferences.getSync(key, '') as
       | string
@@ -87,6 +128,20 @@ export class UpdateContext {
     return defaultValue;
   }
 
+  private flushPreferences(reason: string): void {
+    try {
+      const flushablePreferences = this.preferences as FlushablePreferences;
+      if (typeof flushablePreferences.flushSync === 'function') {
+        flushablePreferences.flushSync();
+        return;
+      }
+      throw Error('preferences.flushSync is not available');
+    } catch (error) {
+      console.error(`Failed to flush preferences for ${reason}:`, error);
+      throw error;
+    }
+  }
+
   private putNullableString(key: string, value?: string): void {
     if (value) {
       this.preferences.putSync(key, value);
@@ -127,6 +182,8 @@ export class UpdateContext {
       clearExisting?: boolean;
       removeStaleHash?: boolean;
       cleanUp?: boolean;
+      markFirstLoadMarker?: boolean;
+      clearFirstLoadMarker?: boolean;
     } = {},
   ): void {
     if (options.clearExisting) {
@@ -136,7 +193,13 @@ export class UpdateContext {
     if (options.removeStaleHash && state.staleVersionToDelete) {
       this.preferences.deleteSync(`hash_${state.staleVersionToDelete}`);
     }
-    this.preferences.flush();
+    if (options.markFirstLoadMarker) {
+      this.preferences.putSync('firstLoadMarked', 'true');
+    }
+    if (options.clearFirstLoadMarker) {
+      this.preferences.deleteSync('firstLoadMarked');
+    }
+    this.flushPreferences('persist state');
     if (options.cleanUp) {
       this.cleanUp();
     }
@@ -148,6 +211,7 @@ export class UpdateContext {
     options: {
       removeStaleHash?: boolean;
       cleanUp?: boolean;
+      clearFirstLoadMarker?: boolean;
     } = {},
   ): StateCoreResult {
     const nextState = NativePatchCore.runStateCore(
@@ -190,13 +254,14 @@ export class UpdateContext {
       return;
     }
 
+    UpdateContext.ignoreRollback = false;
     this.cleanUp();
     this.persistState(nextState, { clearExisting: true });
   }
 
   public setKv(key: string, value: string): void {
     this.preferences.putSync(key, value);
-    this.preferences.flush();
+    this.flushPreferences(`set key ${key}`);
   }
 
   public getKv(key: string): string {
@@ -223,7 +288,10 @@ export class UpdateContext {
   }
 
   public clearFirstTime(): void {
-    this.runStateOperation(STATE_OP_CLEAR_FIRST_TIME, '', { cleanUp: true });
+    this.runStateOperation(STATE_OP_CLEAR_FIRST_TIME, '', {
+      cleanUp: true,
+      clearFirstLoadMarker: true,
+    });
   }
 
   public clearRollbackMark(): void {
@@ -306,23 +374,38 @@ export class UpdateContext {
       }
 
       this.runStateOperation(STATE_OP_SWITCH_VERSION, hash);
+      UpdateContext.ignoreRollback = false;
     } catch (e) {
       console.error('Failed to switch version:', e);
       throw e;
     }
   }
 
+  public consumeFirstLoadMarker(): boolean {
+    const marked = this.readString('firstLoadMarked') === 'true';
+    if (marked) {
+      this.preferences.deleteSync('firstLoadMarked');
+      this.flushPreferences('clear first load marker');
+    }
+    return marked;
+  }
+
   public getBundleUrl() {
     UpdateContext.isUsingBundleUrl = true;
     const launchState = NativePatchCore.runStateCore(
       STATE_OP_RESOLVE_LAUNCH,
       this.getStateSnapshot(),
       '',
-      false,
-      false,
+      UpdateContext.ignoreRollback,
+      true,
     );
     if (launchState.didRollback || launchState.consumedFirstTime) {
-      this.persistState(launchState);
+      this.persistState(launchState, {
+        markFirstLoadMarker: launchState.consumedFirstTime,
+      });
+    }
+    if (launchState.consumedFirstTime) {
+      UpdateContext.ignoreRollback = true;
     }
 
     let version = launchState.loadVersion || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.42.3",
+  "version": "10.42.5",
   "description": "react-native hot update",
   "main": "src/index",
   "scripts": {

package/src/client.ts

@@ -28,6 +28,7 @@ import {
 } from './type';
 import {
   assertWeb,
+  computeProgress,
   DEFAULT_FETCH_TIMEOUT_MS,
   emptyObj,
   fetchWithTimeout,
@@ -491,13 +492,19 @@ export class Pushy {
     }
     const patchStartTime = Date.now();
     if (onDownloadProgress) {
+      const wrapProgress = (data: ProgressData) => {
+        onDownloadProgress({
+          ...data,
+          progress: computeProgress(data.received, data.total),
+        });
+      };
       // @ts-expect-error harmony not in existing platforms
       if (Platform.OS === 'harmony') {
         sharedState.progressHandlers[hash] = DeviceEventEmitter.addListener(
           'RCTPushyDownloadProgress',
-          progressData => {
+          (progressData: ProgressData) => {
             if (progressData.hash === hash) {
-              onDownloadProgress(progressData);
+              wrapProgress(progressData);
             }
           },
         );
@@ -505,54 +512,47 @@ export class Pushy {
         sharedState.progressHandlers[hash] =
           pushyNativeEventEmitter.addListener(
             'RCTPushyDownloadProgress',
-            progressData => {
+            (progressData: ProgressData) => {
               if (progressData.hash === hash) {
-                onDownloadProgress(progressData);
+                wrapProgress(progressData);
               }
             },
           );
       }
     }
+    const maxRetries = Math.max(0, Math.floor(this.options.maxRetries ?? 3));
     let succeeded = '';
-    this.report({
-      type: 'downloading',
-      data: {
-        newVersion: hash,
-      },
-    });
     let lastError: any;
     const errorMessages: string[] = [];
-    const diffUrl = await testUrls(joinUrls(paths, diff));
-    if (diffUrl && !__DEV__) {
-      log('downloading diff');
-      try {
-        await PushyModule.downloadPatchFromPpk({
-          updateUrl: diffUrl,
-          hash,
-          originHash: currentVersion,
-        });
-        succeeded = 'diff';
-      } catch (e: any) {
-        const errorMessage = this.t('error_diff_failed', {
-          message: e.message,
-        });
-        errorMessages.push(errorMessage);
-        lastError = Error(errorMessage);
-        log(errorMessage);
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (attempt > 0) {
+        const backoffMs = Math.min(1000 * 2 ** (attempt - 1), 10000);
+        log(`retry attempt ${attempt}/${maxRetries}, waiting ${backoffMs}ms`);
+        await new Promise(r => setTimeout(r, backoffMs));
+        errorMessages.length = 0;
+        lastError = undefined;
+        succeeded = '';
       }
-    }
-    if (!succeeded) {
-      const pdiffUrl = await testUrls(joinUrls(paths, pdiff));
-      if (pdiffUrl && !__DEV__) {
-        log('downloading pdiff');
+      this.report({
+        type: 'downloading',
+        data: {
+          newVersion: hash,
+          attempt,
+        },
+      });
+      const diffUrl = await testUrls(joinUrls(paths, diff));
+      if (diffUrl && !__DEV__) {
+        log('downloading diff');
         try {
-          await PushyModule.downloadPatchFromPackage({
-            updateUrl: pdiffUrl,
+          await PushyModule.downloadPatchFromPpk({
+            updateUrl: diffUrl,
             hash,
+            originHash: currentVersion,
           });
-          succeeded = 'pdiff';
+          succeeded = 'diff';
         } catch (e: any) {
-          const errorMessage = this.t('error_pdiff_failed', {
+          const errorMessage = this.t('error_diff_failed', {
             message: e.message,
           });
           errorMessages.push(errorMessage);
@@ -560,28 +560,51 @@ export class Pushy {
           log(errorMessage);
         }
       }
-    }
-    if (!succeeded) {
-      const fullUrl = await testUrls(joinUrls(paths, full));
-      if (fullUrl) {
-        log('downloading full patch');
-        try {
-          await PushyModule.downloadFullUpdate({
-            updateUrl: fullUrl,
-            hash,
-          });
+      if (!succeeded) {
+        const pdiffUrl = await testUrls(joinUrls(paths, pdiff));
+        if (pdiffUrl && !__DEV__) {
+          log('downloading pdiff');
+          try {
+            await PushyModule.downloadPatchFromPackage({
+              updateUrl: pdiffUrl,
+              hash,
+            });
+            succeeded = 'pdiff';
+          } catch (e: any) {
+            const errorMessage = this.t('error_pdiff_failed', {
+              message: e.message,
+            });
+            errorMessages.push(errorMessage);
+            lastError = Error(errorMessage);
+            log(errorMessage);
+          }
+        }
+      }
+      if (!succeeded) {
+        const fullUrl = await testUrls(joinUrls(paths, full));
+        if (fullUrl) {
+          log('downloading full patch');
+          try {
+            await PushyModule.downloadFullUpdate({
+              updateUrl: fullUrl,
+              hash,
+            });
+            succeeded = 'full';
+          } catch (e: any) {
+            const errorMessage = this.t('error_full_patch_failed', {
+              message: e.message,
+            });
+            errorMessages.push(errorMessage);
+            lastError = Error(errorMessage);
+            log(errorMessage);
+          }
+        } else if (__DEV__) {
+          log(this.t('dev_incremental_update_disabled'));
           succeeded = 'full';
-        } catch (e: any) {
-          const errorMessage = this.t('error_full_patch_failed', {
-            message: e.message,
-          });
-          errorMessages.push(errorMessage);
-          lastError = Error(errorMessage);
-          log(errorMessage);
         }
-      } else if (__DEV__) {
-        log(this.t('dev_incremental_update_disabled'));
-        succeeded = 'full';
+      }
+      if (succeeded) {
+        break;
       }
     }
     if (sharedState.progressHandlers[hash]) {

package/src/globals.d.ts

@@ -0,0 +1,2 @@
+/** React Native dev mode flag, injected by Metro bundler */
+declare const __DEV__: boolean;

package/src/type.ts

@@ -33,6 +33,8 @@ export interface ProgressData {
   hash: string;
   received: number;
   total: number;
+  /** Download progress percentage (0-100), computed from received / total and clamped to range. Only populated in downloadUpdate callbacks. */
+  progress?: number;
 }
 
 // 用于描述一次检查结束后的最终状态，便于业务侧感知成功、跳过或失败
@@ -119,6 +121,8 @@ export interface ClientOptions {
   ) => Promise<boolean | void> | boolean | void;
   onPackageExpired?: (info: CheckResult) => Promise<boolean> | boolean;
   overridePackageVersion?: string;
+  /** Maximum number of retry attempts for failed downloads (default: 3) */
+  maxRetries?: number;
 }
 
 export interface UpdateTestPayload {

package/src/utils.ts

@@ -108,6 +108,11 @@ export const assertWeb = () => {
   return true;
 };
 
+export const computeProgress = (received: number, total: number): number =>
+  total > 0
+    ? Math.min(100, Math.max(0, Math.floor((received / total) * 100)))
+    : 0;
+
 export const fetchWithTimeout = (
   url: string,
   params: Parameters<typeof fetch>[1],