react-native-update 10.44.0 → 10.45.0

package/android/jni/Android.mk

@@ -20,7 +20,6 @@ Hdp_Files := \
     lzma/C/Lzma2Dec.c
 
 LOCAL_SRC_FILES := \
-	DownloadTask.c \
 	../../cpp/patch_core/archive_patch_core.cpp \
 	../../cpp/patch_core/patch_core.cpp \
 	../../cpp/patch_core/patch_core_android.cpp \

package/android/src/main/java/cn/reactnative/modules/update/DownloadTask.java

@@ -33,7 +33,16 @@ class DownloadTask implements Runnable {
     // events on percentage change, so throttle by bytes to avoid flooding the
     // bridge (e.g. a 20MB chunked download would otherwise emit ~5000 events).
     private static final long PROGRESS_BYTES_THRESHOLD = 256 * 1024;
-    private static final OkHttpClient HTTP_CLIENT = new OkHttpClient();
+    // Explicit timeouts: the default client has no call timeout, so a
+    // slow-dripping connection could occupy the single-threaded download
+    // executor indefinitely and starve queued tasks. The call timeout is a
+    // generous upper bound sized for large full-package downloads.
+    private static final OkHttpClient HTTP_CLIENT = new OkHttpClient.Builder()
+            .connectTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+            .readTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .writeTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+            .callTimeout(10, java.util.concurrent.TimeUnit.MINUTES)
+            .build();
 
     static {
         NativeUpdateCore.ensureLoaded();

package/android/src/main/java/cn/reactnative/modules/update/UpdateContext.java

@@ -214,7 +214,7 @@ public class UpdateContext {
 
     public void switchVersion(String hash) {
         if (!new File(rootDir, hash+"/index.bundlejs").exists()) {
-            throw new Error("Bundle version " + hash + " not found.");
+            throw new IllegalStateException("Bundle version " + hash + " not found.");
         }
         StateCoreResult currentState = getStateSnapshot();
         StateCoreResult nextState = runStateCore(
@@ -385,7 +385,11 @@ public class UpdateContext {
             return defaultAssetsUrl;
         }
 
-        while (currentVersion != null) {
+        // Guard the rollback chain against cycles: a corrupted state returning
+        // an already-visited version would otherwise spin this loop forever on
+        // the main thread.
+        java.util.HashSet<String> visitedVersions = new java.util.HashSet<>();
+        while (currentVersion != null && visitedVersions.add(currentVersion)) {
             File bundleFile = new File(rootDir, currentVersion+"/index.bundlejs");
             if (!bundleFile.exists()) {
                 Log.e(TAG, "Bundle version " + currentVersion + " not found.");

package/android/src/main/java/cn/reactnative/modules/update/UpdateEventEmitter.java

@@ -24,7 +24,7 @@ final class UpdateEventEmitter {
 
     static void sendEvent(String eventName, WritableMap params) {
         ReactApplicationContext reactContext = getReactContext();
-        if (reactContext == null || !reactContext.hasActiveCatalystInstance()) {
+        if (reactContext == null || !hasActiveInstance(reactContext)) {
             return;
         }
 
@@ -32,4 +32,16 @@ final class UpdateEventEmitter {
             .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
             .emit(eventName, params);
     }
+
+    @SuppressWarnings("deprecation")
+    private static boolean hasActiveInstance(ReactApplicationContext reactContext) {
+        try {
+            // hasActiveCatalystInstance() is always false in bridgeless mode, which
+            // silently drops every progress event on the new architecture.
+            return reactContext.hasActiveReactInstance();
+        } catch (NoSuchMethodError e) {
+            // RN < 0.68 has no hasActiveReactInstance(); fall back for old peers.
+            return reactContext.hasActiveCatalystInstance();
+        }
+    }
 }

package/cpp/patch_core/patch_core.cpp

@@ -8,7 +8,6 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <set>
 #include <vector>
 
 extern "C" {
@@ -17,6 +16,11 @@ extern "C" {
 
 namespace pushy {
 namespace patch {
+
+namespace internal {
+bool g_disable_hard_links = false;
+}  // namespace internal
+
 namespace {
 
 constexpr size_t kCopyBufferSize = 16 * 1024;
@@ -202,6 +206,17 @@ Status CopyFile(const std::string& from, const std::string& to, bool overwrite)
     }
   }
 
+  // Prefer a hard link over copying bytes: unchanged files between versions
+  // are identical, so linking is O(1) per file, writes nothing to flash, and
+  // shares disk blocks. Version directories are immutable once created (patch
+  // outputs are always written as new files), so sharing the inode with the
+  // source is safe. Fall back to a byte copy whenever linking is not possible
+  // (cross-device source such as the installed app bundle, EPERM, EMLINK, or
+  // filesystems without hard-link support).
+  if (!internal::g_disable_hard_links && link(from.c_str(), to.c_str()) == 0) {
+    return Status::Ok();
+  }
+
   FILE* source = std::fopen(from.c_str(), "rb");
   if (!source) {
     return MakeErrnoStatus("Failed to open source file " + from);

package/cpp/patch_core/patch_core.h

@@ -64,5 +64,11 @@ Status CleanupOldEntries(
 
 bool IsSafeRelativePath(const std::string& path);
 
+namespace internal {
+// Test-only escape hatch: forces file copies to take the byte-copy fallback
+// instead of hard-linking, so tests can cover both paths on one filesystem.
+extern bool g_disable_hard_links;
+}  // namespace internal
+
 }  // namespace patch
 }  // namespace pushy

package/cpp/patch_core/tests/patch_core_test.cpp

@@ -175,6 +175,81 @@ void TestApplyPatchFromFileSourceMergesAndCopies() {
   Expect(!Exists(JoinPath(target, "assets/delete.txt")), "deleted asset should not be copied");
 }
 
+void TestApplyPatchMergeHardLinksUnchangedFiles() {
+  TempDir temp;
+  const std::string source = JoinPath(temp.path, "origin");
+  const std::string target = JoinPath(temp.path, "target");
+  const std::string patch = JoinPath(temp.path, "bundle.patch");
+
+  WriteFile(JoinPath(source, "index.bundlejs"), "old bundle");
+  WriteFile(JoinPath(source, "assets/keep.txt"), "keep");
+  WriteFile(patch, "unused patch");
+
+  FakeBundlePatcher patcher("patched bundle");
+  FileSourcePatchOptions options;
+  options.source_root = source;
+  options.target_root = target;
+  options.origin_bundle_path = JoinPath(source, "index.bundlejs");
+  options.bundle_patch_path = patch;
+  options.bundle_output_path = JoinPath(target, "index.bundlejs");
+  options.manifest.copies.push_back(CopyOperation{"assets/keep.txt", "assets/copied.txt"});
+
+  Status status = ApplyPatchFromFileSource(options, patcher);
+  Expect(status.ok, status.message);
+
+  // Unchanged files must share the source inode (hard link) instead of being
+  // byte-copied: same filesystem, so the fast path has to kick in.
+  struct stat source_stat;
+  struct stat merged_stat;
+  struct stat copied_stat;
+  Expect(stat(JoinPath(source, "assets/keep.txt").c_str(), &source_stat) == 0, "stat source");
+  Expect(stat(JoinPath(target, "assets/keep.txt").c_str(), &merged_stat) == 0, "stat merged");
+  Expect(stat(JoinPath(target, "assets/copied.txt").c_str(), &copied_stat) == 0, "stat copied");
+  Expect(merged_stat.st_ino == source_stat.st_ino, "merged file should hard-link the source");
+  Expect(copied_stat.st_ino == source_stat.st_ino, "manifest copy should hard-link the source");
+  Expect(source_stat.st_nlink >= 3, "source should have three names");
+  ExpectEq(ReadFile(JoinPath(target, "assets/keep.txt")), "keep", "merged content mismatch");
+
+  // The patched bundle must be a fresh file, never a link into the source dir.
+  struct stat bundle_stat;
+  struct stat origin_stat;
+  Expect(stat(JoinPath(target, "index.bundlejs").c_str(), &bundle_stat) == 0, "stat bundle");
+  Expect(stat(JoinPath(source, "index.bundlejs").c_str(), &origin_stat) == 0, "stat origin bundle");
+  Expect(bundle_stat.st_ino != origin_stat.st_ino, "patched bundle must not link the origin");
+}
+
+void TestApplyPatchMergeFallsBackToByteCopy() {
+  TempDir temp;
+  const std::string source = JoinPath(temp.path, "origin");
+  const std::string target = JoinPath(temp.path, "target");
+  const std::string patch = JoinPath(temp.path, "bundle.patch");
+
+  WriteFile(JoinPath(source, "index.bundlejs"), "old bundle");
+  WriteFile(JoinPath(source, "assets/keep.txt"), "keep");
+  WriteFile(patch, "unused patch");
+
+  FakeBundlePatcher patcher("patched bundle");
+  FileSourcePatchOptions options;
+  options.source_root = source;
+  options.target_root = target;
+  options.origin_bundle_path = JoinPath(source, "index.bundlejs");
+  options.bundle_patch_path = patch;
+  options.bundle_output_path = JoinPath(target, "index.bundlejs");
+
+  pushy::patch::internal::g_disable_hard_links = true;
+  Status status = ApplyPatchFromFileSource(options, patcher);
+  pushy::patch::internal::g_disable_hard_links = false;
+  Expect(status.ok, status.message);
+
+  struct stat source_stat;
+  struct stat merged_stat;
+  Expect(stat(JoinPath(source, "assets/keep.txt").c_str(), &source_stat) == 0, "stat source");
+  Expect(stat(JoinPath(target, "assets/keep.txt").c_str(), &merged_stat) == 0, "stat merged");
+  Expect(merged_stat.st_ino != source_stat.st_ino, "fallback should produce an independent copy");
+  Expect(merged_stat.st_nlink == 1, "fallback copy should have a single name");
+  ExpectEq(ReadFile(JoinPath(target, "assets/keep.txt")), "keep", "fallback content mismatch");
+}
+
 void TestApplyPatchFromFileSourceCanLimitMergeSubdir() {
   TempDir temp;
   const std::string source = JoinPath(temp.path, "origin");
@@ -537,6 +612,8 @@ void TestStateCoreSwitchToSameVersion() {
 int main() {
   const std::vector<std::pair<std::string, void (*)()>> tests = {
       {"ApplyPatchFromFileSourceMergesAndCopies", TestApplyPatchFromFileSourceMergesAndCopies},
+      {"ApplyPatchMergeHardLinksUnchangedFiles", TestApplyPatchMergeHardLinksUnchangedFiles},
+      {"ApplyPatchMergeFallsBackToByteCopy", TestApplyPatchMergeFallsBackToByteCopy},
       {"ApplyPatchFromFileSourceCanLimitMergeSubdir", TestApplyPatchFromFileSourceCanLimitMergeSubdir},
       {"ApplyPatchFromFileSourceRejectsUnsafePaths", TestApplyPatchFromFileSourceRejectsUnsafePaths},
       {"CleanupOldEntriesRemovesOnlyExpiredPaths", TestCleanupOldEntriesRemovesOnlyExpiredPaths},

package/harmony/pushy/src/main/cpp/pushy.cpp

@@ -11,7 +11,6 @@
 #include "state_ops.h"
 
 extern "C" {
-#include "hpatch.h"
 }
 
 namespace {
@@ -407,96 +406,6 @@ pushy::patch::PatchManifest BuildManifest(
   return manifest;
 }
 
-napi_value HdiffPatch(napi_env env, napi_callback_info info) {
-  napi_value args[2] = {nullptr, nullptr};
-  size_t argc = 2;
-  if (!GetArgCount(env, info, &argc, args) || argc < 2) {
-    ThrowError(env, "Wrong number of arguments");
-    return nullptr;
-  }
-
-  bool is_typed_array = false;
-  if (napi_is_typedarray(env, args[0], &is_typed_array) != napi_ok || !is_typed_array) {
-    ThrowError(env, "First argument must be a TypedArray");
-    return nullptr;
-  }
-
-  uint8_t* origin_ptr = nullptr;
-  size_t origin_length = 0;
-  if (napi_get_typedarray_info(
-          env,
-          args[0],
-          nullptr,
-          &origin_length,
-          reinterpret_cast<void**>(&origin_ptr),
-          nullptr,
-          nullptr) != napi_ok) {
-    ThrowError(env, "Failed to get origin buffer");
-    return nullptr;
-  }
-
-  if (napi_is_typedarray(env, args[1], &is_typed_array) != napi_ok || !is_typed_array) {
-    ThrowError(env, "Second argument must be a TypedArray");
-    return nullptr;
-  }
-
-  uint8_t* patch_ptr = nullptr;
-  size_t patch_length = 0;
-  if (napi_get_typedarray_info(
-          env,
-          args[1],
-          nullptr,
-          &patch_length,
-          reinterpret_cast<void**>(&patch_ptr),
-          nullptr,
-          nullptr) != napi_ok) {
-    ThrowError(env, "Failed to get patch buffer");
-    return nullptr;
-  }
-
-  hpatch_singleCompressedDiffInfo patch_info;
-  if (!((origin_length == 0) || origin_ptr) || !patch_ptr || patch_length == 0) {
-    ThrowError(env, "Corrupt patch");
-    return nullptr;
-  }
-  if (kHPatch_ok != hpatch_getInfo_by_mem(&patch_info, patch_ptr, patch_length)) {
-    ThrowError(env, "Error info in hpatch");
-    return nullptr;
-  }
-  if (origin_length != patch_info.oldDataSize) {
-    ThrowError(env, "Error oldDataSize in hpatch");
-    return nullptr;
-  }
-
-  size_t new_size = static_cast<size_t>(patch_info.newDataSize);
-  if (sizeof(size_t) != sizeof(hpatch_StreamPos_t) &&
-      new_size != patch_info.newDataSize) {
-    ThrowError(env, "Error newDataSize in hpatch");
-    return nullptr;
-  }
-
-  void* output_data = nullptr;
-  napi_value result = nullptr;
-  if (napi_create_arraybuffer(env, new_size, &output_data, &result) != napi_ok) {
-    ThrowError(env, "Failed to create result buffer");
-    return nullptr;
-  }
-
-  if (kHPatch_ok != hpatch_by_mem(
-                       origin_ptr,
-                       origin_length,
-                       static_cast<uint8_t*>(output_data),
-                       new_size,
-                       patch_ptr,
-                       patch_length,
-                       &patch_info)) {
-    ThrowError(env, "hpatch");
-    return nullptr;
-  }
-
-  return result;
-}
-
 napi_value SyncStateWithBinaryVersion(napi_env env, napi_callback_info info) {
   napi_value args[3] = {nullptr, nullptr, nullptr};
   size_t argc = 3;
@@ -968,8 +877,7 @@ bool ExportFunction(
 }  // namespace
 
 napi_value Init(napi_env env, napi_value exports) {
-  if (!ExportFunction(env, exports, "hdiffPatch", HdiffPatch) ||
-      !ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
+  if (!ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
       !ExportFunction(env, exports, "runStateCore", RunStateCore) ||
       !ExportFunction(env, exports, "buildArchivePatchPlan", BuildArchivePatchPlan) ||
       !ExportFunction(env, exports, "buildCopyGroups", BuildCopyGroups) ||

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

@@ -69,7 +69,7 @@ const FILE_COPY_BUFFER_SIZE = 64 * 1024;
 
 export class DownloadTask {
   private context: common.Context;
-  private hash: string;
+  private hash = '';
   private eventHub: EventHub;
 
   constructor(context: common.Context) {
@@ -244,7 +244,7 @@ export class DownloadTask {
         bundleOutputPath: outputFile,
         enableMerge: false,
       });
-    } catch (error) {
+    } catch (error: any) {
       error.message = `Failed to process bundle patch: ${error.message}`;
       throw error;
     } finally {
@@ -395,17 +395,18 @@ export class DownloadTask {
         fileIo.OpenMode.CREATE | fileIo.OpenMode.READ_WRITE,
       );
 
-      httpRequest.on('headersReceive', (header: Record<string, string>) => {
+      httpRequest.on('headersReceive', (header: Object) => {
         if (!header) {
           return;
         }
-        const lengthKey = Object.keys(header).find(
+        const headers = header as Record<string, string>;
+        const lengthKey = Object.keys(headers).find(
           key => key.toLowerCase() === 'content-length',
         );
         if (!lengthKey) {
           return;
         }
-        const length = parseInt(header[lengthKey], 10);
+        const length = parseInt(headers[lengthKey], 10);
         if (!Number.isNaN(length)) {
           contentLength = length;
         }
@@ -606,9 +607,11 @@ export class DownloadTask {
         }
 
         if (currentFrom.startsWith('resources/base/media/')) {
+          // Strip only the final extension: 'icon.round.png' -> 'icon.round',
+          // not 'icon' (getMediaByName expects the full resource name).
           const mediaName = currentFrom
             .replace('resources/base/media/', '')
-            .split('.')[0];
+            .replace(/\.[^.]+$/, '');
           const mediaBuffer = await resourceManager.getMediaByName(mediaName);
           const parentDirs = [
             ...new Set(
@@ -649,7 +652,7 @@ export class DownloadTask {
           }
         }
       }
-    } catch (error) {
+    } catch (error: any) {
       error.message =
         'Copy from resource failed:' +
         currentFrom +
@@ -670,7 +673,7 @@ export class DownloadTask {
         params.originHash || '',
         3,
       );
-    } catch (error) {
+    } catch (error: any) {
       error.message = 'Cleanup failed:' + error.message;
       console.error(error);
       throw error;
@@ -698,7 +701,7 @@ export class DownloadTask {
         default:
           throw Error(`Unknown task type: ${params.type}`);
       }
-    } catch (error) {
+    } catch (error: any) {
       console.error('Task execution failed:', error.message);
       if (params.type !== DownloadTaskParams.TASK_TYPE_CLEANUP) {
         try {
@@ -707,7 +710,7 @@ export class DownloadTask {
           } else {
             await this.removeDirectory(params.unzipDirectory);
           }
-        } catch (cleanupError) {
+        } catch (cleanupError: any) {
           console.error('Cleanup after error failed:', cleanupError.message);
         }
       }

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

@@ -50,10 +50,6 @@ export interface FileSourcePatchRequest {
 }
 
 interface NativePatchCoreBindings {
-  hdiffPatch(
-    origin: Uint8Array,
-    patch: Uint8Array,
-  ): ArrayBuffer | Uint8Array;
   syncStateWithBinaryVersion(
     packageVersion: string,
     buildTime: string,

package/ios/RCTPushy/RCTPushy.mm

@@ -14,6 +14,9 @@
 
 #import <React/RCTConvert.h>
 #import <React/RCTLog.h>
+#import <os/lock.h>
+
+#include <atomic>
 
 static NSString *const keyPushyInfo = @"REACTNATIVECN_PUSHY_INFO_KEY";
 static NSString *const paramPackageVersion = @"packageVersion";
@@ -52,7 +55,20 @@ typedef NS_ENUM(NSInteger, PushyType) {
     //TASK_TYPE_PLAIN_DOWNLOAD=4?
 };
 
-static BOOL ignoreRollback = false;
+static std::atomic<bool> ignoreRollback{false};
+
+// Serializes every read-modify-write of the persisted update state. The state
+// machine itself is a pure function (state_core), but callers run on different
+// threads (main thread bundleURL, module method queue, _fileQueue), so the
+// read→transform→write sequence must be atomic to avoid e.g. markSuccess being
+// overwritten by a concurrent bundleURL and the version being rolled back.
+static os_unfair_lock pushyStateLock = OS_UNFAIR_LOCK_INIT;
+
+static void PushyWithStateLock(void (NS_NOESCAPE ^block)(void)) {
+    os_unfair_lock_lock(&pushyStateLock);
+    block();
+    os_unfair_lock_unlock(&pushyStateLock);
+}
 
 static std::string PushyToStdString(NSString *value) {
     if (value == nil) {
@@ -221,64 +237,71 @@ RCT_EXPORT_MODULE(RCTPushy);
 
 + (NSURL *)bundleURL
 {
-    NSUserDefaults *defaults = PushyDefaults();
-    
-    NSString *curPackageVersion = [RCTPushy packageVersion];
-    NSString *curBuildTime = [RCTPushy buildTime];
-    
-    pushy::state::State state = PushyStateFromDefaults(defaults);
-    pushy::state::BinaryVersionSyncResult sync = pushy::state::SyncBinaryVersion(
-        state,
-        PushyToStdString(curPackageVersion),
-        PushyToStdString(curBuildTime)
-    );
-    if (sync.changed) {
-        [defaults setObject:@(YES) forKey:KeyPackageUpdatedMarked];
-        state = sync.state;
-        PushyApplyStateToDefaults(defaults, state);
-    }
+    __block NSURL *resolvedURL = nil;
+    PushyWithStateLock(^{
+        NSUserDefaults *defaults = PushyDefaults();
+
+        NSString *curPackageVersion = [RCTPushy packageVersion];
+        NSString *curBuildTime = [RCTPushy buildTime];
 
-    if (!state.current_version.empty()) {
-        pushy::state::LaunchDecision decision = pushy::state::ResolveLaunchState(
+        pushy::state::State state = PushyStateFromDefaults(defaults);
+        pushy::state::BinaryVersionSyncResult sync = pushy::state::SyncBinaryVersion(
             state,
-            ignoreRollback,
-            true
+            PushyToStdString(curPackageVersion),
+            PushyToStdString(curBuildTime)
         );
-        state = decision.state;
-
-        if (decision.did_rollback || decision.consumed_first_time) {
+        if (sync.changed) {
+            [defaults setObject:@(YES) forKey:KeyPackageUpdatedMarked];
+            state = sync.state;
             PushyApplyStateToDefaults(defaults, state);
         }
-        if (decision.consumed_first_time) {
-            // bundleURL may be called many times, ignore rollbacks before process restarted again.
-            ignoreRollback = true;
-            [defaults setObject:@(YES) forKey:keyFirstLoadMarked];
-        }
 
-        NSString *loadVersion = PushyFromStdString(decision.load_version);
-        NSString *downloadDir = [RCTPushy downloadDir];
-        while (loadVersion.length) {
-            NSString *bundlePath = [[downloadDir stringByAppendingPathComponent:loadVersion] stringByAppendingPathComponent:BUNDLE_FILE_NAME];
-            if ([[NSFileManager defaultManager] fileExistsAtPath:bundlePath isDirectory:NULL]) {
-                NSURL *bundleURL = [NSURL fileURLWithPath:bundlePath];
-                return bundleURL;
-            } else {
-                RCTLogError(@"RCTPushy -- bundle version %@ not found", loadVersion);
-                state = pushy::state::Rollback(state);
+        if (!state.current_version.empty()) {
+            pushy::state::LaunchDecision decision = pushy::state::ResolveLaunchState(
+                state,
+                ignoreRollback.load(),
+                true
+            );
+            state = decision.state;
+
+            if (decision.did_rollback || decision.consumed_first_time) {
                 PushyApplyStateToDefaults(defaults, state);
-                loadVersion = PushyFromStdString(state.current_version);
+            }
+            if (decision.consumed_first_time) {
+                // bundleURL may be called many times, ignore rollbacks before process restarted again.
+                ignoreRollback = true;
+                [defaults setObject:@(YES) forKey:keyFirstLoadMarked];
+            }
+
+            NSString *loadVersion = PushyFromStdString(decision.load_version);
+            NSString *downloadDir = [RCTPushy downloadDir];
+            while (loadVersion.length) {
+                NSString *bundlePath = [[downloadDir stringByAppendingPathComponent:loadVersion] stringByAppendingPathComponent:BUNDLE_FILE_NAME];
+                if ([[NSFileManager defaultManager] fileExistsAtPath:bundlePath isDirectory:NULL]) {
+                    resolvedURL = [NSURL fileURLWithPath:bundlePath];
+                    return;
+                } else {
+                    RCTLogError(@"RCTPushy -- bundle version %@ not found", loadVersion);
+                    state = pushy::state::Rollback(state);
+                    PushyApplyStateToDefaults(defaults, state);
+                    loadVersion = PushyFromStdString(state.current_version);
+                }
             }
         }
-    }
-    
-    return [RCTPushy binaryBundleURL];
+    });
+
+    return resolvedURL ?: [RCTPushy binaryBundleURL];
 }
 
 + (NSString *) rollback {
-    NSUserDefaults *defaults = PushyDefaults();
-    pushy::state::State state = pushy::state::Rollback(PushyStateFromDefaults(defaults));
-    PushyApplyStateToDefaults(defaults, state);
-    return PushyFromStdString(state.current_version);
+    __block NSString *currentVersion = nil;
+    PushyWithStateLock(^{
+        NSUserDefaults *defaults = PushyDefaults();
+        pushy::state::State state = pushy::state::Rollback(PushyStateFromDefaults(defaults));
+        PushyApplyStateToDefaults(defaults, state);
+        currentVersion = PushyFromStdString(state.current_version);
+    });
+    return currentVersion;
 }
 
 + (BOOL)requiresMainQueueSetup
@@ -288,36 +311,37 @@ RCT_EXPORT_MODULE(RCTPushy);
 
 - (NSDictionary *)constantsToExport
 {
-    NSUserDefaults *defaults = PushyDefaults();
-    
     NSMutableDictionary *ret = [NSMutableDictionary new];
-    ret[@"downloadRootDir"] = [RCTPushy downloadDir];
-    ret[@"packageVersion"] = [RCTPushy packageVersion];
-    ret[@"buildTime"] = [RCTPushy buildTime];
-    ret[@"rolledBackVersion"] = [defaults objectForKey:keyRolledBackMarked];
-    ret[@"isFirstTime"] = [defaults objectForKey:keyFirstLoadMarked];
-    ret[@"uuid"] = [defaults objectForKey:keyUuid];
-    NSDictionary *pushyInfo = [defaults dictionaryForKey:keyPushyInfo];
-    NSString *currentVersion = [pushyInfo objectForKey:paramCurrentVersion];
-    ret[@"currentVersion"] = currentVersion;
-    if (currentVersion != nil) {
-        ret[@"currentVersionInfo"] = [defaults objectForKey:PushyHashInfoKey(currentVersion)];
-    }
-    
-    if (ret[@"isFirstTime"]) {
-        [defaults removeObjectForKey:keyFirstLoadMarked];
-    }
-    
-    if (ret[@"rolledBackVersion"] != nil) {
-        [defaults removeObjectForKey:keyRolledBackMarked];
-        [self clearInvalidFiles];
-    }
-    
-    if ([[defaults objectForKey:KeyPackageUpdatedMarked] boolValue]) {
-        [defaults removeObjectForKey:KeyPackageUpdatedMarked];
-        [self clearInvalidFiles];
-    }
-    
+    PushyWithStateLock(^{
+        NSUserDefaults *defaults = PushyDefaults();
+
+        ret[@"downloadRootDir"] = [RCTPushy downloadDir];
+        ret[@"packageVersion"] = [RCTPushy packageVersion];
+        ret[@"buildTime"] = [RCTPushy buildTime];
+        ret[@"rolledBackVersion"] = [defaults objectForKey:keyRolledBackMarked];
+        ret[@"isFirstTime"] = [defaults objectForKey:keyFirstLoadMarked];
+        ret[@"uuid"] = [defaults objectForKey:keyUuid];
+        NSDictionary *pushyInfo = [defaults dictionaryForKey:keyPushyInfo];
+        NSString *currentVersion = [pushyInfo objectForKey:paramCurrentVersion];
+        ret[@"currentVersion"] = currentVersion;
+        if (currentVersion != nil) {
+            ret[@"currentVersionInfo"] = [defaults objectForKey:PushyHashInfoKey(currentVersion)];
+        }
+
+        if (ret[@"isFirstTime"]) {
+            [defaults removeObjectForKey:keyFirstLoadMarked];
+        }
+
+        if (ret[@"rolledBackVersion"] != nil) {
+            [defaults removeObjectForKey:keyRolledBackMarked];
+            [self clearInvalidFiles];
+        }
+
+        if ([[defaults objectForKey:KeyPackageUpdatedMarked] boolValue]) {
+            [defaults removeObjectForKey:KeyPackageUpdatedMarked];
+            [self clearInvalidFiles];
+        }
+    });
 
     return ret;
 }
@@ -438,13 +462,15 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
     resolve(@true);
     #else
 
-    NSUserDefaults *defaults = PushyDefaults();
-    pushy::state::MarkSuccessResult result =
-        pushy::state::MarkSuccess(PushyStateFromDefaults(defaults));
-    if (!result.stale_version_to_delete.empty()) {
-        [defaults removeObjectForKey:PushyHashInfoKey(PushyFromStdString(result.stale_version_to_delete))];
-    }
-    PushyApplyStateToDefaults(defaults, result.state);
+    PushyWithStateLock(^{
+        NSUserDefaults *defaults = PushyDefaults();
+        pushy::state::MarkSuccessResult result =
+            pushy::state::MarkSuccess(PushyStateFromDefaults(defaults));
+        if (!result.stale_version_to_delete.empty()) {
+            [defaults removeObjectForKey:PushyHashInfoKey(PushyFromStdString(result.stale_version_to_delete))];
+        }
+        PushyApplyStateToDefaults(defaults, result.state);
+    });
 
     [self clearInvalidFiles];
     resolve(@true);
@@ -674,38 +700,39 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
         return NO;
     }
 
-    NSUserDefaults *defaults = PushyDefaults();
-    pushy::state::State next = pushy::state::SwitchVersion(
-        PushyStateFromDefaults(defaults),
-        PushyToStdString(hash)
-    );
-    PushyApplyStateToDefaults(defaults, next);
-    // Re-enable first-load consumption and rollback checks for the newly selected bundle.
-    ignoreRollback = false;
+    PushyWithStateLock(^{
+        NSUserDefaults *defaults = PushyDefaults();
+        pushy::state::State next = pushy::state::SwitchVersion(
+            PushyStateFromDefaults(defaults),
+            PushyToStdString(hash)
+        );
+        PushyApplyStateToDefaults(defaults, next);
+        // Re-enable first-load consumption and rollback checks for the newly selected bundle.
+        ignoreRollback = false;
+    });
     return YES;
 }
 
 - (BOOL)ensureDirectoryExistsAtPath:(NSString *)path
 {
-    __block BOOL success = NO;
-
-    dispatch_sync(_fileQueue, ^{
-        NSFileManager *fileManager = [NSFileManager defaultManager];
-        BOOL isDirectory = NO;
-        if ([fileManager fileExistsAtPath:path isDirectory:&isDirectory]) {
-            success = isDirectory;
-            return;
-        }
+    // No _fileQueue hop here: that queue also runs multi-second unzip/patch
+    // work, and a dispatch_sync onto it would block the whole module method
+    // queue for the duration. createDirectoryAtPath is idempotent and
+    // thread-safe, so checking inline is fine.
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    BOOL isDirectory = NO;
+    if ([fileManager fileExistsAtPath:path isDirectory:&isDirectory]) {
+        return isDirectory;
+    }
 
-        NSError *error = nil;
-        success = [fileManager createDirectoryAtPath:path
-                         withIntermediateDirectories:YES
-                                          attributes:nil
-                                               error:&error];
-        if (!success && error != nil) {
-            RCTLogWarn(@"Pushy create directory error: %@", error.localizedDescription);
-        }
-    });
+    NSError *error = nil;
+    BOOL success = [fileManager createDirectoryAtPath:path
+                          withIntermediateDirectories:YES
+                                           attributes:nil
+                                                error:&error];
+    if (!success && error != nil) {
+        RCTLogWarn(@"Pushy create directory error: %@", error.localizedDescription);
+    }
 
     return success;
 }
@@ -741,8 +768,12 @@ RCT_EXPORT_METHOD(markSuccess:(RCTPromiseResolveBlock)resolve
 - (void)clearInvalidFiles
 {
     dispatch_async(_fileQueue, ^{
-        NSUserDefaults *defaults = PushyDefaults();
-        pushy::state::State state = PushyStateFromDefaults(defaults);
+        // Snapshot the state under the lock, but run the (slow) filesystem
+        // cleanup outside of it so state operations are not blocked.
+        __block pushy::state::State state;
+        PushyWithStateLock(^{
+            state = PushyStateFromDefaults(PushyDefaults());
+        });
         NSString *downloadDir = [RCTPushy downloadDir];
         pushy::patch::Status status = pushy::patch::CleanupOldEntries(
             PushyToStdString(downloadDir),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.44.0",
+  "version": "10.45.0",
   "description": "react-native hot update",
   "main": "src/index",
   "types": "src/index.ts",
@@ -9,12 +9,13 @@
     "publish:local": "SKIP_NATIVE_BUILD=1 npm publish",
     "postinstall": "node scripts/check-expo-version.js",
     "prepack": "bun submodule && bun lint",
-    "lint": "eslint \"src/*.@(ts|tsx|js|jsx)\" && tsc --noEmit",
+    "lint": "eslint \"src/*.@(ts|tsx|js|jsx)\" && tsc --noEmit && node scripts/check-harmony-types.js",
+    "lint:harmony": "node scripts/check-harmony-types.js",
     "submodule": "git submodule update --init --recursive",
     "test": "bun test src/__tests__",
     "test:patch-core": "./scripts/test-patch-core.sh",
     "build:harmony-har": "node scripts/build-harmony-har.js",
-    "build:so": "bun submodule && $ANDROID_HOME/ndk/28.2.13676358/ndk-build NDK_PROJECT_PATH=android APP_BUILD_SCRIPT=android/jni/Android.mk NDK_APPLICATION_MK=android/jni/Application.mk NDK_LIBS_OUT=android/lib",
+    "build:so": "bun submodule && bash scripts/build-android-so.sh",
     "build:ios-debug": "cd Example/e2etest && bun && detox build --configuration ios.sim.debug",
     "build:ios-release": "cd Example/e2etest && bun && detox build --configuration ios.sim.release",
     "test:ios-debug": "cd Example/e2etest && E2E_PLATFORM=ios detox test --configuration ios.sim.debug",
@@ -68,6 +69,7 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^25.5.0",
     "@types/react": "^19.2.14",
+    "@types/react-test-renderer": "18.0.7",
     "detox": "^20.50.1",
     "eslint": "^8.57.0",
     "firebase-tools": "^15.11.0",
@@ -76,6 +78,7 @@
     "prettier": "^2",
     "react": "18.2.0",
     "react-native": "0.73",
+    "react-test-renderer": "18.2.0",
     "ts-jest": "^29.4.6",
     "typescript": "^5.6.3"
   }

package/src/client.ts

@@ -191,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) {
@@ -454,17 +470,6 @@ export class Pushy {
       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,

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';

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,7 +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) => {
@@ -161,12 +161,9 @@ 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);
@@ -274,8 +271,9 @@ export const UpdateProvider = ({
       return;
     }
     const { checkStrategy, autoMarkSuccess } = options;
+    let markSuccessTimer: ReturnType<typeof setTimeout> | undefined;
     if (autoMarkSuccess) {
-      setTimeout(() => {
+      markSuccessTimer = setTimeout(() => {
         markSuccess();
       }, 1000);
     }
@@ -293,6 +291,9 @@ export const UpdateProvider = ({
       checkUpdate().catch(noop);
     }
     return () => {
+      if (markSuccessTimer) {
+        clearTimeout(markSuccessTimer);
+      }
       stateListener.current && stateListener.current.remove();
     };
   }, [checkUpdate, options, dismissError, markSuccess, client]);
@@ -391,28 +392,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/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