react-native-bspatch 3.1.2 → 4.0.0

package/README.md

@@ -25,15 +25,15 @@ Premium OTA update solution for React Native using **TurboModules** + **bsdiff b
 
 ## Requirements
 
-- React Native **0.76+** (New Architecture enabled by default)
-- `react-native-blob-util` **0.24.11+** — required peer dependency for file I/O (0.24.10 stops Android file downloads after the first 8 KB: "Download interrupted.")
+- React Native **0.80+** with the New Architecture (TurboModule event emitters for download progress)
+- No other runtime dependencies: downloads and file I/O are native to this module
 
 ---
 
 ## Installation
 
 ```bash
-npm install react-native-bspatch react-native-blob-util
+npm install react-native-bspatch
 cd ios && pod install
 ```
 

package/android/build.gradle

@@ -1,27 +1,8 @@
-buildscript {
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["BsPatch_kotlinVersion"]
-
-  repositories {
-    google()
-    mavenCentral()
-  }
-
-  dependencies {
-    classpath "com.android.tools.build:gradle:9.0.0"
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-  }
-}
-
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-}
-
+// AGP and the Kotlin plugin come from the host app's root build classpath
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
-
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
+// The module extends the codegen spec, so it only builds on the New Architecture
+apply plugin: "com.facebook.react"
 
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["BsPatch_" + name]
@@ -31,6 +12,12 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["BsPatch_" + name]).toInteger()
 }
 
+// Build only the ABIs the app builds (RN's `reactNativeArchitectures` gradle property)
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
 android {
   namespace "vn.reactnativebspatch"
 
@@ -39,11 +26,10 @@ android {
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
     externalNativeBuild {
       cmake {
-        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
-        abiFilters "x86", "x86_64", "armeabi-v7a", "arm64-v8a"
+        cppFlags "-Wall -fstack-protector-all"
+        abiFilters(*reactNativeArchitectures())
       }
     }
   }
@@ -67,14 +53,7 @@ android {
 
   sourceSets {
     main {
-      if (isNewArchitectureEnabled()) {
-        java.srcDirs += [
-          "src/newarch",
-          "${project.buildDir}/generated/source/codegen/java"
-        ]
-      } else {
-        java.srcDirs += ["src/oldarch"]
-      }
+      java.srcDirs += ["${project.buildDir}/generated/source/codegen/java"]
     }
   }
 }
@@ -87,14 +66,13 @@ repositories {
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-  implementation "com.facebook.react:react-native:+"
+  // Version comes from the React Native Gradle plugin
+  implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
 }
 
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "RNBsPatchSpec"
-    codegenJavaPackageName = "vn.reactnativebspatch"
-  }
+react {
+  jsRootDir = file("../src/")
+  libraryName = "RNBsPatchSpec"
+  codegenJavaPackageName = "vn.reactnativebspatch"
 }

package/android/src/main/java/vn/reactnativebspatch/BsPatchModule.kt

@@ -2,13 +2,18 @@ package vn.reactnativebspatch
 
 import android.os.Handler
 import android.os.Looper
+import android.os.SystemClock
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.Promise
+import com.facebook.react.common.LifecycleState
 import java.io.File
 import java.io.FileInputStream
-import java.io.BufferedInputStream
+import java.io.FileOutputStream
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
 import java.util.concurrent.Executors
 
 class BsPatchModule(private val reactContext: ReactApplicationContext) : NativeBsPatchSpec(reactContext) {
@@ -16,7 +21,9 @@ class BsPatchModule(private val reactContext: ReactApplicationContext) : NativeB
     companion object {
         const val NAME = "BsPatch"
         private const val IO_BUFFER_SIZE = 65536 // 64KB buffer for optimal flash storage I/O
-        private val backgroundExecutor = Executors.newFixedThreadPool(2)
+        private const val PROGRESS_INTERVAL_MS = 250L
+        // Unbounded: JS runs up to 6 asset downloads at once next to patch/hash work
+        private val backgroundExecutor = Executors.newCachedThreadPool()
 
         init {
             System.loadLibrary("bspatch")
@@ -45,16 +52,16 @@ class BsPatchModule(private val reactContext: ReactApplicationContext) : NativeB
     }
 
     override fun reloadBundle() {
-        val activity = reactContext.currentActivity
-        if (activity != null) {
-            Handler(Looper.getMainLooper()).post {
-                val intent = activity.packageManager.getLaunchIntentForPackage(activity.packageName)
-                if (intent != null) {
-                    intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK or android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK or android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                    activity.startActivity(intent)
-                    Runtime.getRuntime().exit(0)
-                }
+        Handler(Looper.getMainLooper()).post {
+            // Backgrounded: just exit, the next launch is a cold start on the new bundle.
+            // Relaunching here would pull the app back to the foreground.
+            val activity = reactContext.currentActivity
+            if (activity != null && reactContext.lifecycleState == LifecycleState.RESUMED) {
+                val intent = activity.packageManager.getLaunchIntentForPackage(activity.packageName) ?: return@post
+                intent.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK or android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK or android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP)
+                activity.startActivity(intent)
             }
+            Runtime.getRuntime().exit(0)
         }
     }
 
@@ -124,4 +131,132 @@ class BsPatchModule(private val reactContext: ReactApplicationContext) : NativeB
         }
     }
 
+    // ─── File I/O ───────────────────────────────────────────────────────
+
+    /** Runs block off the JS thread; Unit resolves as null. */
+    private fun io(promise: Promise, block: () -> Any?) {
+        backgroundExecutor.execute {
+            try {
+                val result = block()
+                promise.resolve(if (result == Unit) null else result)
+            } catch (e: Exception) {
+                promise.reject("ERR_FS", e.message, e)
+            }
+        }
+    }
+
+    override fun getDocumentDir(): String = reactContext.filesDir.absolutePath
+
+    override fun downloadFile(url: String, destPath: String, timeoutMs: Double, promise: Promise) {
+        backgroundExecutor.execute {
+            val part = File("$destPath.part")
+            var conn: HttpURLConnection? = null
+            try {
+                conn = (URL(url).openConnection() as HttpURLConnection).apply {
+                    connectTimeout = timeoutMs.toInt()
+                    readTimeout = timeoutMs.toInt()
+                    instanceFollowRedirects = true
+                    setRequestProperty("Cache-Control", "no-cache")
+                }
+                val status = conn.responseCode
+                if (status !in 200..299) throw IOException("HTTP $status for $url")
+                // -1 when unknown (also when the body is transparently gunzipped)
+                val total = conn.contentLengthLong
+                part.parentFile?.mkdirs()
+                var received = 0L
+                var lastEmit = 0L
+                conn.inputStream.use { input ->
+                    FileOutputStream(part).use { output ->
+                        val buffer = ByteArray(IO_BUFFER_SIZE)
+                        while (true) {
+                            val n = input.read(buffer)
+                            if (n < 0) break
+                            output.write(buffer, 0, n)
+                            received += n
+                            val now = SystemClock.uptimeMillis()
+                            if (now - lastEmit >= PROGRESS_INTERVAL_MS) {
+                                lastEmit = now
+                                emitProgress(destPath, received, total)
+                            }
+                        }
+                        output.fd.sync()
+                    }
+                }
+                if (total >= 0 && received != total) {
+                    throw IOException("Download truncated: $received of $total bytes")
+                }
+                emitProgress(destPath, received, total)
+                if (!part.renameTo(File(destPath))) throw IOException("Rename to $destPath failed")
+                promise.resolve(received.toDouble())
+            } catch (e: Exception) {
+                part.delete()
+                promise.reject("ERR_DOWNLOAD", e.message, e)
+            } finally {
+                conn?.disconnect()
+            }
+        }
+    }
+
+    private fun emitProgress(path: String, received: Long, total: Long) {
+        emitOnDownloadProgress(Arguments.createMap().apply {
+            putString("path", path)
+            putDouble("received", received.toDouble())
+            putDouble("total", total.toDouble())
+        })
+    }
+
+    override fun hashFile(path: String, promise: Promise) = io(promise) {
+        val digest = MessageDigest.getInstance("SHA-256")
+        val buffer = ByteArray(IO_BUFFER_SIZE)
+        FileInputStream(path).use { input ->
+            while (true) {
+                val n = input.read(buffer)
+                if (n < 0) break
+                digest.update(buffer, 0, n)
+            }
+        }
+        digest.digest().joinToString("") { "%02x".format(it) }
+    }
+
+    override fun exists(path: String, promise: Promise) = io(promise) { File(path).exists() }
+
+    override fun mkdir(path: String, promise: Promise) = io(promise) {
+        val dir = File(path)
+        if (!dir.mkdirs() && !dir.isDirectory) throw IOException("mkdir failed: $path")
+    }
+
+    override fun removePath(path: String, promise: Promise) = io(promise) {
+        val file = File(path)
+        if (!file.deleteRecursively() && file.exists()) throw IOException("remove failed: $path")
+    }
+
+    override fun moveFile(from: String, to: String, promise: Promise) = io(promise) {
+        val src = File(from)
+        val dst = File(to)
+        // rename() replaces a file atomically; a non-empty directory must go first
+        if (!src.renameTo(dst)) {
+            dst.deleteRecursively()
+            if (!src.renameTo(dst)) throw IOException("move failed: $from → $to")
+        }
+    }
+
+    override fun copyFile(from: String, to: String, promise: Promise) = io(promise) {
+        File(from).copyTo(File(to), overwrite = true)
+        Unit
+    }
+
+    override fun readDir(path: String, promise: Promise) = io(promise) {
+        val names = File(path).list() ?: throw IOException("Not a directory: $path")
+        Arguments.createArray().apply { names.forEach { pushString(it) } }
+    }
+
+    override fun readFile(path: String, promise: Promise) = io(promise) { File(path).readText() }
+
+    override fun writeFile(path: String, content: String, promise: Promise) = io(promise) {
+        // Write-then-rename: a kill mid-write never leaves a truncated file
+        val file = File(path)
+        val tmp = File("$path.tmp")
+        tmp.writeText(content)
+        if (!tmp.renameTo(file)) throw IOException("rename failed: $path")
+    }
 }

package/android/src/main/java/vn/reactnativebspatch/OtaBundleResolver.kt

@@ -36,6 +36,9 @@ object OtaBundleResolver {
     private const val DEFAULT_BASE_VERSION = 1
     private const val MAX_ROLLBACK = 3
 
+    /** Version this process booted (set by resolve), so markAsHealthy verifies only that one */
+    @Volatile private var launchedVersion: Int? = null
+
     /**
      * Resolves the JS bundle path from OTA metadata.
      * Handles crash detection and rollback entirely on the native side.
@@ -46,6 +49,12 @@ object OtaBundleResolver {
      */
     @JvmStatic
     fun resolve(context: Context, baseVersion: Int = DEFAULT_BASE_VERSION): String? {
+        val path = resolveBundle(context, baseVersion)
+        launchedVersion = path?.let { File(it).parentFile?.name?.removePrefix("v")?.toIntOrNull() } ?: baseVersion
+        return path
+    }
+
+    private fun resolveBundle(context: Context, baseVersion: Int): String? {
         return try {
             val otaDir = File(context.filesDir, OTA_DIR_NAME)
             val metadataFile = File(otaDir, METADATA_FILE)
@@ -97,7 +106,7 @@ object OtaBundleResolver {
                 val rollbackBundle = File(rollbackVDir, "index.android.bundle")
                 if (!rollbackBundle.exists()) {
                     Log.w(TAG, "Rollback target index.android.bundle missing in V$newVersion → factory")
-                    resetToFactory(metadataFile, baseVersion)
+                    resetToFactory(metadataFile, baseVersion, metadata)
                     return null
                 }
 
@@ -122,7 +131,7 @@ object OtaBundleResolver {
             val bundleFile = File(vDir, "index.android.bundle")
             if (!bundleFile.exists()) {
                 Log.w(TAG, "index.android.bundle missing in V$currentVersion → APK bundle")
-                resetToFactory(metadataFile, baseVersion)
+                resetToFactory(metadataFile, baseVersion, metadata)
                 return null
             }
 
@@ -210,12 +219,15 @@ object OtaBundleResolver {
     /**
      * Resets metadata to factory defaults.
      */
-    private fun resetToFactory(metadataFile: File, baseVersion: Int) {
+    private fun resetToFactory(metadataFile: File, baseVersion: Int, old: JSONObject) {
         val factory = JSONObject().apply {
             put("currentVersion", baseVersion)
             put("previousVersions", JSONArray())
             put("rollbackCount", 0)
             put("lastLaunchSuccessful", true)
+            // Keep: otherwise JS re-downloads a version that crashed on boot
+            old.optJSONArray("failedVersions")?.let { put("failedVersions", it) }
+            old.optString("appVersion", "").takeIf { it.isNotEmpty() }?.let { put("appVersion", it) }
         }
         writeMetadata(metadataFile, factory)
     }
@@ -228,6 +240,12 @@ object OtaBundleResolver {
             if (!metadataFile.exists()) return
 
             val metadata = JSONObject(metadataFile.readText())
+            // Same rule as JS markHealthy: a version installed since boot hasn't run yet, leave it pending
+            val launched = launchedVersion
+            if (launched != null) {
+                if (metadata.optInt("currentVersion", launched) != launched) return
+                metadata.put("verifiedVersion", launched)
+            }
             metadata.put("lastLaunchSuccessful", true)
             metadata.put("rollbackCount", 0)
 

package/cpp/CMakeLists.txt

@@ -13,9 +13,6 @@ set(BZIP2_SOURCES
     "bzip2/bzlib.c"
 )
 
-# React Native includes
-set(REACT_NATIVE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../../node_modules/react-native)
-
 # Add our custom library
 add_library(
         bspatch

package/cpp/bsdiff/bspatch_wrapper.c

@@ -112,8 +112,9 @@ int apply_bspatch(const char *oldfile, const char *newfile, const char *patchfil
 		old = (uint8_t *)mmap(NULL, (size_t)oldsize, PROT_READ, MAP_SHARED, fd_old, 0);
 		if (old != MAP_FAILED) {
 			old_mmapped = 1;
-#if defined(MADV_SEQUENTIAL)
-			madvise(old, (size_t)oldsize, MADV_SEQUENTIAL);
+			/* Not SEQUENTIAL: ctrl[2] seeks old backwards, so prefetch it all instead */
+#if defined(MADV_WILLNEED)
+			madvise(old, (size_t)oldsize, MADV_WILLNEED);
 #endif
 		} else {
 			/* Fallback to malloc if mmap fails */

package/ios/OtaBundleResolver.swift

@@ -36,12 +36,21 @@ public class OtaBundleResolver: NSObject {
     private static let maxRollback = 3
     private static let maxRollbackIterations = 10 // Safety limit to prevent infinite loops
 
+    /// Version this process booted (set by resolve), so markAsHealthy verifies only that one
+    private static var launchedVersion: Int?
+
     /// Resolves the JS bundle path from OTA metadata.
     /// Handles crash detection and rollback entirely on the native side.
     ///
     /// - Parameter baseVersion: The OTA version baked into the IPA (default: 1)
     /// - Returns: URL to the OTA bundle, or nil to use the IPA default.
     @objc public static func resolve(baseVersion: Int = defaultBaseVersion) -> URL? {
+        let url = resolveBundle(baseVersion: baseVersion)
+        launchedVersion = url.flatMap { Int($0.deletingLastPathComponent().lastPathComponent.dropFirst()) } ?? baseVersion
+        return url
+    }
+
+    private static func resolveBundle(baseVersion: Int) -> URL? {
         guard let documentsDir = FileManager.default.urls(
             for: .documentDirectory,
             in: .userDomainMask
@@ -102,7 +111,7 @@ public class OtaBundleResolver: NSObject {
                 let rollbackBundle = rollbackVDir.appendingPathComponent("main.jsbundle")
                 if !FileManager.default.fileExists(atPath: rollbackBundle.path) {
                     NSLog("[OtaBundleResolver] Rollback target main.jsbundle missing in V\(newVersion) → factory")
-                    resetToFactory(url: metadataURL, baseVersion: baseVersion)
+                    resetToFactory(url: metadataURL, baseVersion: baseVersion, old: metadata)
                     return nil
                 }
 
@@ -127,7 +136,7 @@ public class OtaBundleResolver: NSObject {
             let bundleURL = vDir.appendingPathComponent("main.jsbundle")
             if !FileManager.default.fileExists(atPath: bundleURL.path) {
                 NSLog("[OtaBundleResolver] main.jsbundle missing in V\(currentVersion) → IPA bundle")
-                resetToFactory(url: metadataURL, baseVersion: baseVersion)
+                resetToFactory(url: metadataURL, baseVersion: baseVersion, old: metadata)
                 return nil
             }
 
@@ -212,13 +221,16 @@ public class OtaBundleResolver: NSObject {
         ]
     }
 
-    private static func resetToFactory(url: URL, baseVersion: Int) {
-        let factory: [String: Any] = [
+    private static func resetToFactory(url: URL, baseVersion: Int, old: [String: Any]) {
+        var factory: [String: Any] = [
             "currentVersion": baseVersion,
             "previousVersions": [Int](),
             "rollbackCount": 0,
             "lastLaunchSuccessful": true
         ]
+        // Keep: otherwise JS re-downloads a version that crashed on boot
+        factory["failedVersions"] = old["failedVersions"]
+        factory["appVersion"] = old["appVersion"]
         writeMetadata(url: url, metadata: factory)
     }
 
@@ -243,9 +255,14 @@ public class OtaBundleResolver: NSObject {
                 return
             }
 
+            // Same rule as JS markHealthy: a version installed since boot hasn't run yet, leave it pending
+            if let launched = launchedVersion {
+                if (metadata["currentVersion"] as? Int ?? launched) != launched { return }
+                metadata["verifiedVersion"] = launched
+            }
             metadata["lastLaunchSuccessful"] = true
             metadata["rollbackCount"] = 0
-            
+
             writeMetadata(url: metadataURL, metadata: metadata)
             NSLog("[OtaBundleResolver] App marked as healthy")
         } catch {