react-native-update 10.43.2 → 10.44.0

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

@@ -68,7 +68,7 @@ export class UpdateContext {
    */
   private trace(point: string): void {
     const snap = this.getStateSnapshot();
-    logger.info(
+    logger.debug(
       'UpdateContext',
       `trace id=${this.instanceId} ${point}` +
         ` pkg=${snap.packageVersion} bt=${snap.buildTime}` +
@@ -91,7 +91,12 @@ export class UpdateContext {
         name: 'update',
       });
     } catch (e) {
+      // Fail fast: a missing preferences store means no state can be persisted,
+      // which disables rollback protection. Rethrow so the failure surfaces at
+      // construction time instead of later as an unrelated TypeError on the
+      // undefined `preferences` handle.
       console.error('Failed to init preferences:', e);
+      throw e;
     }
   }
 
@@ -179,17 +184,23 @@ export class UpdateContext {
   }
 
   private flushPreferences(reason: string): void {
-    try {
-      const flushablePreferences = this.preferences as FlushablePreferences;
-      if (typeof flushablePreferences.flushSync === 'function') {
+    const flushablePreferences = this.preferences as FlushablePreferences;
+    if (typeof flushablePreferences.flushSync === 'function') {
+      try {
         flushablePreferences.flushSync();
         return;
+      } catch (error) {
+        console.error(`Failed to flushSync preferences for ${reason}:`, error);
+        // fall through to async flush rather than failing the whole operation
       }
-      throw Error('preferences.flushSync is not available');
-    } catch (error) {
-      console.error(`Failed to flush preferences for ${reason}:`, error);
-      throw error;
     }
+    // flushSync unavailable or failed: writes are already applied in memory via
+    // putSync/deleteSync; persist asynchronously as a best-effort so the state
+    // operation still succeeds instead of throwing (which is worse than a
+    // slightly delayed persist).
+    this.preferences.flush().catch((error: Object) => {
+      console.error(`Failed to flush preferences for ${reason}:`, error);
+    });
   }
 
   private putNullableString(key: string, value?: string): void {
@@ -509,12 +520,18 @@ export class UpdateContext {
 
   public cleanUp(): void {
     const state = this.getStateSnapshot();
+    // cleanupOldEntries now runs on a native worker thread (returns a Promise).
+    // Cleanup is best-effort background maintenance and no caller depends on its
+    // completion, so fire-and-forget it off the UI thread and just log failures
+    // instead of blocking the state operation (or cold start) on disk I/O.
     NativePatchCore.cleanupOldEntries(
       this.rootDir,
       state.currentVersion || '',
       state.lastVersion || '',
       3,
-    );
+    ).catch((error: Object) => {
+      console.error('cleanupOldEntries failed:', error);
+    });
   }
 
   public getIsUsingBundleUrl(): boolean {

package/ios/RCTPushy/RCTPushyDownloader.mm

@@ -10,6 +10,8 @@ static NSString *const RCTPushyDownloaderErrorDomain = @"cn.reactnative.pushy";
 @property (copy) NSString *savePath;
 @property (nonatomic, strong) NSError *fileError;
 @property (nonatomic, assign) BOOL finished;
+@property (nonatomic, assign) int lastReportedPercentage;
+@property (nonatomic, assign) long long lastReportedBytes;
 @end
 
 @implementation RCTPushyDownloader
@@ -42,6 +44,10 @@ completionHandler:(void (^)(NSString *path, NSError *error))completionHandler
     }
 
     NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
+    // Avoid hanging forever on a stalled connection (default resource timeout
+    // is 7 days). These are generous enough for large bundles on slow networks.
+    sessionConfig.timeoutIntervalForRequest = 30;
+    sessionConfig.timeoutIntervalForResource = 300;
     self.session = [NSURLSession sessionWithConfiguration:sessionConfig
                                                  delegate:self
                                             delegateQueue:nil];
@@ -77,14 +83,47 @@ completionHandler:(void (^)(NSString *path, NSError *error))completionHandler
  totalBytesWritten:(int64_t)totalBytesWritten
 totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite
 {
-    if (self.progressHandler) {
-        self.progressHandler(totalBytesWritten ,totalBytesExpectedToWrite);
+    if (!self.progressHandler) {
+        return;
+    }
+    // Normalize an unknown total (NSURLSessionTransferSizeUnknown == -1) to 0 so
+    // the JS side does not compute a negative/NaN percentage.
+    long long total = totalBytesExpectedToWrite > 0 ? totalBytesExpectedToWrite : 0;
+    if (total > 0) {
+        int percentage = (int)((totalBytesWritten * 100.0 / total) + 0.5);
+        if (percentage <= self.lastReportedPercentage) {
+            return;
+        }
+        self.lastReportedPercentage = percentage;
+    } else {
+        // Total unknown: throttle by bytes to avoid flooding the bridge.
+        if (totalBytesWritten - self.lastReportedBytes < 256 * 1024) {
+            return;
+        }
+        self.lastReportedBytes = totalBytesWritten;
     }
+    self.progressHandler(totalBytesWritten, total);
 }
 
 - (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask
 didFinishDownloadingToURL:(NSURL *)location
 {
+    // A completed transfer does not imply success: 404/500 pages, CDN error
+    // bodies and captive-portal HTML all arrive here. Reject non-2xx responses
+    // before touching savePath so an existing valid package is not destroyed.
+    NSURLResponse *response = downloadTask.response;
+    if ([response isKindOfClass:[NSHTTPURLResponse class]]) {
+        NSInteger statusCode = ((NSHTTPURLResponse *)response).statusCode;
+        if (statusCode < 200 || statusCode >= 300) {
+            self.fileError = [NSError errorWithDomain:RCTPushyDownloaderErrorDomain
+                                                 code:statusCode
+                                             userInfo:@{
+                NSLocalizedDescriptionKey: [NSString stringWithFormat:@"unexpected http status code %ld", (long)statusCode],
+            }];
+            return;
+        }
+    }
+
     NSFileManager *fileManager = [NSFileManager defaultManager];
     [fileManager removeItemAtPath:self.savePath error:nil];
 

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "react-native-update",
-  "version": "10.43.2",
+  "version": "10.44.0",
   "description": "react-native hot update",
   "main": "src/index",
+  "types": "src/index.ts",
   "scripts": {
     "prepublishOnly": "NODE_ENV=production bun scripts/prepublish.ts",
     "publish:local": "SKIP_NATIVE_BUILD=1 npm publish",

package/src/client.ts

@@ -30,7 +30,6 @@ import {
   assertWeb,
   computeProgress,
   DEFAULT_FETCH_TIMEOUT_MS,
-  emptyObj,
   fetchWithTimeout,
   info,
   joinUrls,
@@ -87,6 +86,7 @@ const defaultClientOptions: ClientOptions = {
 
 export const sharedState: {
   progressHandlers: Record<string, EmitterSubscription>;
+  downloadingTasks: Record<string, Promise<string | undefined>>;
   downloadedHash?: string;
   toHash?: string;
   apkStatus: 'downloading' | 'downloaded' | null;
@@ -94,6 +94,7 @@ export const sharedState: {
   applyingUpdate: boolean;
 } = {
   progressHandlers: {},
+  downloadingTasks: {},
   downloadedHash: undefined,
   apkStatus: null,
   marked: false,
@@ -102,6 +103,7 @@ export const sharedState: {
 
 const assertHash = (hash: string) => {
   if (!sharedState.downloadedHash) {
+    log(`no downloaded hash yet, ignore switch to ${hash}`);
     return;
   }
   if (hash !== sharedState.downloadedHash) {
@@ -113,7 +115,7 @@ const assertHash = (hash: string) => {
 
 // for China users
 export class Pushy {
-  options = defaultClientOptions;
+  options = { ...defaultClientOptions };
   clientType: 'Pushy' | 'Cresc' = 'Pushy';
   lastChecking?: number;
   lastRespJson?: Promise<CheckResult>;
@@ -134,7 +136,9 @@ export class Pushy {
     this.clientType = clientType || 'Pushy';
     this.options.server = cloneServerConfig(SERVER_PRESETS[this.clientType]);
 
-    i18n.setLocale(options.locale ?? this.clientType === 'Pushy' ? 'zh' : 'en');
+    i18n.setLocale(
+      options.locale ?? (this.clientType === 'Pushy' ? 'zh' : 'en'),
+    );
 
     if (Platform.OS === 'ios' || Platform.OS === 'android') {
       if (!options.appKey) {
@@ -348,7 +352,14 @@ export class Pushy {
         sharedState.applyingUpdate = false;
         throw e;
       }
-      return PushyModule.reloadUpdate({ hash });
+      try {
+        return await PushyModule.reloadUpdate({ hash });
+      } catch (e) {
+        // reloadUpdate can reject (e.g. bundle missing); reset the flag so a
+        // later retry is not permanently blocked by a stuck applyingUpdate.
+        sharedState.applyingUpdate = false;
+        throw e;
+      }
     }
   };
 
@@ -437,7 +448,10 @@ export class Pushy {
       });
       this.notifyAfterCheckUpdate({ status: 'error', error: e });
       this.throwIfEnabled(e);
-      return previousRespJson ? await previousRespJson : emptyObj;
+      // Fall back to the previous successful response if we have one; otherwise
+      // return undefined so callers can distinguish "check failed" from a real
+      // empty result and avoid overwriting the last good updateInfo.
+      return previousRespJson ? await previousRespJson : undefined;
     }
   };
   getBackupEndpoints = async () => {
@@ -455,16 +469,7 @@ export class Pushy {
     updateInfo: CheckResult,
     onDownloadProgress?: (data: ProgressData) => void,
   ) => {
-    const {
-      hash,
-      diff,
-      pdiff,
-      full,
-      paths = [],
-      name,
-      description = '',
-      metaInfo,
-    } = updateInfo;
+    const { hash } = updateInfo;
     if (
       this.options.beforeDownloadUpdate &&
       (await this.options.beforeDownloadUpdate(updateInfo)) === false
@@ -487,6 +492,39 @@ export class Pushy {
       log(`duplicated downloaded hash ${sharedState.downloadedHash}, ignored`);
       return sharedState.downloadedHash;
     }
+    // Deduplicate concurrent downloads of the same hash regardless of whether a
+    // progress callback was passed: all callers await the single in-flight
+    // promise instead of triggering parallel native downloads.
+    const existingTask = sharedState.downloadingTasks[hash];
+    if (existingTask) {
+      log(`download for hash ${hash} already in progress, reusing it`);
+      return existingTask;
+    }
+    const task = this.performDownload(updateInfo, onDownloadProgress);
+    sharedState.downloadingTasks[hash] = task;
+    try {
+      return await task;
+    } finally {
+      delete sharedState.downloadingTasks[hash];
+    }
+  };
+  private performDownload = async (
+    updateInfo: CheckResult,
+    onDownloadProgress?: (data: ProgressData) => void,
+  ) => {
+    const {
+      hash,
+      diff,
+      pdiff,
+      full,
+      paths = [],
+      name,
+      description = '',
+      metaInfo,
+    } = updateInfo;
+    if (!hash) {
+      return;
+    }
     if (sharedState.progressHandlers[hash]) {
       return;
     }
@@ -525,6 +563,59 @@ export class Pushy {
     let lastError: any;
     const errorMessages: string[] = [];
 
+    // Ordered download strategies, tried in sequence until one succeeds. Each
+    // resolves its candidate URL lazily (testUrls) and runs the matching native
+    // download. diff/pdiff are incremental and skipped entirely in dev; full is
+    // attempted whenever a URL exists, and in dev with no URL it is treated as a
+    // no-op success so the flow can proceed.
+    type DownloadStrategy = {
+      name: string;
+      candidate: string | undefined;
+      errorKey: 'error_diff_failed' | 'error_pdiff_failed' | 'error_full_patch_failed';
+      skipInDev: boolean;
+      devNoopWhenNoUrl: boolean;
+      run: (url: string) => Promise<void>;
+    };
+    const strategies: DownloadStrategy[] = [
+      {
+        name: 'diff',
+        candidate: diff,
+        errorKey: 'error_diff_failed',
+        skipInDev: true,
+        devNoopWhenNoUrl: false,
+        run: url =>
+          PushyModule.downloadPatchFromPpk({
+            updateUrl: url,
+            hash,
+            originHash: currentVersion,
+          }),
+      },
+      {
+        name: 'pdiff',
+        candidate: pdiff,
+        errorKey: 'error_pdiff_failed',
+        skipInDev: true,
+        devNoopWhenNoUrl: false,
+        run: url =>
+          PushyModule.downloadPatchFromPackage({
+            updateUrl: url,
+            hash,
+          }),
+      },
+      {
+        name: 'full',
+        candidate: full,
+        errorKey: 'error_full_patch_failed',
+        skipInDev: false,
+        devNoopWhenNoUrl: true,
+        run: url =>
+          PushyModule.downloadFullUpdate({
+            updateUrl: url,
+            hash,
+          }),
+      },
+    ];
+
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       if (attempt > 0) {
         const backoffMs = Math.min(1000 * 2 ** (attempt - 1), 10000);
@@ -541,66 +632,27 @@ export class Pushy {
           attempt,
         },
       });
-      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);
-        }
-      }
-      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);
-          }
+      for (const strategy of strategies) {
+        if (succeeded) {
+          break;
         }
-      }
-      if (!succeeded) {
-        const fullUrl = await testUrls(joinUrls(paths, full));
-        if (fullUrl) {
-          log('downloading full patch');
+        const url = await testUrls(joinUrls(paths, strategy.candidate));
+        if (url && !(strategy.skipInDev && __DEV__)) {
+          log(`downloading ${strategy.name}`);
           try {
-            await PushyModule.downloadFullUpdate({
-              updateUrl: fullUrl,
-              hash,
-            });
-            succeeded = 'full';
+            await strategy.run(url);
+            succeeded = strategy.name;
           } catch (e: any) {
-            const errorMessage = this.t('error_full_patch_failed', {
+            const errorMessage = this.t(strategy.errorKey, {
               message: e.message,
             });
             errorMessages.push(errorMessage);
             lastError = Error(errorMessage);
             log(errorMessage);
           }
-        } else if (__DEV__) {
+        } else if (!url && strategy.devNoopWhenNoUrl && __DEV__) {
           log(this.t('dev_incremental_update_disabled'));
-          succeeded = 'full';
+          succeeded = strategy.name;
         }
       }
       if (succeeded) {
@@ -697,19 +749,22 @@ export class Pushy {
           },
         );
     }
-    await PushyModule.downloadAndInstallApk({
-      url,
-      target: 'update.apk',
-      hash: progressKey,
-    }).catch(() => {
+    try {
+      await PushyModule.downloadAndInstallApk({
+        url,
+        target: 'update.apk',
+        hash: progressKey,
+      });
+      sharedState.apkStatus = 'downloaded';
+    } catch {
       sharedState.apkStatus = null;
       this.report({ type: 'errorDownloadAndInstallApk' });
       this.throwIfEnabled(Error('errorDownloadAndInstallApk'));
-    });
-    sharedState.apkStatus = 'downloaded';
-    if (sharedState.progressHandlers[progressKey]) {
-      sharedState.progressHandlers[progressKey].remove();
-      delete sharedState.progressHandlers[progressKey];
+    } finally {
+      if (sharedState.progressHandlers[progressKey]) {
+        sharedState.progressHandlers[progressKey].remove();
+        delete sharedState.progressHandlers[progressKey];
+      }
     }
   };
   restartApp = async () => {

package/src/provider.tsx

@@ -27,7 +27,7 @@ import {
 import { UpdateContext } from './context';
 import { URL } from 'react-native-url-polyfill';
 import { resolveCheckResult } from './resolveCheckResult';
-import { assertWeb, log } from './utils';
+import { assertWeb, log, noop } from './utils';
 
 export const UpdateProvider = ({
   client,
@@ -108,7 +108,6 @@ export const UpdateProvider = ({
         if (!hash) {
           return false;
         }
-        stateListener.current && stateListener.current.remove();
 
         if (
           options.afterDownloadUpdate &&
@@ -170,7 +169,7 @@ export const UpdateProvider = ({
       lastChecking.current = now;
       let rootInfo: CheckResult | undefined;
       try {
-        rootInfo = { ...(await client.checkUpdate(extra)) };
+        rootInfo = await client.checkUpdate(extra);
       } catch (e: any) {
         setLastError(e);
         alertError(client.t('error_update_check_failed'), e.message);
@@ -178,6 +177,8 @@ export const UpdateProvider = ({
         return;
       }
       if (!rootInfo) {
+        // Check was skipped or failed with no cached result; keep the last
+        // known updateInfo instead of overwriting it with an empty object.
         return;
       }
       const info = resolveCheckResult(rootInfo);
@@ -198,7 +199,7 @@ export const UpdateProvider = ({
         if (downloadUrl && sharedState.apkStatus === null) {
           if (options.updateStrategy === 'silentAndNow') {
             if (Platform.OS === 'android' && downloadUrl.endsWith('.apk')) {
-              downloadAndInstallApk(downloadUrl);
+              downloadAndInstallApk(downloadUrl).catch(noop);
             } else {
               Linking.openURL(downloadUrl);
             }
@@ -215,7 +216,7 @@ export const UpdateProvider = ({
                     Platform.OS === 'android' &&
                     downloadUrl.endsWith('.apk')
                   ) {
-                    downloadAndInstallApk(downloadUrl);
+                    downloadAndInstallApk(downloadUrl).catch(noop);
                   } else {
                     Linking.openURL(downloadUrl);
                   }
@@ -229,7 +230,7 @@ export const UpdateProvider = ({
           options.updateStrategy === 'silentAndNow' ||
           options.updateStrategy === 'silentAndLater'
         ) {
-          downloadUpdate(info);
+          downloadUpdate(info).catch(noop);
           return info;
         }
         alertUpdate(
@@ -244,7 +245,7 @@ export const UpdateProvider = ({
               text: client.t('alert_confirm'),
               style: 'default',
               onPress: () => {
-                downloadUpdate();
+                downloadUpdate().catch(noop);
               },
             },
           ],
@@ -272,7 +273,7 @@ export const UpdateProvider = ({
     if (!assertWeb()) {
       return;
     }
-    const { checkStrategy, dismissErrorAfter, autoMarkSuccess } = options;
+    const { checkStrategy, autoMarkSuccess } = options;
     if (autoMarkSuccess) {
       setTimeout(() => {
         markSuccess();
@@ -283,26 +284,35 @@ export const UpdateProvider = ({
         'change',
         nextAppState => {
           if (nextAppState === 'active') {
-            checkUpdate();
+            checkUpdate().catch(noop);
           }
         },
       );
     }
     if (checkStrategy === 'both' || checkStrategy === 'onAppStart') {
-      checkUpdate();
-    }
-    let dismissErrorTimer: ReturnType<typeof setTimeout>;
-    if (typeof dismissErrorAfter === 'number' && dismissErrorAfter > 0) {
-      dismissErrorTimer = setTimeout(() => {
-        dismissError();
-      }, dismissErrorAfter);
+      checkUpdate().catch(noop);
     }
     return () => {
       stateListener.current && stateListener.current.remove();
-      clearTimeout(dismissErrorTimer);
     };
   }, [checkUpdate, options, dismissError, markSuccess, client]);
 
+  useEffect(() => {
+    const { dismissErrorAfter } = options;
+    if (
+      lastError &&
+      typeof dismissErrorAfter === 'number' &&
+      dismissErrorAfter > 0
+    ) {
+      const dismissErrorTimer = setTimeout(() => {
+        dismissError();
+      }, dismissErrorAfter);
+      return () => {
+        clearTimeout(dismissErrorTimer);
+      };
+    }
+  }, [lastError, options, dismissError]);
+
   const parseTestPayload = useCallback(
     (payload: UpdateTestPayload) => {
       if (payload && payload.type && payload.type.startsWith('__rnPushy')) {
@@ -314,15 +324,19 @@ export const UpdateProvider = ({
         if (payload.type === '__rnPushyVersionHash') {
           const toHash = payload.data;
           sharedState.toHash = toHash;
-          checkUpdate({ extra: { toHash } }).then(() => {
-            if (updateInfoRef.current && updateInfoRef.current.upToDate) {
-              Alert.alert(
-                client.t('alert_info'),
-                client.t('alert_no_update_wait'),
-              );
-            }
-            options.logger = logger;
-          });
+          checkUpdate({ extra: { toHash } })
+            .then(() => {
+              if (updateInfoRef.current && updateInfoRef.current.upToDate) {
+                Alert.alert(
+                  client.t('alert_info'),
+                  client.t('alert_no_update_wait'),
+                );
+              }
+            })
+            .catch(noop)
+            .finally(() => {
+              options.logger = logger;
+            });
         }
         return true;
       }

package/src/utils.ts

@@ -84,7 +84,7 @@ export function joinUrls(paths: string[], fileName?: string) {
   }
 }
 
-export const testUrls = async (urls?: string[]) => {
+export const testUrls = async (urls?: string[]): Promise<string | null> => {
   if (!urls?.length) {
     return null;
   }
@@ -93,7 +93,7 @@ export const testUrls = async (urls?: string[]) => {
     const ret = await promiseAny(urls.map(ping));
     if (ret) {
       log('ping success, use url:', ret);
-      return ret;
+      return ret as string;
     }
   } catch {}
   log('all ping failed, use first url:', urls[0]);