react-native-update 10.43.3 → 10.45.0

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) {
@@ -187,23 +191,39 @@ export class Pushy {
     data?: Record<string, string | number>;
   }) => {
     log(`${type} ${message}`);
-    await this.loggerPromise.promise;
+    if (this.options.logger === noop) {
+      // Wait briefly for a logger to arrive via setOptions (e.g. the rollback
+      // report fires in the constructor before the user configures one), but
+      // give up after a bound instead of retaining the closure forever when
+      // no logger is ever provided.
+      await Promise.race([
+        this.loggerPromise.promise,
+        new Promise(resolve => setTimeout(resolve, 10 * 1000)),
+      ]);
+    }
     const { logger = noop, appKey } = this.options;
     const overridePackageVersion = this.options.overridePackageVersion;
-    logger({
-      type,
-      data: {
-        appKey,
-        currentVersion,
-        cInfo,
-        packageVersion,
-        overridePackageVersion,
-        buildTime,
-        message,
-        ...currentVersionInfo,
-        ...data,
-      },
-    });
+    try {
+      logger({
+        type,
+        data: {
+          appKey,
+          currentVersion,
+          cInfo,
+          packageVersion,
+          overridePackageVersion,
+          buildTime,
+          message,
+          ...currentVersionInfo,
+          ...data,
+        },
+      });
+    } catch (e: any) {
+      // A user-provided logger must never break the update flow, and report()
+      // calls are fire-and-forget so a throw here would be an unhandled
+      // rejection.
+      log('logger error:', e?.message || e);
+    }
   };
   throwIfEnabled = (e: Error) => {
     if (this.options.throwError) {
@@ -348,7 +368,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,34 +464,17 @@ 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 () => {
-    const { server } = this.options;
-    if (!server) {
-      return [];
-    }
-    const remoteEndpoints = await this.getRemoteEndpoints();
-    return excludeConfiguredEndpoints(
-      dedupeEndpoints(remoteEndpoints),
-      this.getConfiguredCheckEndpoints(),
-    );
-  };
   downloadUpdate = async (
     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 +497,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 +568,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 +637,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);
+      for (const strategy of strategies) {
+        if (succeeded) {
+          break;
         }
-      }
-      if (!succeeded) {
-        const pdiffUrl = await testUrls(joinUrls(paths, pdiff));
-        if (pdiffUrl && !__DEV__) {
-          log('downloading pdiff');
+        const url = await testUrls(joinUrls(paths, strategy.candidate));
+        if (url && !(strategy.skipInDev && __DEV__)) {
+          log(`downloading ${strategy.name}`);
           try {
-            await PushyModule.downloadPatchFromPackage({
-              updateUrl: pdiffUrl,
-              hash,
-            });
-            succeeded = 'pdiff';
+            await strategy.run(url);
+            succeeded = strategy.name;
           } catch (e: any) {
-            const errorMessage = this.t('error_pdiff_failed', {
+            const errorMessage = this.t(strategy.errorKey, {
               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__) {
+        } else if (!url && strategy.devNoopWhenNoUrl && __DEV__) {
           log(this.t('dev_incremental_update_disabled'));
-          succeeded = 'full';
+          succeeded = strategy.name;
         }
       }
       if (succeeded) {
@@ -697,19 +754,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/context.ts

@@ -1,4 +1,4 @@
-import { createContext, useContext } from 'react';
+import { createContext, useContext, useMemo } from 'react';
 import { CheckResult, ProgressData } from './type';
 import { Pushy, Cresc } from './client';
 import i18n from './i18n';
@@ -46,21 +46,35 @@ export const UpdateContext = createContext<{
   currentHash: string;
   packageVersion: string;
   client?: Pushy | Cresc;
-  progress?: ProgressData;
   updateInfo?: CheckResult;
   lastError?: Error;
 }>(defaultContext);
 
-export const useUpdate = __DEV__ ? () => {
+// Download progress ticks at high frequency, so it lives in its own context;
+// otherwise every tick would re-render all useUpdate() consumers even when
+// they never read progress.
+export const ProgressContext = createContext<ProgressData | undefined>(
+  undefined,
+);
+
+/**
+ * Subscribe to download progress only. Components that render a progress bar
+ * should prefer this over useUpdate() so the rest of the tree is not
+ * re-rendered on every progress event.
+ */
+export const useUpdateProgress = () => useContext(ProgressContext);
+
+export const useUpdate = () => {
   const context = useContext(UpdateContext);
+  const progress = useContext(ProgressContext);
 
-  // 检查是否在 UpdateProvider 内部使用
-  if (!context.client) {
+  if (__DEV__ && !context.client) {
+    // 检查是否在 UpdateProvider 内部使用
     throw new Error(i18n.t('error_use_update_outside_provider'));
   }
 
-  return context;
-} : () => useContext(UpdateContext);
+  return useMemo(() => ({ ...context, progress }), [context, progress]);
+};
 
 /** @deprecated Please use `useUpdate` instead */
 export const usePushy = useUpdate;

package/src/core.ts

@@ -82,7 +82,11 @@ export const pushyNativeEventEmitter = new NativeEventEmitter(PushyModule);
 
 if (!uuid) {
 	uuid = require('nanoid/non-secure').nanoid();
-	PushyModule.setUuid(uuid);
+	// If persisting fails the uuid drifts on every launch, which skews gray
+	// release bucketing and inflates stats — log it instead of failing silently.
+	Promise.resolve(PushyModule.setUuid(uuid)).catch((e: any) => {
+		log('setUuid error:', e?.message || e);
+	});
 }
 
 export const cInfo = {

package/src/index.ts

@@ -1,4 +1,10 @@
 export { Pushy, Cresc } from './client';
-export { UpdateContext, usePushy, useUpdate } from './context';
+export {
+  ProgressContext,
+  UpdateContext,
+  usePushy,
+  useUpdate,
+  useUpdateProgress,
+} from './context';
 export { PushyProvider, UpdateProvider } from './provider';
 export { PushyModule, UpdateModule } from './core';