@onekeyfe/react-native-bundle-update 3.0.67 → 3.0.69

package/android/src/main/java/com/margelo/nitro/reactnativebundleupdate/ReactNativeBundleUpdate.kt

@@ -18,8 +18,9 @@ import java.io.FileOutputStream
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicLong
 import java.util.zip.ZipEntry
@@ -1094,8 +1095,27 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
 
     private val listeners = CopyOnWriteArrayList<BundleListener>()
     private val nextListenerId = AtomicLong(1)
-    private val isDownloading = AtomicBoolean(false)
+
+    // Per-destination single-flight (OCDS §5.8): one in-flight run per final
+    // bundle path, keyed by `filePath`. `putIfAbsent` makes a second
+    // downloadBundle for the SAME dest fail fast ("Already downloading"), while
+    // different dests now run concurrently (the old global boolean serialized
+    // everything). The value is the live CancelHandle so clearDownload/clearBundle
+    // can stop the 8 workers BEFORE deleting the directory (cancel-then-delete),
+    // preventing a worker from re-creating a just-deleted `.segN`. Being an
+    // in-memory map, a crashed run leaves no stale lock — the entry is gone on
+    // relaunch, giving inherent stale-lock recovery (OCDS §5.8).
+    private val activeDownloads =
+        ConcurrentHashMap<String, ConcurrentRangeDownloader.CancelHandle>()
     private val httpClient = OkHttpClient.Builder()
+        // OCDS §5.4 timeouts. `readTimeout` is the primary inter-byte stall
+        // window: OkHttp raises SocketTimeoutException when no bytes arrive within
+        // it, which the segment loop classifies transient and retries. We do NOT
+        // set callTimeout — it bounds the WHOLE call and would cut a legitimately
+        // slow large segment mid-stream; the overall run deadline is owned by the
+        // shared-JS retry budget (ServiceAppUpdate), not this socket layer.
+        .connectTimeout(30, TimeUnit.SECONDS)
+        .readTimeout(60, TimeUnit.SECONDS)
         .addNetworkInterceptor { chain ->
             val req = chain.request()
             if (!req.url.isHttps) {
@@ -1191,10 +1211,13 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
 
     override fun downloadBundle(params: BundleDownloadParams): Promise<BundleDownloadResult> {
         return Promise.async {
-            if (isDownloading.getAndSet(true)) {
-                OneKeyLog.warn("BundleUpdate", "downloadBundle: rejected, already downloading")
-                throw Exception("Already downloading")
-            }
+            // Per-dest single-flight is acquired below once `filePath` is known.
+            // Input validation (version/HTTPS) runs FIRST and is intentionally
+            // NOT gated by the lock — a malformed request must fail the same way
+            // whether or not a download is in flight, and must never register a
+            // lock entry it then has to unwind.
+            var acquiredKey: String? = null
+            var cancelHandle: ConcurrentRangeDownloader.CancelHandle? = null
 
             try {
             val context = getContext()
@@ -1224,6 +1247,19 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
             // "exists at filePath -> already valid" cache check above.
             val partialFilePath = "$filePath.partial"
 
+            // OCDS §5.8 per-destination single-flight. Register a CancelHandle for
+            // THIS dest; a second downloadBundle for the same `filePath` fails fast
+            // ("Already downloading"). Different dests are allowed to run
+            // concurrently. The handle is passed to the concurrent downloader so
+            // clearDownload/clearBundle can stop its workers before deleting files.
+            val handle = ConcurrentRangeDownloader.CancelHandle()
+            if (activeDownloads.putIfAbsent(filePath, handle) != null) {
+                OneKeyLog.warn("BundleUpdate", "downloadBundle: rejected, already downloading $filePath")
+                throw Exception("Already downloading")
+            }
+            acquiredKey = filePath
+            cancelHandle = handle
+
             val result = BundleDownloadResult(
                 downloadedFile = filePath,
                 downloadUrl = downloadUrl,
@@ -1247,12 +1283,12 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
                     if (partialFile.exists()) partialFile.delete()
                     File("$partialFilePath.progress").delete()
                     for (i in 0 until CONCURRENT_SEGMENT_COUNT) File("$partialFilePath.seg$i").delete()
-                    // Keep isDownloading held across the skip delay below. Clearing
-                    // it before the sleep opens a ~1s window where a second
-                    // downloadBundle could pass the getAndSet guard and run
-                    // concurrently. Reset only after the delay completes.
+                    // Keep the per-dest lock held across the skip delay below.
+                    // The `finally` removes the lock entry AFTER this return runs,
+                    // so the lock spans the whole sleep — closing the ~1s window
+                    // where a second downloadBundle for this dest could otherwise
+                    // pass the single-flight guard and run concurrently.
                     Thread.sleep(1000)
-                    isDownloading.set(false)
                     sendEvent("update/complete")
                     return@async result
                 } else {
@@ -1284,7 +1320,7 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
                 val concurrentOutcome = ConcurrentRangeDownloader(
                     httpClient = httpClient,
                     log = { msg -> OneKeyLog.info("BundleUpdate", msg) },
-                ).download(downloadUrl, partialFilePath) { transferred, total ->
+                ).download(downloadUrl, partialFilePath, cancelHandle) { transferred, total ->
                     if (total > 0) {
                         val p = ((transferred * 100) / total).toInt().coerceIn(0, 100)
                         val prev = concurrentProgress.get()
@@ -1338,7 +1374,9 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
                         if (downloadedFile.exists()) downloadedFile.delete()
                         if (partialFile.renameTo(downloadedFile) && verifyBundleSHA256(filePath, sha256)) {
                             OneKeyLog.info("BundleUpdate", "downloadBundle: recovered crashed-before-rename bundle, skipping download")
-                            isDownloading.set(false)
+                            // The `finally` removes the per-dest lock after this
+                            // return; the lock therefore spans the skip delay,
+                            // same as the existing-file cache-hit path above.
                             Thread.sleep(1000)
                             sendEvent("update/complete")
                             return@async result
@@ -1545,7 +1583,26 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
                 // sanitizeErrorMessageForEvent.
                 OneKeyLog.error("BundleUpdate", "downloadBundle: failed: ${e.javaClass.simpleName}: ${e.message}")
                 val sanitized = sanitizeErrorMessageForEvent(e)
-                sendEvent("update/error", message = sanitized)
+                // An INTENTIONAL cancel (clearDownload/clearBundle flipped THIS
+                // run's CancelHandle, which aborts the workers → they throw
+                // IOException("aborted")) is NOT a download failure — the caller
+                // deliberately tore the run down. Before the cancel-then-delete
+                // path existed, clearing never aborted an in-flight run, so no
+                // `update/error` was emitted; preserve that. Detect it off the
+                // handle's `aborted` flag rather than the message, because
+                // sanitizeErrorMessageForEvent collapses "aborted" to the generic
+                // "IO_IOException" tag and would be indistinguishable from a real
+                // I/O failure.
+                val intentionallyCancelled = cancelHandle?.aborted?.get() == true
+                // A duplicate-dest single-flight rejection ("Already downloading")
+                // is NOT a failure of any in-flight download — it means another
+                // run already owns this dest. The original global-boolean guard
+                // threw this BEFORE the try, so no `update/error` was emitted;
+                // preserve that so listeners don't observe a spurious error for the
+                // rejected caller while the real download is still progressing.
+                if (sanitized != "Already downloading" && !intentionallyCancelled) {
+                    sendEvent("update/error", message = sanitized)
+                }
                 // Rethrow with the same sanitized message so the Promise
                 // rejection surfacing to JS carries no /data/user/<u>/<pkg>/
                 // paths. Without this rewrap, FileNotFoundException etc.
@@ -1555,7 +1612,16 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
                 // native crash reporter) still sees the full chain.
                 throw Exception(sanitized, e)
             } finally {
-                isDownloading.set(false)
+                // Release THIS run's per-dest single-flight lock. Keyed remove
+                // (only if we actually acquired it — input-validation failures
+                // throw before acquisition, leaving acquiredKey null). The
+                // value-checked remove avoids deleting an entry a later run for
+                // the same dest may have re-registered after a concurrent cancel.
+                val key = acquiredKey
+                val handle = cancelHandle
+                if (key != null && handle != null) {
+                    activeDownloads.remove(key, handle)
+                }
             }
         }
     }
@@ -1784,10 +1850,28 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
         }
     }
 
+    // OCDS §5.8 cancel-then-delete. Stop every in-flight concurrent run's worker
+    // pool (flip its abort flag + shutdownNow) BEFORE the caller deletes the
+    // download directory. Without this, a live segment worker could re-create a
+    // `.segN` we just deleted (CRD streams into `.segN` via append). Removing each
+    // entry here also makes the dest immediately re-acquirable. The in-flight
+    // download's own `finally` does a value-checked remove, so racing it is safe.
+    private fun cancelAllActiveDownloads() {
+        val keys = activeDownloads.keys.toList()
+        for (key in keys) {
+            activeDownloads.remove(key)?.let {
+                OneKeyLog.info("BundleUpdate", "cancelling in-flight download: $key")
+                it.cancel()
+            }
+        }
+    }
+
     override fun clearDownload(): Promise<Unit> {
         return Promise.async {
             OneKeyLog.info("BundleUpdate", "clearDownload: clearing download directory...")
             val context = getContext()
+            // Cancel-then-delete: stop live workers before removing files.
+            cancelAllActiveDownloads()
             val downloadDir = File(BundleUpdateStoreAndroid.getDownloadBundleDir(context))
             if (downloadDir.exists()) {
                 BundleUpdateStoreAndroid.deleteDir(downloadDir)
@@ -1795,7 +1879,6 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
             } else {
                 OneKeyLog.info("BundleUpdate", "clearDownload: download directory does not exist, skipping")
             }
-            isDownloading.set(false)
             OneKeyLog.info("BundleUpdate", "clearDownload: completed")
         }
     }
@@ -1805,6 +1888,8 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
         return Promise.async {
             OneKeyLog.info("BundleUpdate", "clearBundle: clearing download and bundle directories...")
             val context = getContext()
+            // Cancel-then-delete: stop live workers before removing files.
+            cancelAllActiveDownloads()
             // Clear download directory
             val downloadDir = File(BundleUpdateStoreAndroid.getDownloadBundleDir(context))
             if (downloadDir.exists()) {
@@ -1817,7 +1902,6 @@ class ReactNativeBundleUpdate : HybridReactNativeBundleUpdateSpec() {
                 BundleUpdateStoreAndroid.deleteDir(bundleDir)
                 OneKeyLog.info("BundleUpdate", "clearBundle: bundle directory deleted")
             }
-            isDownloading.set(false)
             OneKeyLog.info("BundleUpdate", "clearBundle: completed")
         }
     }

package/ios/ReactNativeBundleUpdate.swift

@@ -985,6 +985,11 @@ class ReactNativeBundleUpdate: HybridReactNativeBundleUpdateSpec {
     /// Read by the background-snapshot handler so it knows where to drop the
     /// `.resume` sidecar.
     private var activeDownloadFilePath: String?
+    /// OCDS §5.7: the highest progress percent already reported to JS for the
+    /// in-flight download. Used to floor single-stream progress so the bar never
+    /// moves backward at the concurrent→single-stream seam. Guarded by
+    /// `stateQueue`. Reset to 0 only on a genuine restart (permanent fallback).
+    private var lastReportedProgress: Int = 0
     private var didEnterBackgroundObserver: NSObjectProtocol?
 
     override init() {
@@ -1228,7 +1233,13 @@ class ReactNativeBundleUpdate: HybridReactNativeBundleUpdateSpec {
             // below; the range downloader keeps its `.segN` files for the next
             // attempt (its background session resumes them by taskId).
             self.sendEvent(type: "update/start")
-            self.stateQueue.sync { self.activeDownloadFilePath = filePath }
+            // §5.7: a fresh downloadBundle starts the progress floor at 0; the
+            // concurrent path raises it as bytes land (below), and a transient
+            // single-stream fallback keeps it.
+            self.stateQueue.sync {
+                self.activeDownloadFilePath = filePath
+                self.lastReportedProgress = 0
+            }
 
             // Stable, unique task id for this bundle. Same value across retry
             // attempts so the range downloader can resume its `.segN` files, and
@@ -1241,31 +1252,88 @@ class ReactNativeBundleUpdate: HybridReactNativeBundleUpdateSpec {
             // "fallback" are surfaced by this method's own sendEvent calls and
             // the download outcome below, so we don't double-emit them here.
             let progressListenerId = RangeDownloader.shared.addListener { [weak self] event in
-                guard event.channel.stringValue == DownloadChannel.bundle.stringValue,
+                guard let self = self,
+                      event.channel.stringValue == DownloadChannel.bundle.stringValue,
                       event.taskId == rangeTaskId,
                       event.type == "progress" else { return }
-                self?.sendEvent(type: "update/downloading", progress: Int(event.progress))
-            }
-
-            let (rangeOutcome, _, rangeReason) = await RangeDownloader.shared.download(
-                channel: .bundle,
-                taskId: rangeTaskId,
-                urlString: downloadUrl,
-                filePath: filePath,
-                // SHA256 is verified by this module right after assembly (below),
-                // so we don't double-hash inside the range downloader.
-                expectedSha256: nil,
-                segmentCount: nil,
-                minConcurrentBytes: nil
-            )
+                // §5.7: record the concurrent floor so a later single-stream
+                // transient fallback resumes the bar from here, not from 0.
+                let floored: Int = self.stateQueue.sync {
+                    let clamped = max(self.lastReportedProgress, Int(event.progress))
+                    self.lastReportedProgress = clamped
+                    return clamped
+                }
+                self.sendEvent(type: "update/downloading", progress: floored)
+            }
+
+            // A `.fallback` outcome covers two very different situations whose
+            // recovery must NOT be the same:
+            //   • Permanent — Range unsupported / file too small / server 200 /
+            //     SHA mismatch. The downloader has already cleaned its `.segN`
+            //     segments, so none survive; single-stream is the only way.
+            //   • Transient — a network drop or app suspend interrupted a segment
+            //     mid-flight ("segment N missing/truncated"). The downloader
+            //     RETAINS the segments that DID complete; the next concurrent
+            //     attempt resumes only the missing one(s).
+            // This method used to `discardArtifacts` on EVERY fallback and restart
+            // single-stream from byte 0, so any background/lock/network blip threw
+            // away tens of MB and the user saw progress reset to 0. We now retry
+            // the concurrent path while resumable segments survive, and fall back
+            // to single-stream only as a last resort — WITHOUT deleting those
+            // segments, so a later attempt can still resume them.
+            let maxConcurrentAttempts = 3
+            var concurrentAttempt = 0
+            // OCDS §4: consume the EXPLICIT typed class from the in-process core
+            // (`RangeDownloadClass`) instead of inferring transient-vs-permanent
+            // from whether `.segN` happens to survive on disk. The wire enum stays
+            // `completed | fallback` until nitrogen regen; we call the in-process
+            // `download(...)` directly, so we get the precise class here.
+            var rangeClass: RangeDownloadClass = .fallbackPermanent
+            var rangeReason: String?
+            while true {
+                concurrentAttempt += 1
+                (rangeClass, _, rangeReason, _) = await RangeDownloader.shared.download(
+                    channel: .bundle,
+                    taskId: rangeTaskId,
+                    urlString: downloadUrl,
+                    filePath: filePath,
+                    // SHA256 is verified by this module right after assembly (below),
+                    // so we don't double-hash inside the range downloader.
+                    expectedSha256: nil,
+                    segmentCount: nil,
+                    minConcurrentBytes: nil
+                )
+                if rangeClass == .completed {
+                    break // completed
+                }
+                // §4: a Transient class is resumable — retry the concurrent path.
+                // The core keeps `.segN`; the next call resumes only what's missing.
+                if rangeClass == .fallbackTransient,
+                   concurrentAttempt < maxConcurrentAttempts {
+                    OneKeyLog.info("BundleUpdate", "downloadBundle: concurrent transient fallback (\(rangeReason ?? "")), resuming surviving segments (attempt \(concurrentAttempt)/\(maxConcurrentAttempts))")
+                    // Brief backoff so a flapping network / suspend settles before
+                    // we re-probe and resume the missing segment(s).
+                    try? await Task.sleep(nanoseconds: 1_500_000_000)
+                    continue
+                }
+                break // permanent, or transient retries exhausted
+            }
             RangeDownloader.shared.removeListener(progressListenerId)
 
-            if rangeOutcome.stringValue == RangeDownloadOutcome.fallback.stringValue {
-                // Concurrent path unavailable (Range unsupported / file too small /
-                // server returned 200 / transient error). Hand off to the
-                // single-stream path, leaving a clean slot.
-                OneKeyLog.info("BundleUpdate", "downloadBundle: concurrent fallback (\(rangeReason ?? "")), using single-stream")
-                RangeDownloader.shared.discardArtifacts(filePath: filePath)
+            if rangeClass != .completed {
+                if rangeClass == .fallbackTransient {
+                    // §4 Transient that outlived our concurrent retries: KEEP the
+                    // segments so the next downloadBundle call's concurrent path can
+                    // resume them. Single-stream is just this call's safety net, and
+                    // its progress is floored (below) so the bar never drops to 0.
+                    OneKeyLog.info("BundleUpdate", "downloadBundle: concurrent transient fallback persists (\(rangeReason ?? "")), using single-stream (segments preserved for resume)")
+                } else {
+                    // §4 Permanent (segments already cleaned by the downloader):
+                    // clear any residue and hand off to single-stream from a clean
+                    // slot; this is a genuine restart, so the progress floor resets.
+                    OneKeyLog.info("BundleUpdate", "downloadBundle: concurrent permanent fallback (\(rangeReason ?? "")), using single-stream")
+                    RangeDownloader.shared.discardArtifacts(filePath: filePath)
+                }
                 // fall through to the single-stream path below
             } else {
                 OneKeyLog.info("BundleUpdate", "downloadBundle: concurrent finished, verifying SHA256...")
@@ -1312,8 +1380,24 @@ class ReactNativeBundleUpdate: HybridReactNativeBundleUpdateSpec {
                 throw NSError(domain: "BundleUpdate", code: -1, userInfo: [NSLocalizedDescriptionKey: "Download delegate not initialized"])
             }
             delegate.reset()
+            // OCDS §5.7: reported progress is monotonic non-decreasing within a
+            // run, and resets only on a GENUINE restart. The single-stream
+            // delegate emits its own 0→100, which would jump the bar backward at
+            // the concurrent→single-stream seam. Floor it: a transient fallback
+            // KEEPS the floor (the concurrent path already reported ~N%), a
+            // permanent fallback is a genuine restart so the floor resets to 0.
+            let progressFloor = (rangeClass == .fallbackTransient)
+                ? self.stateQueue.sync { self.lastReportedProgress }
+                : 0
+            self.stateQueue.sync { self.lastReportedProgress = progressFloor }
             delegate.onProgress = { [weak self] progress in
-                self?.sendEvent(type: "update/downloading", progress: progress)
+                guard let self = self else { return }
+                let floored: Int = self.stateQueue.sync {
+                    let clamped = max(self.lastReportedProgress, progress)
+                    self.lastReportedProgress = clamped
+                    return clamped
+                }
+                self.sendEvent(type: "update/downloading", progress: floored)
             }
 
             // Anchor for the background-snapshot handler. Set BEFORE
@@ -1421,6 +1505,11 @@ class ReactNativeBundleUpdate: HybridReactNativeBundleUpdateSpec {
                     throw NSError(domain: "BundleUpdate", code: -1, userInfo: [NSLocalizedDescriptionKey: "Bundle SHA256 verification failed: \(reason)"])
                 }
 
+                // A verified single-stream file is authoritative — drop any
+                // concurrent `.segN` segments we intentionally kept across a
+                // transient fallback so they don't linger as orphans.
+                RangeDownloader.shared.discardArtifacts(filePath: filePath)
+
                 self.sendEvent(type: "update/complete")
                 OneKeyLog.info("BundleUpdate", "downloadBundle: completed successfully, appVersion=\(appVersion), bundleVersion=\(bundleVersion)")
                 return result

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-bundle-update",
-  "version": "3.0.67",
+  "version": "3.0.69",
   "description": "react-native-bundle-update",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",