react-native-update 10.42.4 → 10.42.5

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

@@ -75,7 +75,7 @@ export class PushyTurboModule extends UITurboModule {
     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

@@ -25,6 +25,7 @@ export class UpdateContext {
   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;
@@ -72,9 +73,8 @@ export class UpdateContext {
 
   public getBuildTime(): string {
     try {
-      const content = this.context.resourceManager.getRawFileContentSync(
-        'meta.json',
-      );
+      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>;
@@ -182,6 +182,8 @@ export class UpdateContext {
       clearExisting?: boolean;
       removeStaleHash?: boolean;
       cleanUp?: boolean;
+      markFirstLoadMarker?: boolean;
+      clearFirstLoadMarker?: boolean;
     } = {},
   ): void {
     if (options.clearExisting) {
@@ -191,6 +193,12 @@ export class UpdateContext {
     if (options.removeStaleHash && state.staleVersionToDelete) {
       this.preferences.deleteSync(`hash_${state.staleVersionToDelete}`);
     }
+    if (options.markFirstLoadMarker) {
+      this.preferences.putSync('firstLoadMarked', 'true');
+    }
+    if (options.clearFirstLoadMarker) {
+      this.preferences.deleteSync('firstLoadMarked');
+    }
     this.flushPreferences('persist state');
     if (options.cleanUp) {
       this.cleanUp();
@@ -203,6 +211,7 @@ export class UpdateContext {
     options: {
       removeStaleHash?: boolean;
       cleanUp?: boolean;
+      clearFirstLoadMarker?: boolean;
     } = {},
   ): StateCoreResult {
     const nextState = NativePatchCore.runStateCore(
@@ -245,6 +254,7 @@ export class UpdateContext {
       return;
     }
 
+    UpdateContext.ignoreRollback = false;
     this.cleanUp();
     this.persistState(nextState, { clearExisting: true });
   }
@@ -278,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 {
@@ -361,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.4",
+  "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],