react-native-update 10.44.0 → 10.46.0

package/src/client.ts

@@ -39,8 +39,19 @@ import {
   testUrls,
 } from './utils';
 import i18n from './i18n';
+import { toUpdateError, UpdateError, UpdateErrorCode } from './error';
 import { dedupeEndpoints, executeEndpointFallback } from './endpoint';
 
+/**
+ * Receives every error the client reports, alongside the report event type.
+ * The UpdateProvider subscribes to surface errors as lastError/Alert; user
+ * code can subscribe too. Listeners run before any throwError rethrow.
+ */
+export type UpdateErrorListener = (
+  error: UpdateError,
+  eventType: EventType,
+) => void;
+
 const SERVER_PRESETS = {
   // cn
   Pushy: {
@@ -142,7 +153,10 @@ export class Pushy {
 
     if (Platform.OS === 'ios' || Platform.OS === 'android') {
       if (!options.appKey) {
-        throw Error(i18n.t('error_appkey_required'));
+        throw new UpdateError(
+          i18n.t('error_appkey_required'),
+          'APPKEY_REQUIRED',
+        );
       }
     }
 
@@ -184,36 +198,88 @@ export class Pushy {
   report = async ({
     type,
     message = '',
+    code,
     data = {},
   }: {
     type: EventType;
     message?: string;
+    code?: UpdateErrorCode;
     data?: Record<string, string | number>;
   }) => {
-    log(`${type} ${message}`);
-    await this.loggerPromise.promise;
+    log(`${type} ${code ? `[${code}] ` : ''}${message}`);
+    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,
+          code,
+          ...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) {
       throw e;
     }
   };
+  private errorListeners = new Set<UpdateErrorListener>();
+  /**
+   * Subscribe to every error the client reports (regardless of throwError).
+   * Returns an unsubscribe function.
+   */
+  onError = (listener: UpdateErrorListener) => {
+    this.errorListeners.add(listener);
+    return () => {
+      this.errorListeners.delete(listener);
+    };
+  };
+  /**
+   * Single exit point for errors: reports to the logger (with the stable
+   * code) and notifies onError listeners. Whether to also throw stays with
+   * the caller (throwIfEnabled or an unconditional rethrow).
+   */
+  private emitError = (
+    error: UpdateError,
+    type: EventType,
+    {
+      message = error.message,
+      data,
+    }: { message?: string; data?: Record<string, string | number> } = {},
+  ) => {
+    this.report({ type, message, code: error.code, data });
+    for (const listener of this.errorListeners) {
+      try {
+        listener(error, type);
+      } catch (e: any) {
+        log('onError listener error:', e?.message || e);
+      }
+    }
+  };
   notifyAfterCheckUpdate = (state: UpdateCheckState) => {
     const { afterCheckUpdate } = this.options;
     if (!afterCheckUpdate) {
@@ -286,11 +352,13 @@ export class Pushy {
 
     if (!resp.ok) {
       const respText = await resp.text();
-      throw Error(
+      throw new UpdateError(
         this.t('error_http_status', {
           status: resp.status,
           statusText: respText,
         }),
+        'HTTP_STATUS',
+        { extra: { status: resp.status } },
       );
     }
 
@@ -332,7 +400,13 @@ export class Pushy {
     if (sharedState.marked || __DEV__ || !isFirstTime) {
       return;
     }
-    await Promise.resolve(PushyModule.markSuccess());
+    try {
+      await Promise.resolve(PushyModule.markSuccess());
+    } catch (e) {
+      const err = toUpdateError(e, 'MARK_SUCCESS_FAILED');
+      this.emitError(err, 'errorMarkSuccess');
+      throw err;
+    }
     sharedState.marked = true;
     this.report({ type: 'markSuccess' });
   };
@@ -350,7 +424,11 @@ export class Pushy {
         }
       } catch (e) {
         sharedState.applyingUpdate = false;
-        throw e;
+        const err = toUpdateError(e, 'SWITCH_VERSION_FAILED');
+        this.emitError(err, 'errorSwitchVersion', {
+          data: { newVersion: hash },
+        });
+        throw err;
       }
       try {
         return await PushyModule.reloadUpdate({ hash });
@@ -358,7 +436,11 @@ export class Pushy {
         // 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;
+        const err = toUpdateError(e, 'SWITCH_VERSION_FAILED');
+        this.emitError(err, 'errorSwitchVersion', {
+          data: { newVersion: hash },
+        });
+        throw err;
       }
     }
   };
@@ -369,7 +451,15 @@ export class Pushy {
     }
     if (assertHash(hash)) {
       log(`switchVersionLater: ${hash}`);
-      return PushyModule.setNeedUpdate({ hash });
+      try {
+        return await PushyModule.setNeedUpdate({ hash });
+      } catch (e) {
+        const err = toUpdateError(e, 'SWITCH_VERSION_FAILED');
+        this.emitError(err, 'errorSwitchVersion', {
+          data: { newVersion: hash },
+        });
+        throw err;
+      }
     }
   };
   checkUpdate = async (extra?: Record<string, any>) => {
@@ -440,31 +530,18 @@ export class Pushy {
       return result;
     } catch (e: any) {
       this.lastRespJson = previousRespJson;
-      const errorMessage =
-        e?.message || this.t('error_cannot_connect_server');
-      this.report({
-        type: 'errorChecking',
-        message: errorMessage,
+      const err = toUpdateError(e, 'CHECK_FAILED');
+      this.emitError(err, 'errorChecking', {
+        message: err.message || this.t('error_cannot_connect_server'),
       });
-      this.notifyAfterCheckUpdate({ status: 'error', error: e });
-      this.throwIfEnabled(e);
+      this.notifyAfterCheckUpdate({ status: 'error', error: err });
+      this.throwIfEnabled(err);
       // 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,
@@ -664,14 +741,22 @@ export class Pushy {
       delete sharedState.progressHandlers[hash];
     }
     if (!succeeded) {
+      const message = errorMessages.join(';');
+      if (lastError) {
+        const err = toUpdateError(lastError, 'DOWNLOAD_FAILED');
+        this.emitError(err, 'errorUpdate', {
+          message,
+          data: { newVersion: hash },
+        });
+        throw err;
+      }
+      // No download URL was even attempted (e.g. dev without a full URL):
+      // report for diagnostics but there is no error object to surface.
       this.report({
         type: 'errorUpdate',
         data: { newVersion: hash },
-        message: errorMessages.join(';'),
+        message,
       });
-      if (lastError) {
-        throw lastError;
-      }
       return;
     } else {
       const duration = Date.now() - patchStartTime;
@@ -712,8 +797,12 @@ export class Pushy {
       return;
     }
     if (sharedState.apkStatus === 'downloaded') {
-      this.report({ type: 'errorInstallApk' });
-      this.throwIfEnabled(Error('errorInstallApk'));
+      const err = new UpdateError(
+        this.t('error_apk_pending_install'),
+        'APK_INSTALL_PENDING',
+      );
+      this.emitError(err, 'errorInstallApk');
+      this.throwIfEnabled(err);
       return;
     }
     if (Platform.Version <= 23) {
@@ -722,13 +811,18 @@ export class Pushy {
           PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE,
         );
         if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
-          this.report({ type: 'rejectStoragePermission' });
-          this.throwIfEnabled(Error('rejectStoragePermission'));
+          const err = new UpdateError(
+            this.t('error_storage_permission_rejected'),
+            'STORAGE_PERMISSION_REJECTED',
+          );
+          this.emitError(err, 'rejectStoragePermission');
+          this.throwIfEnabled(err);
           return;
         }
       } catch (e: any) {
-        this.report({ type: 'errorStoragePermission' });
-        this.throwIfEnabled(e);
+        const err = toUpdateError(e, 'STORAGE_PERMISSION_ERROR');
+        this.emitError(err, 'errorStoragePermission');
+        this.throwIfEnabled(err);
         return;
       }
     }
@@ -756,10 +850,14 @@ export class Pushy {
         hash: progressKey,
       });
       sharedState.apkStatus = 'downloaded';
-    } catch {
+    } catch (e) {
       sharedState.apkStatus = null;
-      this.report({ type: 'errorDownloadAndInstallApk' });
-      this.throwIfEnabled(Error('errorDownloadAndInstallApk'));
+      // Keep the native error (message/stack) instead of discarding it.
+      const err = toUpdateError(e, 'APK_DOWNLOAD_FAILED');
+      this.emitError(err, 'errorDownloadAndInstallApk', {
+        message: err.message || this.t('error_apk_download_failed'),
+      });
+      this.throwIfEnabled(err);
     } finally {
       if (sharedState.progressHandlers[progressKey]) {
         sharedState.progressHandlers[progressKey].remove();

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

@@ -1,5 +1,6 @@
 import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
 import i18n from './i18n';
+import { UpdateError } from './error';
 import { emptyModule, error, log } from './utils';
 
 /* eslint-disable @react-native/no-deep-imports */
@@ -21,8 +22,9 @@ export const PushyModule =
 export const UpdateModule = PushyModule;
 
 if (!PushyModule) {
-	throw Error(
+	throw new UpdateError(
 		'Failed to load react-native-update native module, please try to recompile',
+		'MODULE_NOT_LOADED',
 	);
 }
 
@@ -82,7 +84,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/endpoint.ts

@@ -1,3 +1,5 @@
+import { UpdateError } from './error';
+
 export interface EndpointAttemptSuccess<T> {
   endpoint: string;
   value: T;
@@ -47,7 +49,7 @@ export const pickRandomEndpoint = (
   random: () => number = Math.random,
 ) => {
   if (!endpoints.length) {
-    throw new Error('No endpoints configured');
+    throw new UpdateError('No endpoints configured', 'NO_ENDPOINTS');
   }
   return endpoints[Math.floor(random() * endpoints.length)];
 };
@@ -120,7 +122,7 @@ export async function executeEndpointFallback<T>({
   let candidates = dedupeEndpoints(configuredEndpoints);
 
   if (!candidates.length) {
-    throw new Error('No endpoints configured');
+    throw new UpdateError('No endpoints configured', 'NO_ENDPOINTS');
   }
 
   const firstEndpoint = pickRandomEndpoint(candidates, random);

package/src/error.ts

@@ -0,0 +1,68 @@
+/**
+ * Stable, machine-readable error codes. Unlike messages (which are localized
+ * and vary across platforms), codes are safe to aggregate on in a logger.
+ *
+ * The native-originated codes (second group) are defined in
+ * cpp/patch_core/error_codes.h — the single source of truth shared by the
+ * Android/iOS/Harmony modules — and flow through promise rejections onto the
+ * `code` property, which toUpdateError() preserves.
+ */
+export type UpdateErrorCode =
+  // JS-layer codes
+  | 'MODULE_NOT_LOADED'
+  | 'APPKEY_REQUIRED'
+  | 'NO_ENDPOINTS'
+  | 'HTTP_STATUS'
+  | 'CHECK_FAILED'
+  | 'DOWNLOAD_FAILED'
+  | 'SWITCH_VERSION_FAILED'
+  | 'MARK_SUCCESS_FAILED'
+  | 'APK_INSTALL_PENDING'
+  | 'STORAGE_PERMISSION_REJECTED'
+  | 'STORAGE_PERMISSION_ERROR'
+  | 'APK_DOWNLOAD_FAILED'
+  // Native codes (see cpp/patch_core/error_codes.h)
+  | 'INVALID_OPTIONS'
+  | 'PATCH_FAILED'
+  | 'FILE_OPERATION_FAILED'
+  | 'RESTART_FAILED'
+  | 'INVALID_HASH_INFO'
+  | 'UNSUPPORTED_PLATFORM';
+
+export class UpdateError extends Error {
+  code: UpdateErrorCode;
+  cause?: unknown;
+  extra?: Record<string, string | number>;
+
+  constructor(
+    message: string,
+    code: UpdateErrorCode,
+    options?: { cause?: unknown; extra?: Record<string, string | number> },
+  ) {
+    super(message);
+    this.name = 'UpdateError';
+    this.code = code;
+    this.cause = options?.cause;
+    this.extra = options?.extra;
+  }
+}
+
+/**
+ * Attach a code to an unknown thrown value. An existing Error keeps its
+ * identity (message, stack, and any code already assigned upstream) so callers
+ * comparing the caught error to the original still match; non-Error values are
+ * wrapped.
+ */
+export const toUpdateError = (
+  e: unknown,
+  code: UpdateErrorCode,
+): UpdateError => {
+  if (e instanceof Error) {
+    const err = e as UpdateError;
+    if (!err.code) {
+      err.code = code;
+    }
+    return err;
+  }
+  return new UpdateError(String(e ?? code), code);
+};

package/src/index.ts

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

package/src/locales/en.ts

@@ -19,7 +19,6 @@ export default {
   time_remaining: 'Time remaining: {{time}}',
 
   // Error messages
-  error_code: 'Error code: {{code}}',
   error_message: 'Error message: {{message}}',
   retry_count: 'Retry attempt: {{count}}/{{max}}',
 
@@ -57,6 +56,11 @@ export default {
   error_ping_failed: 'Ping failed',
   error_ping_timeout: 'Ping timeout',
   error_http_status: '{{status}} {{statusText}}',
+  error_apk_pending_install:
+    'The APK has been downloaded, please complete the installation in the system installer',
+  error_storage_permission_rejected:
+    'Storage permission denied, unable to download the APK',
+  error_apk_download_failed: 'Failed to download or install the APK',
 
   // Development messages
   dev_debug_disabled:

package/src/locales/zh.ts

@@ -19,7 +19,6 @@ export default {
   time_remaining: '剩余时间: {{time}}',
 
   // Error messages
-  error_code: '错误代码: {{code}}',
   error_message: '错误信息: {{message}}',
   retry_count: '重试次数: {{count}}/{{max}}',
 
@@ -54,6 +53,9 @@ export default {
   error_ping_failed: 'Ping 失败',
   error_ping_timeout: 'Ping 超时',
   error_http_status: '{{status}} {{statusText}}',
+  error_apk_pending_install: '安装包已下载完成，请在系统安装界面完成安装',
+  error_storage_permission_rejected: '存储权限被拒绝，无法下载安装包',
+  error_apk_download_failed: '安装包下载或安装失败',
 
   // Development messages
   dev_debug_disabled: