react-native-update 10.44.0 → 10.46.0

package/src/provider.tsx

@@ -2,6 +2,7 @@ import React, {
   ReactNode,
   useCallback,
   useEffect,
+  useMemo,
   useRef,
   useState,
 } from 'react';
@@ -24,7 +25,7 @@ import {
   ProgressData,
   UpdateTestPayload,
 } from './type';
-import { UpdateContext } from './context';
+import { ProgressContext, UpdateContext } from './context';
 import { URL } from 'react-native-url-polyfill';
 import { resolveCheckResult } from './resolveCheckResult';
 import { assertWeb, log, noop } from './utils';
@@ -44,16 +45,6 @@ export const UpdateProvider = ({
   const updateInfoRef = useRef(updateInfo);
   const [progress, setProgress] = useState<ProgressData>();
   const [lastError, setLastError] = useState<Error>();
-  const lastChecking = useRef(0);
-
-  const throwErrorIfEnabled = useCallback(
-    (e: Error) => {
-      if (options.throwError) {
-        throw e;
-      }
-    },
-    [options.throwError],
-  );
 
   const dismissError = useCallback(() => {
     setLastError(undefined);
@@ -80,6 +71,25 @@ export const UpdateProvider = ({
     [options.updateStrategy],
   );
 
+  // All client errors flow through this single subscription (regardless of
+  // throwError), so the catches below only handle flow control and never
+  // duplicate the lastError/Alert surfacing.
+  useEffect(
+    () =>
+      client.onError((e, eventType) => {
+        setLastError(e);
+        alertError(
+          client.t(
+            eventType === 'errorChecking'
+              ? 'error_update_check_failed'
+              : 'update_failed',
+          ),
+          e.message,
+        );
+      }),
+    [client, alertError],
+  );
+
   const switchVersion = useCallback(
     async (info: CheckResult | undefined = updateInfoRef.current) => {
       if (info && info.hash) {
@@ -117,10 +127,11 @@ export const UpdateProvider = ({
           return false;
         }
         if (options.updateStrategy === 'silentAndNow') {
-          client.switchVersion(hash);
+          // Failures are surfaced via the onError subscription above.
+          client.switchVersion(hash).catch(noop);
           return true;
         } else if (options.updateStrategy === 'silentAndLater') {
-          client.switchVersionLater(hash);
+          client.switchVersionLater(hash).catch(noop);
           return true;
         }
         alertUpdate(client.t('alert_title'), client.t('alert_update_ready'), [
@@ -128,26 +139,33 @@ export const UpdateProvider = ({
             text: client.t('alert_next_time'),
             style: 'cancel',
             onPress: () => {
-              client.switchVersionLater(hash);
+              client.switchVersionLater(hash).catch(noop);
             },
           },
           {
             text: client.t('alert_update_now'),
             style: 'default',
             onPress: () => {
-              client.switchVersion(hash);
+              client.switchVersion(hash).catch(noop);
             },
           },
         ]);
         return true;
       } catch (e: any) {
-        setLastError(e);
-        alertError(client.t('update_failed'), e.message);
-        throwErrorIfEnabled(e);
+        // Client pipeline errors carry a code and were already surfaced via
+        // the onError subscription; errors thrown by user hooks
+        // (afterDownloadUpdate) bypass the pipeline and are surfaced here.
+        if (!e?.code) {
+          setLastError(e);
+          alertError(client.t('update_failed'), e.message);
+        }
+        if (options.throwError) {
+          throw e;
+        }
         return false;
       }
     },
-    [client, options, alertUpdate, alertError, throwErrorIfEnabled],
+    [client, options, alertUpdate, alertError],
   );
 
   const downloadAndInstallApk = useCallback(
@@ -161,19 +179,23 @@ export const UpdateProvider = ({
 
   const checkUpdate = useCallback(
     async ({ extra }: { extra?: Partial<{ toHash: string }> } = {}) => {
-      const now = Date.now();
-      if (lastChecking.current && now - lastChecking.current < 1000) {
-        client.notifyAfterCheckUpdate({ status: 'skipped' });
-        return;
-      }
-      lastChecking.current = now;
+      // No throttle here: the client already dedupes checks via its 5s
+      // response cache, and a second throttle layer silently returned
+      // undefined, indistinguishable from a failed check.
       let rootInfo: CheckResult | undefined;
       try {
         rootInfo = await client.checkUpdate(extra);
       } catch (e: any) {
-        setLastError(e);
-        alertError(client.t('error_update_check_failed'), e.message);
-        throwErrorIfEnabled(e);
+        // Client pipeline errors carry a code and were already surfaced via
+        // the onError subscription; errors thrown by user hooks
+        // (beforeCheckUpdate) bypass the pipeline and are surfaced here.
+        if (!e?.code) {
+          setLastError(e);
+          alertError(client.t('error_update_check_failed'), e.message);
+        }
+        if (options.throwError) {
+          throw e;
+        }
         return;
       }
       if (!rootInfo) {
@@ -255,10 +277,9 @@ export const UpdateProvider = ({
     },
     [
       client,
-      alertError,
-      throwErrorIfEnabled,
       options,
       alertUpdate,
+      alertError,
       downloadAndInstallApk,
       downloadUpdate,
     ],
@@ -274,9 +295,11 @@ export const UpdateProvider = ({
       return;
     }
     const { checkStrategy, autoMarkSuccess } = options;
+    let markSuccessTimer: ReturnType<typeof setTimeout> | undefined;
     if (autoMarkSuccess) {
-      setTimeout(() => {
-        markSuccess();
+      markSuccessTimer = setTimeout(() => {
+        // Failures are reported and surfaced via the onError subscription.
+        Promise.resolve(markSuccess()).catch(noop);
       }, 1000);
     }
     if (checkStrategy === 'both' || checkStrategy === 'onAppResume') {
@@ -293,6 +316,9 @@ export const UpdateProvider = ({
       checkUpdate().catch(noop);
     }
     return () => {
+      if (markSuccessTimer) {
+        clearTimeout(markSuccessTimer);
+      }
       stateListener.current && stateListener.current.remove();
     };
   }, [checkUpdate, options, dismissError, markSuccess, client]);
@@ -350,7 +376,8 @@ export const UpdateProvider = ({
       try {
         const payload = typeof code === 'string' ? JSON.parse(code) : code;
         return parseTestPayload(payload);
-      } catch {
+      } catch (e: any) {
+        log('parseTestQrCode: invalid payload', e?.message || e);
         return false;
       }
     },
@@ -391,28 +418,48 @@ export const UpdateProvider = ({
     };
   }, [parseTestPayload]);
 
+  // progress lives in its own context (see context.ts), so this value only
+  // changes when the update state itself changes, not on every progress tick.
+  const contextValue = useMemo(
+    () => ({
+      checkUpdate,
+      switchVersion,
+      switchVersionLater,
+      dismissError,
+      updateInfo,
+      lastError,
+      markSuccess,
+      client,
+      downloadUpdate,
+      packageVersion,
+      currentHash: currentVersion,
+      downloadAndInstallApk,
+      getCurrentVersionInfo,
+      currentVersionInfo,
+      parseTestQrCode,
+      restartApp,
+    }),
+    [
+      checkUpdate,
+      switchVersion,
+      switchVersionLater,
+      dismissError,
+      updateInfo,
+      lastError,
+      markSuccess,
+      client,
+      downloadUpdate,
+      downloadAndInstallApk,
+      parseTestQrCode,
+      restartApp,
+    ],
+  );
+
   return (
-    <UpdateContext.Provider
-      value={{
-        checkUpdate,
-        switchVersion,
-        switchVersionLater,
-        dismissError,
-        updateInfo,
-        lastError,
-        markSuccess,
-        client,
-        downloadUpdate,
-        packageVersion,
-        currentHash: currentVersion,
-        progress,
-        downloadAndInstallApk,
-        getCurrentVersionInfo,
-        currentVersionInfo,
-        parseTestQrCode,
-        restartApp,
-      }}>
-      {children}
+    <UpdateContext.Provider value={contextValue}>
+      <ProgressContext.Provider value={progress}>
+        {children}
+      </ProgressContext.Provider>
     </UpdateContext.Provider>
   );
 };

package/src/type.ts

@@ -1,3 +1,5 @@
+import type { UpdateErrorCode } from './error';
+
 export interface VersionInfo {
   name: string;
   hash: string;
@@ -52,6 +54,8 @@ export type EventType =
   | 'downloadSuccess'
   | 'errorUpdate'
   | 'markSuccess'
+  | 'errorMarkSuccess'
+  | 'errorSwitchVersion'
   | 'downloadingApk'
   | 'rejectStoragePermission'
   | 'errorStoragePermission'
@@ -59,6 +63,8 @@ export type EventType =
   | 'errorInstallApk';
 
 export interface EventData {
+  /** Stable machine-readable error code; present on error events */
+  code?: UpdateErrorCode;
   currentVersion: string;
   cInfo: {
     rnu: string;

package/src/utils.ts

@@ -22,6 +22,10 @@ export const DEFAULT_FETCH_TIMEOUT_MS = 5000;
 
 export function promiseAny<T>(promises: Promise<T>[]) {
   return new Promise<T>((resolve, reject) => {
+    if (!promises.length) {
+      reject(Error(i18n.t('error_all_promises_rejected')));
+      return;
+    }
     let count = 0;
 
     promises.forEach(promise => {
@@ -118,21 +122,50 @@ export const fetchWithTimeout = (
   params: Parameters<typeof fetch>[1],
   timeoutMs = DEFAULT_FETCH_TIMEOUT_MS,
 ): Promise<Response> => {
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-
-  return Promise.race([
-    enhancedFetch(url, params),
-    new Promise<Response>((_, reject) => {
-      timeoutId = setTimeout(() => {
-        log('fetch timeout', url);
-        reject(Error(i18n.t('error_ping_timeout')));
-      }, timeoutMs);
-    }),
-  ]).finally(() => {
-    if (timeoutId) {
+  // AbortController landed in the RN fetch polyfill around 0.60; we support
+  // older peers, so fall back to a plain timer race when it is unavailable
+  // (the losing fetch keeps running there — old runtimes can't do better).
+  if (typeof AbortController === 'undefined') {
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+    return Promise.race([
+      enhancedFetch(url, params),
+      new Promise<Response>((_, reject) => {
+        timeoutId = setTimeout(() => {
+          log('fetch timeout', url);
+          reject(Error(i18n.t('error_ping_timeout')));
+        }, timeoutMs);
+      }),
+    ]).finally(() => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    });
+  }
+
+  // Abort the underlying request on timeout instead of racing a timer: with
+  // Promise.race the losing fetch kept running (and kept the connection busy)
+  // long after the caller had already moved on.
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    log('fetch timeout', url);
+    controller.abort();
+  }, timeoutMs);
+
+  return enhancedFetch(url, { ...params, signal: controller.signal })
+    .catch((e: any) => {
+      if (controller.signal.aborted) {
+        throw Error(i18n.t('error_ping_timeout'));
+      }
+      throw e;
+    })
+    .finally(() => {
       clearTimeout(timeoutId);
-    }
-  });
+    });
+};
+
+const isIdempotentRequest = (params: Parameters<typeof fetch>[1]) => {
+  const method = params?.method?.toUpperCase() ?? 'GET';
+  return method === 'GET' || method === 'HEAD';
 };
 
 export const enhancedFetch = async (
@@ -143,10 +176,17 @@ export const enhancedFetch = async (
   return fetch(url, params)
     .catch(e => {
       log('fetch error', url, e);
-      if (isRetry) {
+      if (
+        isRetry ||
+        (params as any)?.signal?.aborted ||
+        !url.startsWith('https:') ||
+        // Never replay non-idempotent requests (e.g. the checkUpdate POST)
+        // over plaintext http: the server may have processed the original.
+        !isIdempotentRequest(params)
+      ) {
         throw e;
       }
       log('trying fallback to http');
-      return enhancedFetch(url.replace('https', 'http'), params, true);
+      return enhancedFetch(url.replace(/^https:/, 'http:'), params, true);
     });
 };

package/android/jni/DownloadTask.c

@@ -1,56 +0,0 @@
-//
-// Created by DengYun on 3/31/16.
-//
-
-#include "cn_reactnative_modules_update_DownloadTask.h"
-
-#include "hpatch.h"
-#define _check(v,errInfo) do{ if (!(v)) {  _isError=hpatch_TRUE; _errInfo=errInfo; goto _clear;  } }while(0)
-
-JNIEXPORT jbyteArray JNICALL Java_cn_reactnative_modules_update_DownloadTask_hdiffPatch
-        (JNIEnv *env, jobject self, jbyteArray origin, jbyteArray patch){
-    hpatch_BOOL  _isError=hpatch_FALSE; 
-    const char* _errInfo="";
-
-    jbyte* originPtr = (*env)->GetByteArrayElements(env, origin, NULL);
-    size_t originLength = (*env)->GetArrayLength(env, origin);
-    jbyte* patchPtr = (*env)->GetByteArrayElements(env, patch, NULL);
-    size_t patchLength = (*env)->GetArrayLength(env, patch);
-    jbyteArray ret = NULL;
-    jbyte* outPtr = NULL;
-    size_t newsize = 0;
-    hpatch_singleCompressedDiffInfo patInfo;
-
-    _check(((originLength==0)||originPtr) && patchPtr && (patchLength>0),"Corrupt patch");
-    _check(kHPatch_ok==hpatch_getInfo_by_mem(&patInfo,(const uint8_t*)patchPtr,patchLength),"Error info in hpatch");
-    _check(originLength==patInfo.oldDataSize,"Error oldDataSize in hpatch");
-    newsize=(size_t)patInfo.newDataSize;
-    if (sizeof(size_t)!=sizeof(hpatch_StreamPos_t))
-        _check(newsize==patInfo.newDataSize,"Error newDataSize in hpatch");
-    
-    ret = (*env)->NewByteArray(env,newsize);
-    _check(ret,"Error JNIEnv::NewByteArray()");
-    if (newsize>0) {
-        outPtr = (*env)->GetByteArrayElements(env, ret, NULL);
-        _check(outPtr,"Corrupt JNIEnv::GetByteArrayElements");
-    }
-
-    _check(kHPatch_ok==hpatch_by_mem((const uint8_t*)originPtr,originLength,(uint8_t*)outPtr,newsize,
-                                     (const uint8_t*)patchPtr,patchLength,&patInfo),"hpacth");
-
-_clear:
-    if (outPtr) (*env)->ReleaseByteArrayElements(env, ret, outPtr, (_isError?JNI_ABORT:0));
-    if (originPtr) (*env)->ReleaseByteArrayElements(env, origin, originPtr, JNI_ABORT);
-    if (patchPtr) (*env)->ReleaseByteArrayElements(env, patch, patchPtr, JNI_ABORT);
-    if (_isError){
-        jclass newExcCls = NULL;
-        if (ret){
-            (*env)->DeleteLocalRef(env, ret);
-            ret = NULL;
-        }
-        newExcCls = (*env)->FindClass(env, "java/lang/Error");
-        if (newExcCls != NULL) // Unable to find the new exception class, give up.
-            (*env)->ThrowNew(env, newExcCls, _errInfo);
-    }
-    return ret;
-}

package/android/jni/cn_reactnative_modules_update_DownloadTask.h

@@ -1,21 +0,0 @@
-/* DO NOT EDIT THIS FILE - it is machine generated */
-#include <jni.h>
-/* Header for class cn_reactnative_modules_update_DownloadTask */
-
-#ifndef _Included_cn_reactnative_modules_update_DownloadTask
-#define _Included_cn_reactnative_modules_update_DownloadTask
-#ifdef __cplusplus
-extern "C" {
-#endif
-/*
- * Class:     cn_reactnative_modules_update_DownloadTask
- * Method:    hdiffPatch
- * Signature: ([B[B)[B
- */
-JNIEXPORT jbyteArray JNICALL Java_cn_reactnative_modules_update_DownloadTask_hdiffPatch
-  (JNIEnv *, jclass, jbyteArray, jbyteArray);
-
-#ifdef __cplusplus
-}
-#endif
-#endif