react-native-update 10.43.2 → 10.44.0

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,6 +29,10 @@ import org.json.JSONTokener;
 
 class DownloadTask implements Runnable {
     private static final int DOWNLOAD_CHUNK_SIZE = 4096;
+    // 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;
     private static final OkHttpClient HTTP_CLIENT = new OkHttpClient();
 
     static {
@@ -98,6 +102,7 @@ class DownloadTask implements Runnable {
             long bytesRead;
             long received = 0;
             int currentPercentage = 0;
+            long lastPostedBytes = 0;
 
             try (
                 BufferedSource source = body.source();
@@ -113,7 +118,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 +400,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();
 

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_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

package/cpp/patch_core/tests/patch_core_test.cpp

@@ -426,6 +426,28 @@ void TestArchivePatchCoreRejectsMissingEntries() {
       "manifest entry should be skipped");
 }
 
+void TestTryParseArchivePatchType() {
+  pushy::archive_patch::ArchivePatchType type;
+  Expect(
+      pushy::archive_patch::TryParseArchivePatchType(1, &type) &&
+          type == pushy::archive_patch::ArchivePatchType::kFull,
+      "1 should parse to kFull");
+  Expect(
+      pushy::archive_patch::TryParseArchivePatchType(2, &type) &&
+          type == pushy::archive_patch::ArchivePatchType::kPatchFromPackage,
+      "2 should parse to kPatchFromPackage");
+  Expect(
+      pushy::archive_patch::TryParseArchivePatchType(3, &type) &&
+          type == pushy::archive_patch::ArchivePatchType::kPatchFromPpk,
+      "3 should parse to kPatchFromPpk");
+  Expect(
+      !pushy::archive_patch::TryParseArchivePatchType(0, &type),
+      "0 should be rejected");
+  Expect(
+      !pushy::archive_patch::TryParseArchivePatchType(4, &type),
+      "unknown type should be rejected, not silently coerced to kFull");
+}
+
 void TestArchivePatchCoreSupportsCustomBundlePatchEntry() {
   PatchManifest manifest;
   manifest.copies.push_back(CopyOperation{"assets/a.png", "assets/a.png"});
@@ -524,6 +546,7 @@ int main() {
       {"StateCoreCanClearMarkers", TestStateCoreCanClearMarkers},
       {"ArchivePatchCoreBuildPlanAndCopyGroups", TestArchivePatchCoreBuildPlanAndCopyGroups},
       {"ArchivePatchCoreRejectsMissingEntries", TestArchivePatchCoreRejectsMissingEntries},
+      {"TryParseArchivePatchType", TestTryParseArchivePatchType},
       {"ArchivePatchCoreSupportsCustomBundlePatchEntry", TestArchivePatchCoreSupportsCustomBundlePatchEntry},
       {"ArchivePatchCoreHarmonyBundlePatchFromPackage", TestArchivePatchCoreHarmonyBundlePatchFromPackage},
       {"StateCoreRollbackToEmptyVersion", TestStateCoreRollbackToEmptyVersion},
@@ -531,15 +554,22 @@ int main() {
       {"StateCoreSwitchToSameVersion", TestStateCoreSwitchToSameVersion},
   };
 
+  int failures = 0;
   for (const auto& test : tests) {
     try {
       test.second();
       std::fprintf(stdout, "[PASS] %s\n", test.first.c_str());
     } catch (const std::exception& error) {
       std::fprintf(stderr, "[FAIL] %s: %s\n", test.first.c_str(), error.what());
-      return 1;
+      ++failures;
     }
   }
 
-  return 0;
+  std::fprintf(
+      stdout,
+      "\n%zu tests, %d passed, %d failed\n",
+      tests.size(),
+      static_cast<int>(tests.size()) - failures,
+      failures);
+  return failures == 0 ? 0 : 1;
 }