react-native-update 10.37.20 → 10.38.0-beta.1

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

@@ -15,6 +15,10 @@ import java.util.concurrent.Executors;
 import java.io.File;
 
 public class UpdateContext {
+    static {
+        NativeUpdateCore.ensureLoaded();
+    }
+
     private Context context;
     private File rootDir;
     private Executor executor;
@@ -22,11 +26,31 @@ public class UpdateContext {
     public static boolean DEBUG = true;
     private static ReactInstanceManager mReactInstanceManager;
     private static boolean isUsingBundleUrl = false;
+    private static final int STATE_OP_SWITCH_VERSION = 1;
+    private static final int STATE_OP_MARK_SUCCESS = 2;
+    private static final int STATE_OP_ROLLBACK = 3;
+    private static final int STATE_OP_CLEAR_FIRST_TIME = 4;
+    private static final int STATE_OP_CLEAR_ROLLBACK_MARK = 5;
+    private static final int STATE_OP_RESOLVE_LAUNCH = 6;
     
     // Singleton instance
     private static UpdateContext sInstance;
     private static final Object sLock = new Object();
 
+    private static native StateCoreResult syncStateWithBinaryVersion(
+        String packageVersion,
+        String buildTime,
+        StateCoreResult state
+    );
+
+    private static native StateCoreResult runStateCore(
+        int operation,
+        StateCoreResult state,
+        String stringArg,
+        boolean flagA,
+        boolean flagB
+    );
+
     public UpdateContext(Context context) {
         this.context = context;
         this.executor = Executors.newSingleThreadExecutor();
@@ -41,21 +65,18 @@ public class UpdateContext {
 
         String packageVersion = getPackageVersion();
         String buildTime = getBuildTime();
-        String storedPackageVersion = this.sp.getString("packageVersion", null);
-        String storedBuildTime = this.sp.getString("buildTime", null);
-        
-
-        SharedPreferences.Editor editor = this.sp.edit();
-        
-        boolean packageVersionChanged = storedPackageVersion == null || !packageVersion.equals(storedPackageVersion);
-        boolean buildTimeChanged = storedBuildTime == null || !buildTime.equals(storedBuildTime);
-        
-        if (packageVersionChanged || buildTimeChanged) {
+        StateCoreResult nextState = syncStateWithBinaryVersion(
+            packageVersion,
+            buildTime,
+            getStateSnapshot()
+        );
+
+        if (nextState.changed) {
             // Execute cleanUp before clearing SharedPreferences to avoid race condition
             this.cleanUp();
+            SharedPreferences.Editor editor = this.sp.edit();
             editor.clear();
-            editor.putString("packageVersion", packageVersion);
-            editor.putString("buildTime", buildTime);
+            applyState(editor, nextState);
             editor.apply();
         }
     }
@@ -144,19 +165,55 @@ public class UpdateContext {
 
     private SharedPreferences sp;
 
+    private StateCoreResult getStateSnapshot() {
+        StateCoreResult state = new StateCoreResult();
+        state.packageVersion = sp.getString("packageVersion", null);
+        state.buildTime = sp.getString("buildTime", null);
+        state.currentVersion = sp.getString("currentVersion", null);
+        state.lastVersion = sp.getString("lastVersion", null);
+        state.firstTime = sp.getBoolean("firstTime", false);
+        state.firstTimeOk = sp.getBoolean("firstTimeOk", true);
+        state.rolledBackVersion = sp.getString("rolledBackVersion", null);
+        return state;
+    }
+
+    private static void putNullableString(
+        SharedPreferences.Editor editor,
+        String key,
+        String value
+    ) {
+        if (value == null) {
+            editor.remove(key);
+        } else {
+            editor.putString(key, value);
+        }
+    }
+
+    private void applyState(SharedPreferences.Editor editor, StateCoreResult state) {
+        putNullableString(editor, "packageVersion", state.packageVersion);
+        putNullableString(editor, "buildTime", state.buildTime);
+        putNullableString(editor, "currentVersion", state.currentVersion);
+        putNullableString(editor, "lastVersion", state.lastVersion);
+        editor.putBoolean("firstTime", state.firstTime);
+        editor.putBoolean("firstTimeOk", state.firstTimeOk);
+        putNullableString(editor, "rolledBackVersion", state.rolledBackVersion);
+    }
+
     public void switchVersion(String hash) {
         if (!new File(rootDir, hash+"/index.bundlejs").exists()) {
             throw new Error("Bundle version " + hash + " not found.");
         }
-        String lastVersion = getCurrentVersion();
+        StateCoreResult currentState = getStateSnapshot();
+        StateCoreResult nextState = runStateCore(
+            STATE_OP_SWITCH_VERSION,
+            currentState,
+            hash
+            ,
+            false,
+            false
+        );
         SharedPreferences.Editor editor = sp.edit();
-        editor.putString("currentVersion", hash);
-        if (lastVersion != null && !lastVersion.equals(hash)) {
-            editor.putString("lastVersion", lastVersion);
-        }
-        editor.putBoolean("firstTime", true);
-        editor.putBoolean("firstTimeOk", false);
-        editor.putString("rolledBackVersion", null);
+        applyState(editor, nextState);
         editor.apply();
     }
 
@@ -184,13 +241,18 @@ public class UpdateContext {
 
     public void markSuccess() {
         if (!BuildConfig.DEBUG) {
+            StateCoreResult currentState = getStateSnapshot();
+            StateCoreResult nextState = runStateCore(
+                STATE_OP_MARK_SUCCESS,
+                currentState,
+                null,
+                false,
+                false
+            );
             SharedPreferences.Editor editor = sp.edit();
-            editor.putBoolean("firstTimeOk", true);
-            String lastVersion = sp.getString("lastVersion", null);
-            String curVersion = sp.getString("currentVersion", null);
-            if (lastVersion != null && !lastVersion.equals(curVersion)) {
-                editor.remove("lastVersion");
-                editor.remove("hash_" + lastVersion);
+            applyState(editor, nextState);
+            if (nextState.staleVersionToDelete != null) {
+                editor.remove("hash_" + nextState.staleVersionToDelete);
             }
             editor.apply();
 
@@ -199,16 +261,32 @@ public class UpdateContext {
     }
 
     public void clearFirstTime() {
+        StateCoreResult currentState = getStateSnapshot();
+        StateCoreResult nextState = runStateCore(
+            STATE_OP_CLEAR_FIRST_TIME,
+            currentState,
+            null,
+            false,
+            false
+        );
         SharedPreferences.Editor editor = sp.edit();
-        editor.putBoolean("firstTime", false);
+        applyState(editor, nextState);
         editor.apply();
 
         this.cleanUp();
     }
 
     public void clearRollbackMark() {
+        StateCoreResult currentState = getStateSnapshot();
+        StateCoreResult nextState = runStateCore(
+            STATE_OP_CLEAR_ROLLBACK_MARK,
+            currentState,
+            null,
+            false,
+            false
+        );
         SharedPreferences.Editor editor = sp.edit();
-        editor.putString("rolledBackVersion", null);
+        applyState(editor, nextState);
         editor.apply();
 
         this.cleanUp();
@@ -251,17 +329,24 @@ public class UpdateContext {
 
     public String getBundleUrl(String defaultAssetsUrl) {
         isUsingBundleUrl = true;
-        String currentVersion = getCurrentVersion();
+        StateCoreResult currentState = getStateSnapshot();
+        StateCoreResult launchState = runStateCore(
+            STATE_OP_RESOLVE_LAUNCH,
+            currentState,
+            null,
+            false,
+            false
+        );
+        if (launchState.didRollback || launchState.consumedFirstTime) {
+            SharedPreferences.Editor editor = sp.edit();
+            applyState(editor, launchState);
+            editor.apply();
+        }
+
+        String currentVersion = launchState.loadVersion;
         if (currentVersion == null) {
             return defaultAssetsUrl;
         }
-        // Test should rollback.
-        if (!sp.getBoolean("firstTime", false)) {
-            if (!sp.getBoolean("firstTimeOk", true)) {
-                // Not firstTime, but not ok, so we roll back.
-                currentVersion = this.rollBack();
-            }
-        }
 
         while (currentVersion != null) {
             File bundleFile = new File(rootDir, currentVersion+"/index.bundlejs");
@@ -277,20 +362,18 @@ public class UpdateContext {
     }
 
     private String rollBack() {
-        String lastVersion = sp.getString("lastVersion", null);
-        String currentVersion = sp.getString("currentVersion", null);
+        StateCoreResult currentState = getStateSnapshot();
+        StateCoreResult nextState = runStateCore(
+            STATE_OP_ROLLBACK,
+            currentState,
+            null,
+            false,
+            false
+        );
         SharedPreferences.Editor editor = sp.edit();
-        if (lastVersion == null) {
-            editor.remove("currentVersion");
-        } else {
-            editor.remove("lastVersion");
-            editor.putString("currentVersion", lastVersion);
-        }
-        editor.putBoolean("firstTimeOk", true);
-        editor.putBoolean("firstTime", false);
-        editor.putString("rolledBackVersion", currentVersion);
+        applyState(editor, nextState);
         editor.apply();
-        return lastVersion;
+        return nextState.currentVersion;
     }
 
     private void cleanUp() {

package/cpp/patch_core/archive_patch_core.cpp

@@ -0,0 +1,125 @@
+#include "archive_patch_core.h"
+
+namespace pushy {
+namespace archive_patch {
+namespace {
+
+constexpr const char* kManifestEntryName = "__diff.json";
+bool HasEntry(const std::vector<std::string>& entry_names, const std::string& name) {
+  for (const std::string& entry_name : entry_names) {
+    if (entry_name == name) {
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+EntryAction ClassifyEntry(
+    ArchivePatchType type,
+    const std::string& entry_name) {
+  if (type == ArchivePatchType::kFull) {
+    return EntryAction::kExtract;
+  }
+  return entry_name == kManifestEntryName ? EntryAction::kSkip : EntryAction::kExtract;
+}
+
+patch::Status BuildArchivePatchPlan(
+    ArchivePatchType type,
+    const patch::PatchManifest& manifest,
+    const std::vector<std::string>& entry_names,
+    ArchivePatchPlan* out_plan,
+    const std::string& bundle_patch_entry_name) {
+  if (out_plan == nullptr) {
+    return patch::Status::Error("Archive patch plan output is required");
+  }
+
+  patch::Status manifest_status = patch::ValidateManifest(manifest);
+  if (!manifest_status.ok) {
+    return manifest_status;
+  }
+
+  out_plan->type = type;
+  out_plan->manifest = manifest;
+  out_plan->merge_source_subdir.clear();
+  out_plan->enable_merge = false;
+
+  switch (type) {
+    case ArchivePatchType::kFull:
+      return patch::Status::Ok();
+    case ArchivePatchType::kPatchFromPackage:
+    case ArchivePatchType::kPatchFromPpk:
+      if (!HasEntry(entry_names, kManifestEntryName)) {
+        return patch::Status::Error("diff.json not found");
+      }
+      if (!HasEntry(entry_names, bundle_patch_entry_name)) {
+        return patch::Status::Error("bundle patch not found");
+      }
+      out_plan->merge_source_subdir =
+          type == ArchivePatchType::kPatchFromPackage ? "assets" : "";
+      out_plan->enable_merge = true;
+      return patch::Status::Ok();
+  }
+
+  return patch::Status::Error("Unknown archive patch type");
+}
+
+patch::Status BuildCopyGroups(
+    const patch::PatchManifest& manifest,
+    std::vector<CopyGroup>* out_groups) {
+  if (out_groups == nullptr) {
+    return patch::Status::Error("Copy groups output is required");
+  }
+
+  patch::Status manifest_status = patch::ValidateManifest(manifest);
+  if (!manifest_status.ok) {
+    return manifest_status;
+  }
+
+  out_groups->clear();
+  for (const patch::CopyOperation& copy : manifest.copies) {
+    bool appended = false;
+    for (CopyGroup& group : *out_groups) {
+      if (group.from == copy.from) {
+        group.to_paths.push_back(copy.to);
+        appended = true;
+        break;
+      }
+    }
+    if (!appended) {
+      CopyGroup group;
+      group.from = copy.from;
+      group.to_paths.push_back(copy.to);
+      out_groups->push_back(group);
+    }
+  }
+
+  return patch::Status::Ok();
+}
+
+patch::Status BuildFileSourcePatchOptions(
+    const ArchivePatchPlan& plan,
+    const std::string& source_root,
+    const std::string& target_root,
+    const std::string& origin_bundle_path,
+    const std::string& bundle_patch_path,
+    const std::string& bundle_output_path,
+    patch::FileSourcePatchOptions* out_options) {
+  if (out_options == nullptr) {
+    return patch::Status::Error("Patch options output is required");
+  }
+
+  out_options->manifest = plan.manifest;
+  out_options->source_root = source_root;
+  out_options->target_root = target_root;
+  out_options->origin_bundle_path = origin_bundle_path;
+  out_options->bundle_patch_path = bundle_patch_path;
+  out_options->bundle_output_path = bundle_output_path;
+  out_options->merge_source_subdir = plan.merge_source_subdir;
+  out_options->enable_merge = plan.enable_merge;
+  return patch::Status::Ok();
+}
+
+}  // namespace archive_patch
+}  // namespace pushy

package/cpp/patch_core/archive_patch_core.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "patch_core.h"
+
+namespace pushy {
+namespace archive_patch {
+
+enum class ArchivePatchType {
+  kFull = 1,
+  kPatchFromPackage = 2,
+  kPatchFromPpk = 3,
+};
+
+enum class EntryAction {
+  kSkip = 0,
+  kExtract = 1,
+};
+
+struct CopyGroup {
+  std::string from;
+  std::vector<std::string> to_paths;
+};
+
+struct ArchivePatchPlan {
+  ArchivePatchType type = ArchivePatchType::kFull;
+  patch::PatchManifest manifest;
+  std::string merge_source_subdir;
+  bool enable_merge = false;
+};
+
+EntryAction ClassifyEntry(
+    ArchivePatchType type,
+    const std::string& entry_name);
+
+patch::Status BuildArchivePatchPlan(
+    ArchivePatchType type,
+    const patch::PatchManifest& manifest,
+    const std::vector<std::string>& entry_names,
+    ArchivePatchPlan* out_plan,
+    const std::string& bundle_patch_entry_name = "index.bundlejs.patch");
+
+patch::Status BuildCopyGroups(
+    const patch::PatchManifest& manifest,
+    std::vector<CopyGroup>* out_groups);
+
+patch::Status BuildFileSourcePatchOptions(
+    const ArchivePatchPlan& plan,
+    const std::string& source_root,
+    const std::string& target_root,
+    const std::string& origin_bundle_path,
+    const std::string& bundle_patch_path,
+    const std::string& bundle_output_path,
+    patch::FileSourcePatchOptions* out_options);
+
+}  // namespace archive_patch
+}  // namespace pushy