react-native-update 10.43.3 → 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/BundledResourceCopier.java

@@ -92,6 +92,10 @@ final class BundledResourceCopier {
             SafeZipFile baseZipFile = zipFileMap.get(context.getPackageResourcePath());
             HashMap<String, ArrayList<File>> remainingFiles =
                 new HashMap<String, ArrayList<File>>(resToCopy);
+            // Track copies that were located but failed to write. These are real
+            // failures (disk full, corrupt archive) that must fail the update,
+            // not skips — otherwise the update activates with missing resources.
+            ArrayList<String> failedCopies = new ArrayList<String>();
 
             for (String fromPath : new ArrayList<String>(remainingFiles.keySet())) {
                 ArrayList<File> targets = remainingFiles.get(fromPath);
@@ -168,23 +172,31 @@ final class BundledResourceCopier {
                         }
                         lastTarget = target;
                     } catch (IOException e) {
-                        if (UpdateContext.DEBUG) {
-                            Log.w(
-                                UpdateContext.TAG,
-                                "Failed to copy resource "
-                                    + actualSourcePath
-                                    + " to "
-                                    + target
-                                    + ": "
-                                    + e.getMessage()
-                            );
-                        }
+                        // A located resource that fails to write is a hard
+                        // failure, not a skip: record it and fail the update
+                        // after the loop so a broken update is not activated.
+                        Log.e(
+                            UpdateContext.TAG,
+                            "Failed to copy resource "
+                                + actualSourcePath
+                                + " to "
+                                + target,
+                            e
+                        );
+                        failedCopies.add(actualSourcePath + " -> " + target);
                     }
                 }
                 remainingFiles.remove(fromPath);
             }
 
-            if (!remainingFiles.isEmpty() && UpdateContext.DEBUG) {
+            if (!failedCopies.isEmpty()) {
+                throw new IOException(
+                    "Failed to copy " + failedCopies.size()
+                        + " bundled resource(s): " + failedCopies
+                );
+            }
+
+            if (!remainingFiles.isEmpty()) {
                 Log.w(
                     UpdateContext.TAG,
                     "Skipped " + remainingFiles.size() + " missing bundled resources"

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

@@ -29,7 +29,20 @@ import org.json.JSONTokener;
 
 class DownloadTask implements Runnable {
     private static final int DOWNLOAD_CHUNK_SIZE = 4096;
-    private static final OkHttpClient HTTP_CLIENT = new OkHttpClient();
+    // When the server does not report Content-Length we cannot key progress
+    // 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;
+    // 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();
@@ -98,6 +111,7 @@ class DownloadTask implements Runnable {
             long bytesRead;
             long received = 0;
             int currentPercentage = 0;
+            long lastPostedBytes = 0;
 
             try (
                 BufferedSource source = body.source();
@@ -113,7 +127,8 @@ class DownloadTask implements Runnable {
                             currentPercentage = percentage;
                             postProgress(received, contentLength);
                         }
-                    } else {
+                    } else if (received - lastPostedBytes >= PROGRESS_BYTES_THRESHOLD) {
+                        lastPostedBytes = received;
                         postProgress(received, contentLength);
                     }
                 }
@@ -394,19 +409,28 @@ class DownloadTask implements Runnable {
                 default:
                     break;
             }
-
-            if (params.listener != null) {
-                params.listener.onDownloadCompleted(params);
-            }
         } catch (Throwable error) {
-            if (UpdateContext.DEBUG) {
-                Log.e(UpdateContext.TAG, "download task failed", error);
-            }
+            Log.e(UpdateContext.TAG, "download task failed", error);
             cleanUpAfterFailure(taskType);
 
             if (params.listener != null) {
                 params.listener.onDownloadFailed(error);
             }
+            return;
+        }
+
+        // The task itself succeeded. Run the completion callback outside the
+        // try/catch above so an exception thrown by the callback (e.g. a
+        // FileProvider misconfiguration during installApk) is not mistaken for
+        // a download failure that deletes the successfully downloaded file and
+        // settles the promise a second time.
+        if (params.listener != null) {
+            try {
+                params.listener.onDownloadCompleted(params);
+            } catch (Throwable error) {
+                Log.e(UpdateContext.TAG, "download completion callback failed", error);
+                params.listener.onDownloadFailed(error);
+            }
         }
     }
 

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

@@ -75,7 +75,13 @@ final class ReactReloadManager {
                     currentReactHost,
                     createBundleLoader(application, updateBundlePath, true)
                 );
-            } catch (Throwable ignored) {
+            } catch (Throwable reloadError) {
+                Log.e(
+                    UpdateContext.TAG,
+                    "Failed to reload via ReactHost, falling back to Activity.recreate() "
+                        + "(this may load the previous bundle until next cold start)",
+                    reloadError
+                );
                 currentActivity.recreate();
             }
         }
@@ -172,6 +178,7 @@ final class ReactReloadManager {
                     }
                 }
             } catch (Throwable ignored) {
+                Log.w(UpdateContext.TAG, "getReactHost via ReactDelegate reflection failed", ignored);
             }
         }
 
@@ -179,6 +186,7 @@ final class ReactReloadManager {
             Method getReactHostMethod = application.getClass().getMethod("getReactHost");
             return getReactHostMethod.invoke(application);
         } catch (Throwable ignored) {
+            Log.w(UpdateContext.TAG, "getReactHost via Application.getReactHost() failed", ignored);
         }
 
         return null;

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

@@ -0,0 +1,64 @@
+package cn.reactnative.modules.update;
+
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Promise;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+/**
+ * Runs state-persistence operations (switchVersion / markSuccess / setUuid /
+ * setLocalHashInfo) on a dedicated single background thread.
+ *
+ * These operations only read/modify SharedPreferences via a synchronous
+ * commit(); they were previously dispatched to the UI thread purely to
+ * serialize them. markSuccess in particular runs on every cold start, so doing
+ * its blocking disk write on the main thread caused jank/ANR on low-end
+ * devices. A single-thread executor preserves the same serialization guarantee
+ * while keeping the disk I/O off the UI thread.
+ *
+ * Note: reload/restart operations must still run on the UI thread and therefore
+ * keep using {@link UiThreadRunner}.
+ */
+final class StateSerialRunner {
+    interface Operation {
+        void run() throws Throwable;
+    }
+
+    // Single worker thread -> operations stay serialized in submission order,
+    // matching the previous UI-thread behavior. The thread is named so it is
+    // identifiable in thread dumps / ANR traces when diagnosing persistence.
+    private static final Executor EXECUTOR = Executors.newSingleThreadExecutor(
+        new ThreadFactory() {
+            @Override
+            public Thread newThread(Runnable r) {
+                return new Thread(r, "pushy-state-serial");
+            }
+        });
+
+    private StateSerialRunner() {
+    }
+
+    static void run(
+        @Nullable final Promise promise,
+        final String operationName,
+        final Operation operation
+    ) {
+        EXECUTOR.execute(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    operation.run();
+                } catch (Throwable error) {
+                    if (promise != null) {
+                        promise.reject(operationName + " failed", error);
+                    } else {
+                        Log.e(UpdateContext.TAG, operationName + " failed", error);
+                    }
+                }
+            }
+        });
+    }
+}

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

@@ -37,7 +37,7 @@ public class UpdateContext {
     private static final String KEY_FIRST_LOAD_MARKED = "firstLoadMarked";
     
     // Singleton instance
-    private static UpdateContext sInstance;
+    private static volatile UpdateContext sInstance;
     private static final Object sLock = new Object();
     private static ReactInstanceManager pendingReactInstanceManager;
 
@@ -55,7 +55,7 @@ public class UpdateContext {
         boolean flagB
     );
 
-    public UpdateContext(Context context) {
+    private UpdateContext(Context context) {
         this.context = context.getApplicationContext();
         this.executor = Executors.newSingleThreadExecutor();
 
@@ -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/android/src/main/java/cn/reactnative/modules/update/UpdateModuleImpl.java

@@ -149,7 +149,7 @@ public class UpdateModuleImpl {
         final Promise promise
     ) {
         final String hash = options.getString("hash");
-        UiThreadRunner.run(promise, "switchVersionLater", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(promise, "switchVersionLater", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setNeedUpdateInternal(updateContext, hash);
@@ -160,7 +160,7 @@ public class UpdateModuleImpl {
 
     public static void setNeedUpdate(final UpdateContext updateContext, final ReadableMap options) {
         final String hash = options.getString("hash");
-        UiThreadRunner.run(null, "switchVersionLater", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(null, "switchVersionLater", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setNeedUpdateInternal(updateContext, hash);
@@ -173,7 +173,7 @@ public class UpdateModuleImpl {
     }
 
     public static void markSuccess(final UpdateContext updateContext, final Promise promise) {
-        UiThreadRunner.run(promise, "markSuccess", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(promise, "markSuccess", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 markSuccessInternal(updateContext);
@@ -183,7 +183,7 @@ public class UpdateModuleImpl {
     }
 
     public static void markSuccess(final UpdateContext updateContext) {
-        UiThreadRunner.run(null, "markSuccess", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(null, "markSuccess", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 markSuccessInternal(updateContext);
@@ -200,7 +200,7 @@ public class UpdateModuleImpl {
         final String uuid,
         final Promise promise
     ) {
-        UiThreadRunner.run(promise, "setUuid", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(promise, "setUuid", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setUuidInternal(updateContext, uuid);
@@ -210,7 +210,7 @@ public class UpdateModuleImpl {
     }
 
     public static void setUuid(final UpdateContext updateContext, final String uuid) {
-        UiThreadRunner.run(null, "setUuid", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(null, "setUuid", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setUuidInternal(updateContext, uuid);
@@ -235,7 +235,7 @@ public class UpdateModuleImpl {
         final String info,
         final Promise promise
     ) {
-        UiThreadRunner.run(promise, "setLocalHashInfo", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(promise, "setLocalHashInfo", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setLocalHashInfoInternal(updateContext, hash, info);
@@ -249,7 +249,7 @@ public class UpdateModuleImpl {
         final String hash,
         final String info
     ) {
-        UiThreadRunner.run(null, "setLocalHashInfo", new UiThreadRunner.Operation() {
+        StateSerialRunner.run(null, "setLocalHashInfo", new StateSerialRunner.Operation() {
             @Override
             public void run() {
                 setLocalHashInfoInternal(updateContext, hash, info);

package/cpp/patch_core/archive_patch_core.cpp

@@ -25,6 +25,22 @@ EntryAction ClassifyEntry(
   return entry_name == kManifestEntryName ? EntryAction::kSkip : EntryAction::kExtract;
 }
 
+bool TryParseArchivePatchType(int value, ArchivePatchType* out) {
+  switch (value) {
+    case 1:
+      *out = ArchivePatchType::kFull;
+      return true;
+    case 2:
+      *out = ArchivePatchType::kPatchFromPackage;
+      return true;
+    case 3:
+      *out = ArchivePatchType::kPatchFromPpk;
+      return true;
+    default:
+      return false;
+  }
+}
+
 patch::Status BuildArchivePatchPlan(
     ArchivePatchType type,
     const patch::PatchManifest& manifest,

package/cpp/patch_core/archive_patch_core.h

@@ -35,6 +35,11 @@ EntryAction ClassifyEntry(
     ArchivePatchType type,
     const std::string& entry_name);
 
+// Convert a platform-supplied integer to an ArchivePatchType. Returns false for
+// unknown values so callers can fail loudly instead of silently treating an
+// incremental patch as a full package (which would skip validation).
+bool TryParseArchivePatchType(int value, ArchivePatchType* out);
+
 patch::Status BuildArchivePatchPlan(
     ArchivePatchType type,
     const patch::PatchManifest& manifest,

package/cpp/patch_core/jni_util.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <jni.h>
+
+#include <string>
+#include <vector>
+
+// Small JNI helpers shared by the Android glue translation units
+// (patch_core_android.cpp and update_core_android.cpp). Header-only with inline
+// linkage so both can include it without a separate compilation unit.
+
+namespace pushy {
+namespace jni_util {
+
+inline std::string JStringToString(JNIEnv* env, jstring value) {
+  if (value == nullptr) {
+    return std::string();
+  }
+
+  const char* chars = env->GetStringUTFChars(value, nullptr);
+  if (chars == nullptr) {
+    return std::string();
+  }
+
+  std::string result(chars);
+  env->ReleaseStringUTFChars(value, chars);
+  return result;
+}
+
+inline std::vector<std::string> JArrayToVector(
+    JNIEnv* env,
+    jobjectArray values) {
+  std::vector<std::string> result;
+  if (values == nullptr) {
+    return result;
+  }
+
+  const jsize size = env->GetArrayLength(values);
+  result.reserve(static_cast<size_t>(size));
+  for (jsize index = 0; index < size; ++index) {
+    auto* item = static_cast<jstring>(env->GetObjectArrayElement(values, index));
+    result.push_back(JStringToString(env, item));
+    env->DeleteLocalRef(item);
+  }
+  return result;
+}
+
+inline void ThrowRuntimeException(JNIEnv* env, const std::string& message) {
+  jclass exception = env->FindClass("java/lang/RuntimeException");
+  if (exception != nullptr) {
+    env->ThrowNew(exception, message.c_str());
+  }
+}
+
+}  // namespace jni_util
+}  // namespace pushy

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/patch_core_android.cpp

@@ -3,47 +3,14 @@
 #include <string>
 #include <vector>
 
+#include "jni_util.h"
 #include "patch_core.h"
 
 namespace {
 
-std::string JStringToString(JNIEnv* env, jstring value) {
-  if (value == nullptr) {
-    return std::string();
-  }
-
-  const char* chars = env->GetStringUTFChars(value, nullptr);
-  if (chars == nullptr) {
-    return std::string();
-  }
-
-  std::string result(chars);
-  env->ReleaseStringUTFChars(value, chars);
-  return result;
-}
-
-std::vector<std::string> JArrayToVector(JNIEnv* env, jobjectArray values) {
-  std::vector<std::string> result;
-  if (values == nullptr) {
-    return result;
-  }
-
-  const jsize size = env->GetArrayLength(values);
-  result.reserve(static_cast<size_t>(size));
-  for (jsize i = 0; i < size; ++i) {
-    auto* item = static_cast<jstring>(env->GetObjectArrayElement(values, i));
-    result.push_back(JStringToString(env, item));
-    env->DeleteLocalRef(item);
-  }
-  return result;
-}
-
-void ThrowRuntimeException(JNIEnv* env, const std::string& message) {
-  jclass exception = env->FindClass("java/lang/RuntimeException");
-  if (exception != nullptr) {
-    env->ThrowNew(exception, message.c_str());
-  }
-}
+using pushy::jni_util::JArrayToVector;
+using pushy::jni_util::JStringToString;
+using pushy::jni_util::ThrowRuntimeException;
 
 }  // namespace
 

package/cpp/patch_core/state_ops.h

@@ -0,0 +1,24 @@
+#pragma once
+
+// Single source of truth for the state-machine operation codes shared across
+// the platform glue layers (Android JNI in update_core_android.cpp and
+// HarmonyOS NAPI in pushy.cpp). The integer values MUST stay in sync with the
+// callers on each platform:
+//   - Android:  UpdateContext.java (STATE_OP_* constants)
+//   - HarmonyOS: UpdateContext.ts  (StateOperation usage)
+// Do not renumber existing entries; only append new ones.
+
+namespace pushy {
+namespace state_ops {
+
+enum class StateOperation {
+  kSwitchVersion = 1,
+  kMarkSuccess = 2,
+  kRollback = 3,
+  kClearFirstTime = 4,
+  kClearRollbackMark = 5,
+  kResolveLaunch = 6,
+};
+
+}  // namespace state_ops
+}  // namespace pushy