react-native-update 10.56.0 → 10.57.0

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

@@ -71,6 +71,52 @@ final class NativeCheckOrchestrator {
     // (markJsCheckCompleted). Process-scoped by design: the next launch
     // starts with no signal and the cold-start round runs again.
     private static volatile String sJsCompletedConfig;
+    // Published after the launch rollback snapshot, before host calls are accepted.
+    private static volatile boolean nativeReady;
+    private static volatile NativeUpdateResult roundResult =
+        NativeUpdateResult.of(NativeUpdateResult.FAILED, "check_failed");
+    private static volatile long roundGeneration = -1;
+    private static volatile long roundConfigGeneration = -1;
+    private static volatile String roundConfigJson;
+
+    /** Blocking only on the host API's worker; never call on the UI thread. */
+    static NativeUpdateResult checkAndUpdate(UpdateContext context) throws InterruptedException {
+        if (UpdateContext.DEBUG) {
+            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "debug");
+        }
+        if (!nativeReady || sContext != context || !context.getIsUsingBundleUrl()) {
+            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "not_initialized");
+        }
+        String configJson = context.getKv(KEY_CONFIG);
+        if (configJson == null || configJson.isEmpty()) {
+            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "not_configured");
+        }
+        try {
+            JSONObject config = new JSONObject(configJson);
+            if (config.optBoolean("disabled", false)) {
+                return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "disabled");
+            }
+            if (config.optString("appKey", "").isEmpty()) {
+                return NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
+            }
+        } catch (JSONException e) {
+            return NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
+        }
+        startRound(0);
+        if (!roundStarted.get()) {
+            return NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "config_changed");
+        }
+        roundDone.await();
+        if (roundConfigGeneration != UpdateContext.getNativeConfigGeneration()
+            || !configJson.equals(roundConfigJson) || !configJson.equals(context.getKv(KEY_CONFIG))) {
+            return NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "config_changed");
+        }
+        if (roundGeneration != UpdateContext.getResetGeneration()) {
+            return NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "reset");
+        }
+        return roundResult;
+    }
+
 
     static void markJsCheckCompleted(String config) {
         sJsCompletedConfig = config;
@@ -99,6 +145,7 @@ final class NativeCheckOrchestrator {
         }
         sContext = context;
         sLaunchRolledBackVersion = launchRolledBackVersion;
+        nativeReady = true;
         // The crash-hold rescue shares the orchestrator's rollout gate: no
         // persisted config, no handler (§11.3).
         if (context.getKv(KEY_CONFIG) != null) {
@@ -142,7 +189,36 @@ final class NativeCheckOrchestrator {
      * started it yet. deadlineNanos > 0 (crash rescue) caps every HTTP call
      * and download phase to the remaining budget.
      */
+    private static boolean hasRunnableConfig(UpdateContext context) {
+        if (context == null) {
+            return false;
+        }
+        try {
+            String json = context.getKv(KEY_CONFIG);
+            if (json == null) {
+                return false;
+            }
+            JSONObject config = new JSONObject(json);
+            return !config.optBoolean("disabled", false)
+                && config.opt("appKey") instanceof String
+                && !config.getString("appKey").trim().isEmpty();
+        } catch (JSONException e) {
+            return false;
+        }
+    }
+
+    static void onConfigured(UpdateContext context) {
+        if (nativeReady && sContext == context && hasRunnableConfig(context)) {
+            CrashRescue.install();
+        }
+    }
+
     private static void startRound(long deadlineNanos) {
+        // An automatic check before first-run provisioning must not consume
+        // the process's only round. Hosts may configure later in this launch.
+        if (!hasRunnableConfig(sContext)) {
+            return;
+        }
         if (!roundStarted.compareAndSet(false, true)) {
             return;
         }
@@ -150,6 +226,7 @@ final class NativeCheckOrchestrator {
             runOnce(sContext, sLaunchRolledBackVersion, deadlineNanos);
         } catch (Throwable e) {
             Log.w(UpdateContext.TAG, "native check failed: " + e);
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "internal_error");
         } finally {
             roundCompleted = true;
             roundDone.countDown();
@@ -170,7 +247,7 @@ final class NativeCheckOrchestrator {
         }
         crashRescueActive = true;
         startRound(deadlineNanos);
-        if (!roundCompleted) {
+        if (roundStarted.get() && !roundCompleted) {
             long remainingNanos = deadlineNanos - System.nanoTime();
             if (remainingNanos > 0) {
                 try {
@@ -223,32 +300,33 @@ final class NativeCheckOrchestrator {
         String launchRolledBackVersion,
         long deadlineNanos
     ) throws JSONException {
-        // Sampled before any IO: a reset landing while this round runs must
-        // win over the round's decision.
         final long resetGeneration = UpdateContext.getResetGeneration();
+        roundGeneration = resetGeneration;
+        roundConfigGeneration = UpdateContext.getNativeConfigGeneration();
+        roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "check_failed");
         String configJson = context.getKv(KEY_CONFIG);
+        roundConfigJson = configJson;
         if (configJson == null || configJson.isEmpty()) {
-            // No persisted config (old integration / first ever launch): the
-            // native check silently does not run — this is the rollout gate.
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "not_configured");
             return;
         }
         JSONObject config;
         try {
             config = new JSONObject(configJson);
         } catch (JSONException e) {
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
             return;
         }
         if (config.optBoolean("disabled", false)) {
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "disabled");
             return;
         }
         String appKey = config.optString("appKey", "");
         if (appKey.isEmpty()) {
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_config");
             return;
         }
-        // From here on the round does real work: leave the breadcrumb that
-        // the next launch reads to skip its 5s delay if we die mid-round.
-        // Best-effort: a lost breadcrumb costs one 5s delay, it must not
-        // abort the rescue round itself.
+        // Keep the existing interrupted-round breadcrumb and reset generation.
         try {
             context.setKv(KEY_ROUND_INCOMPLETE, "1");
         } catch (IllegalStateException ignored) {
@@ -323,6 +401,7 @@ final class NativeCheckOrchestrator {
 
         String body = NativeUpdateFlow.buildCheckRequestBody(input.toString());
         if (body == null) {
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_request");
             return;
         }
 
@@ -339,19 +418,24 @@ final class NativeCheckOrchestrator {
         String decisionJson = NativeUpdateFlow.handleCheckResponse(
             responseText, identity.toString(), config.optString("afterDownload", ""));
         if (decisionJson == null) {
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_response");
             return;
         }
         JSONObject decision = new JSONObject(decisionJson);
         if (!"download".equals(decision.optString("action"))) {
-            context.commitNativeCheckResult(
+            boolean committed = context.commitNativeCheckResult(
                 resetGeneration, null, null, false,
                 buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
+            roundResult = committed
+                ? NativeUpdateResult.of(NativeUpdateResult.NO_UPDATE, decision.optString("reason"))
+                : NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "reset");
             Log.i(UpdateContext.TAG,
                 "native check: nothing to do (" + decision.optString("reason") + ")");
             return;
         }
         String hash = decision.optString("hash", "");
         if (!UpdateFileUtils.isSafePathComponent(hash)) {
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "invalid_response");
             return;
         }
 
@@ -364,9 +448,12 @@ final class NativeCheckOrchestrator {
         if (!downloaded) {
             // The native attempt has finished, so JS may safely reuse the
             // response and retry through its own strategy chain.
-            context.commitNativeCheckResult(
+            boolean committed = context.commitNativeCheckResult(
                 resetGeneration, null, null, false,
                 buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
+            roundResult = NativeUpdateResult.of(
+                committed ? NativeUpdateResult.FAILED : NativeUpdateResult.CANCELLED,
+                committed ? "download_failed" : "reset");
             return;
         }
 
@@ -412,6 +499,7 @@ final class NativeCheckOrchestrator {
                 buildResponseCacheJson(configJson, body, responseText, responseAtSeconds));
         } catch (Exception e) {
             Log.w(UpdateContext.TAG, "native check: commit failed: " + e);
+            roundResult = NativeUpdateResult.of(NativeUpdateResult.FAILED, "commit_failed");
             return;
         }
         if (!committed) {
@@ -428,6 +516,9 @@ final class NativeCheckOrchestrator {
             Log.i(UpdateContext.TAG,
                 "native check: downloaded " + hash + ", activation left to JS");
         }
+        roundResult = committed
+            ? NativeUpdateResult.downloaded(hash, activate)
+            : NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "reset");
     }
 
     private static String buildResponseCacheJson(

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

@@ -0,0 +1,99 @@
+package cn.reactnative.modules.update;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.regex.Pattern;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/** Internal normalizer for the JSONObject accepted by PushyNativeUpdate.configure. */
+final class NativeUpdateConfig {
+    private static final Set<String> KEYS = new HashSet<>(Arrays.asList(
+        "appKey", "endpoints", "queryUrls", "afterDownload", "disabled",
+        "packageVersion", "rnu", "rn"));
+    private static final Pattern URL = Pattern.compile(
+        "^https?://(\\[[0-9a-fA-F:]+\\]|[a-zA-Z0-9.-]+)(:[0-9]+)?([/?#]|$)");
+    private static final String[] ENDPOINTS = {
+        "https://update.react-native.cn/api", "https://update.reactnative.cn/api"
+    };
+    private static final String[] QUERY_URLS = {
+        "https://gitee.com/sunnylqm/react-native-pushy/raw/master/endpoints.json",
+        "https://cdn.jsdelivr.net/gh/reactnativecn/react-native-update@master/endpoints.json"
+    };
+
+    private NativeUpdateConfig() {}
+
+    static String normalize(String json) throws JSONException {
+        JSONObject options = new JSONObject(json);
+        for (Iterator<String> keys = options.keys(); keys.hasNext();) {
+            String key = keys.next();
+            if (!KEYS.contains(key)) {
+                throw invalid("unknown option " + key);
+            }
+        }
+        String appKey = string(options.opt("appKey"), "appKey", false);
+        boolean customEndpoints = options.has("endpoints");
+        JSONArray endpoints = urls(customEndpoints ? options.get("endpoints")
+            : new JSONArray(Arrays.asList(ENDPOINTS)), "endpoints", true);
+        JSONArray queryUrls = urls(options.has("queryUrls") ? options.get("queryUrls")
+            : new JSONArray(Arrays.asList(customEndpoints ? new String[0] : QUERY_URLS)),
+            "queryUrls", false);
+        String afterDownload = options.has("afterDownload")
+            ? string(options.get("afterDownload"), "afterDownload", false) : "none";
+        if (!"none".equals(afterDownload) && !"setNeedUpdate".equals(afterDownload)) {
+            throw invalid("afterDownload must be none or setNeedUpdate");
+        }
+        Object disabled = options.has("disabled") ? options.get("disabled") : Boolean.FALSE;
+        if (!(disabled instanceof Boolean)) {
+            throw invalid("disabled must be a boolean");
+        }
+        JSONObject result = new JSONObject();
+        result.put("appKey", appKey);
+        result.put("endpoints", endpoints);
+        result.put("queryUrls", queryUrls);
+        result.put("afterDownload", afterDownload);
+        result.put("disabled", disabled);
+        result.put("rnu", options.has("rnu") ? string(options.get("rnu"), "rnu", true) : "");
+        result.put("rn", options.has("rn") ? string(options.get("rn"), "rn", true) : "");
+        if (options.has("packageVersion")) {
+            result.put("packageVersion", string(options.get("packageVersion"), "packageVersion", false));
+        }
+        return result.toString();
+    }
+
+    private static String string(Object value, String name, boolean allowEmpty) {
+        if (!(value instanceof String) || (!allowEmpty && ((String) value).trim().isEmpty())) {
+            throw invalid(name + " must be a string" + (allowEmpty ? "" : " and must not be blank"));
+        }
+        return (String) value;
+    }
+
+    private static JSONArray urls(Object value, String name, boolean base) throws JSONException {
+        if (!(value instanceof JSONArray) || (base && ((JSONArray) value).length() == 0)) {
+            throw invalid(name + " must be " + (base ? "a non-empty" : "an") + " array");
+        }
+        JSONArray values = (JSONArray) value;
+        JSONArray result = new JSONArray();
+        Set<String> seen = new HashSet<>();
+        for (int i = 0; i < values.length(); i++) {
+            String url = string(values.get(i), name, false).trim();
+            if (!URL.matcher(url).find() || url.matches("(?s).*\\s.*") || url.contains("\\")
+                || (base && (url.contains("?") || url.contains("#")))) {
+                throw invalid(name + " requires absolute HTTP(S) URLs without credentials"
+                    + (base ? ", queries or fragments" : ""));
+            }
+            String normalized = base ? url.replaceAll("/+$", "") : url;
+            if (seen.add(normalized)) {
+                result.put(normalized);
+            }
+        }
+        return result;
+    }
+
+    private static IllegalArgumentException invalid(String message) {
+        return new IllegalArgumentException("Invalid native configuration: " + message);
+    }
+}

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

@@ -0,0 +1,51 @@
+package cn.reactnative.modules.update;
+
+/**
+ * Snapshot of a native check-and-update round. A downloaded result does not
+ * mean that the running React Native instance has been reloaded.
+ */
+public final class NativeUpdateResult {
+    public static final String SKIPPED = "skipped";
+    public static final String NO_UPDATE = "noUpdate";
+    public static final String DOWNLOADED = "downloaded";
+    public static final String FAILED = "failed";
+    public static final String CANCELLED = "cancelled";
+
+    private final String status;
+    private final String reason;
+    private final String hash;
+    private final boolean activated;
+
+    private NativeUpdateResult(String status, String reason, String hash, boolean activated) {
+        this.status = status;
+        this.reason = reason;
+        this.hash = hash;
+        this.activated = activated;
+    }
+
+    static NativeUpdateResult of(String status, String reason) {
+        return new NativeUpdateResult(status, reason, "", false);
+    }
+
+    static NativeUpdateResult downloaded(String hash, boolean activated) {
+        return new NativeUpdateResult(DOWNLOADED, "", hash, activated);
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public String getReason() {
+        return reason;
+    }
+
+    /** Installed update hash, or an empty string when this round installed nothing. */
+    public String getHash() {
+        return hash;
+    }
+
+    /** Whether this round selected the downloaded version for the next launch. */
+    public boolean isActivated() {
+        return activated;
+    }
+}

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

@@ -0,0 +1,127 @@
+package cn.reactnative.modules.update;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import org.json.JSONObject;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+
+/** Bridge-free native configuration and update APIs. */
+public final class PushyNativeUpdate {
+    public interface Callback {
+        /** Always called on the main thread, including skipped and failed checks. */
+        void onComplete(NativeUpdateResult result);
+    }
+
+    // A single waiting worker, not one thread per caller. The actual round is
+    // shared with cold start and crash rescue by NativeCheckOrchestrator.
+    private static final Executor WORKER = Executors.newSingleThreadExecutor(new ThreadFactory() {
+        @Override
+        public Thread newThread(Runnable runnable) {
+            Thread thread = new Thread(runnable, "pushy-host-check");
+            thread.setDaemon(true);
+            return thread;
+        }
+    });
+
+    public interface ConfigurationCallback {
+        /** Main thread; null means configuration was persisted successfully. */
+        void onComplete(@Nullable Exception error);
+    }
+
+    // Configuration must not wait behind a network round that it invalidates.
+    private static final Executor CONFIG_WORKER = Executors.newSingleThreadExecutor(new ThreadFactory() {
+        @Override
+        public Thread newThread(Runnable runnable) {
+            Thread thread = new Thread(runnable, "pushy-host-config");
+            thread.setDaemon(true);
+            return thread;
+        }
+    });
+
+    /**
+     * Validate and persist a complete configuration, even before JS or bundle
+     * resolution. This starts no network work and never resolves a bundle.
+     * Await the callback before continuing startup/checkAndUpdate. Unless JS
+     * uses nativeConfigSource: 'native', later JS config writes can replace it.
+     */
+    public static void configure(Context context, JSONObject options, final ConfigurationCallback callback) {
+        if (context == null || options == null || callback == null) {
+            throw new IllegalArgumentException("context, options and callback are required");
+        }
+        final Context applicationContext = context.getApplicationContext();
+        // Snapshot caller-owned JSON before dispatch, not minutes later on a worker.
+        final String snapshot = options.toString();
+        CONFIG_WORKER.execute(new Runnable() {
+            @Override
+            public void run() {
+                Exception failure = null;
+                try {
+                    String config = NativeUpdateConfig.normalize(snapshot);
+                    UpdateContext.getInstance(applicationContext).setNativeConfig(config);
+                } catch (Exception e) {
+                    failure = e;
+                } catch (LinkageError e) {
+                    failure = new IllegalStateException("Native configuration failed", e);
+                }
+                final Exception error = failure;
+                new Handler(Looper.getMainLooper()).post(new Runnable() {
+                    @Override
+                    public void run() {
+                        callback.onComplete(error);
+                    }
+                });
+            }
+        });
+    }
+
+    private PushyNativeUpdate() {
+    }
+
+    /**
+     * Start the process's native check now, join its in-flight round, or return
+     * its completed result. This does not reload React Native or show UI.
+     *
+     * Call after the host has resolved its real launch bundle with
+     * UpdateContext.getBundleUrl. Do not resolve the bundle again just to call
+     * this method: bundle resolution consumes first-load/rollback markers.
+     * Missing persisted configuration and debug builds are reported as skipped.
+     */
+    public static void checkAndUpdate(Context context, final Callback callback) {
+        if (context == null || callback == null) {
+            throw new IllegalArgumentException("context and callback are required");
+        }
+        final Context applicationContext = context.getApplicationContext();
+        WORKER.execute(new Runnable() {
+            @Override
+            public void run() {
+                NativeUpdateResult outcome;
+                try {
+                    if (BuildConfig.DEBUG) {
+                        outcome = NativeUpdateResult.of(NativeUpdateResult.SKIPPED, "debug");
+                    } else {
+                        outcome = NativeCheckOrchestrator.checkAndUpdate(
+                            UpdateContext.getInstance(applicationContext));
+                    }
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    outcome = NativeUpdateResult.of(NativeUpdateResult.CANCELLED, "interrupted");
+                } catch (Exception | LinkageError e) {
+                    Log.w("react-native-update", "native host check failed", e);
+                    outcome = NativeUpdateResult.of(NativeUpdateResult.FAILED, "internal_error");
+                }
+                final NativeUpdateResult result = outcome;
+                new Handler(Looper.getMainLooper()).post(new Runnable() {
+                    @Override
+                    public void run() {
+                        callback.onComplete(result);
+                    }
+                });
+            }
+        });
+    }
+}

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

@@ -737,6 +737,41 @@ public class UpdateContext {
     }
 
     /** Sampled/compared by the native check orchestrator; see resetGeneration. */
+    /** Shared by JS and native hosts. Config replacement invalidates old native decisions. */
+    private static final java.util.concurrent.atomic.AtomicLong nativeConfigGeneration =
+        new java.util.concurrent.atomic.AtomicLong(0);
+
+    static long getNativeConfigGeneration() {
+        return nativeConfigGeneration.get();
+    }
+
+    void setNativeConfig(String config) {
+        synchronized (commitLock) {
+            boolean changed = !config.equals(sp.getString(NativeCheckOrchestrator.KEY_CONFIG, null));
+            SharedPreferences.Editor editor = sp.edit();
+            if (changed) {
+                // Also invalidate on a failed persistence attempt: an older
+                // round must not commit over uncertain configuration state.
+                resetGeneration.incrementAndGet();
+                nativeConfigGeneration.incrementAndGet();
+                editor.remove(NativeCheckOrchestrator.KEY_RESP_CACHE);
+                NativeCheckOrchestrator.markJsCheckCompleted(null);
+            }
+            // A native-only first launch needs a stable gray-release identity
+            // before JS initializes. Never replace an existing installation ID.
+            String uuid = sp.getString("uuid", null);
+            if (uuid == null || uuid.isEmpty()) {
+                editor.putString("uuid", java.util.UUID.randomUUID().toString());
+            }
+            editor.putString(NativeCheckOrchestrator.KEY_CONFIG, config);
+            // Persist even an equal value: a previous commit may have updated
+            // SharedPreferences memory but failed to write its file.
+            persistEditorOrThrow(editor, "configure native update");
+        }
+        NativeCheckOrchestrator.onConfigured(this);
+    }
+
+    // Native-decision generation: bumped by reset AND configuration replacement.
     static long getResetGeneration() {
         return resetGeneration.get();
     }

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

@@ -339,7 +339,7 @@ public class UpdateModuleImpl {
         StateSerialRunner.run(promise, ErrorCodes.FILE_OPERATION_FAILED, "syncNativeConfig", new StateSerialRunner.Operation() {
             @Override
             public void run() {
-                updateContext.setKv(NativeCheckOrchestrator.KEY_CONFIG, config);
+                updateContext.setNativeConfig(config);
                 promise.resolve(true);
             }
         });