@onekeyfe/react-native-split-bundle-loader 3.0.18 → 3.0.19

package/android/src/main/java/com/splitbundleloader/SplitBundleLoaderModule.kt

@@ -30,10 +30,87 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         // #18: Limit concurrent asset extractions to avoid I/O contention
         private const val MAX_CONCURRENT_EXTRACTS = 2
         private val extractSemaphore = Semaphore(MAX_CONCURRENT_EXTRACTS)
+
+        // Wipe-on-APK-replace: avoids stale extracted HBC after overwrite install.
+        // `lastUpdateTime` changes on every APK replacement (adb install -r,
+        // Play Store upgrade, sideload, TestFlight-equivalent). If it differs
+        // from what we persisted, nuke the whole extract tree so the new APK's
+        // assets get extracted fresh on first load.
+        private const val PREFS_NAME = "split_bundle_loader"
+        private const val KEY_LAST_INSTALL_STAMP = "last_install_stamp"
+        // Double-checked locking: loser threads must BLOCK until the wipe
+        // finishes, not just skip. AtomicBoolean.compareAndSet would let
+        // losers race ahead and read half-nuked state.
+        @Volatile private var wipeCheckDone: Boolean = false
+        private val wipeLock = Any()
     }
 
     override fun getName(): String = NAME
 
+    // -----------------------------------------------------------------------
+    // Wipe extract dir when APK install/upgrade detected.
+    //
+    // Without this, an overwrite install (adb install -r, Play Store upgrade,
+    // etc.) leaves last-run's extracted HBC files in /data/.../files/, and
+    // extractBuiltinSegmentIfNeeded reuses them because its size check can
+    // pass even when Metro module IDs drifted. Nuking the tree on every
+    // install-stamp change forces the new APK's assets to be re-extracted.
+    //
+    // Atomic gate means this runs at most once per process regardless of how
+    // many entry points call it.
+    // -----------------------------------------------------------------------
+
+    private fun ensureExtractDirFreshForCurrentInstall(context: Context) {
+        // Fast path: already done, no locking needed (volatile read).
+        if (wipeCheckDone) return
+        synchronized(wipeLock) {
+            // Re-check inside the lock: another thread may have finished
+            // the wipe while we were waiting to enter.
+            if (wipeCheckDone) return
+
+            val currentStamp = try {
+                context.packageManager.getPackageInfo(context.packageName, 0).lastUpdateTime
+            } catch (e: Exception) {
+                SBLLogger.warn("[install-stamp] failed to read lastUpdateTime: ${e.message}")
+                // Mark done even on failure: retrying every call won't help and
+                // would defeat the gate. Conservative default is to NOT wipe.
+                wipeCheckDone = true
+                return
+            }
+
+            val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+            val savedStamp = prefs.getLong(KEY_LAST_INSTALL_STAMP, -1L)
+            if (savedStamp != currentStamp) {
+                val baseDir = File(context.filesDir, BUILTIN_EXTRACT_DIR)
+                if (baseDir.exists()) {
+                    SBLLogger.info(
+                        "[install-stamp] changed saved=$savedStamp current=$currentStamp, wiping ${baseDir.absolutePath}"
+                    )
+                    // rename-then-delete so the baseDir is gone atomically
+                    // before we release the lock; waiters never see a half-nuked dir.
+                    val tomb = File(
+                        baseDir.parentFile,
+                        ".${BUILTIN_EXTRACT_DIR}.stale-${System.nanoTime()}"
+                    )
+                    if (baseDir.renameTo(tomb)) {
+                        tomb.deleteRecursively()
+                    } else {
+                        baseDir.deleteRecursively()
+                    }
+                } else {
+                    SBLLogger.info(
+                        "[install-stamp] first seen current=$currentStamp (no extract dir yet)"
+                    )
+                }
+                // Persist synchronously (commit) so that a crash mid-wipe doesn't
+                // leave us with a stale stamp + still-wiped dir next launch.
+                prefs.edit().putLong(KEY_LAST_INSTALL_STAMP, currentStamp).commit()
+            }
+            // Publish via volatile write; fast path on other threads now sees true.
+            wipeCheckDone = true
+        }
+    }
+
     // -----------------------------------------------------------------------
     // getRuntimeBundleContext
     // -----------------------------------------------------------------------
@@ -41,6 +118,7 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
     override fun getRuntimeBundleContext(promise: Promise) {
         try {
             val context = reactApplicationContext
+            ensureExtractDirFreshForCurrentInstall(context)
             val runtimeKind = "main"
             var sourceKind = "builtin"
             var bundleRoot = ""
@@ -91,6 +169,7 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
 
     override fun resolveSegmentPath(relativePath: String, sha256: String, promise: Promise) {
         try {
+            ensureExtractDirFreshForCurrentInstall(reactApplicationContext)
             val absolutePath = resolveSegmentPath(relativePath, sha256)
             if (absolutePath != null) {
                 promise.resolve(absolutePath)
@@ -121,6 +200,7 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         // segment integrity. Builtin segments are signed as part of the APK/IPA.
         // If runtime SHA-256 verification is needed, add it here.
         try {
+            ensureExtractDirFreshForCurrentInstall(reactApplicationContext)
             val segId = segmentId.toInt()
 
             val absolutePath = resolveSegmentPath(relativePath, sha256)
@@ -132,54 +212,21 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
                 return
             }
 
-            // #19: Try CatalystInstance first (bridge mode), fall back to
-            // ReactHost registerSegment if available (bridgeless / new arch).
+            // Use ReactContext.registerSegment which works in both bridge
+            // and bridgeless modes. In bridge mode it delegates to
+            // CatalystInstance; in bridgeless mode it delegates to ReactHost.
             val reactContext = reactApplicationContext
             val segStart = System.nanoTime()
-            if (reactContext.hasCatalystInstance()) {
-                reactContext.catalystInstance.registerSegment(segId, absolutePath)
+            reactContext.registerSegment(segId, absolutePath) {
                 val segMs = (System.nanoTime() - segStart) / 1_000_000.0
                 SBLLogger.info("[SplitBundle] segment $segmentKey (id=$segId) registered in ${String.format("%.1f", segMs)}ms")
                 promise.resolve(null)
-            } else {
-                // Bridgeless: try ReactHost via reflection
-                val registered = tryRegisterViaBridgeless(segId, absolutePath)
-                val segMs = (System.nanoTime() - segStart) / 1_000_000.0
-                if (registered) {
-                    SBLLogger.info("[SplitBundle] segment $segmentKey (id=$segId) registered via bridgeless in ${String.format("%.1f", segMs)}ms")
-                    promise.resolve(null)
-                } else {
-                    promise.reject(
-                        "SPLIT_BUNDLE_NO_INSTANCE",
-                        "Neither CatalystInstance nor ReactHost available"
-                    )
-                }
             }
         } catch (e: Exception) {
             promise.reject("SPLIT_BUNDLE_LOAD_ERROR", e.message, e)
         }
     }
 
-    // -----------------------------------------------------------------------
-    // Bridgeless support (#19)
-    // -----------------------------------------------------------------------
-
-    private fun tryRegisterViaBridgeless(segmentId: Int, path: String): Boolean {
-        return try {
-            val appContext = reactApplicationContext.applicationContext
-            val appClass = appContext.javaClass
-            val hostMethod = appClass.getMethod("getReactHost")
-            val host = hostMethod.invoke(appContext) ?: return false
-            val registerMethod = host.javaClass.getMethod(
-                "registerSegment", Int::class.java, String::class.java
-            )
-            registerMethod.invoke(host, segmentId, path)
-            true
-        } catch (_: Exception) {
-            false
-        }
-    }
-
     // -----------------------------------------------------------------------
     // Path resolution helpers
     // -----------------------------------------------------------------------
@@ -206,14 +253,27 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
             val otaRoot = File(otaBundlePath).parentFile
             if (otaRoot != null) {
                 val candidate = File(otaRoot, relativePath)
-                if (candidate.exists() && isPathWithinRoot(otaRoot, candidate)) {
+                val exists = candidate.exists()
+                val withinRoot = isPathWithinRoot(otaRoot, candidate)
+                SBLLogger.info("[resolveSeg] rel=$relativePath ota root=${otaRoot.absolutePath} cand=${candidate.absolutePath} exists=$exists withinRoot=$withinRoot")
+                if (exists && withinRoot) {
                     return candidate.absolutePath
                 }
+            } else {
+                SBLLogger.info("[resolveSeg] rel=$relativePath otaBundlePath=$otaBundlePath parentFile=null")
             }
+        } else {
+            SBLLogger.info("[resolveSeg] rel=$relativePath otaBundlePath=(empty) — skipping OTA")
         }
 
         // 2. Try builtin: extract from assets if needed
-        return extractBuiltinSegmentIfNeeded(relativePath, expectedSha256)
+        val result = extractBuiltinSegmentIfNeeded(relativePath, expectedSha256)
+        if (result == null) {
+            SBLLogger.warn("[resolveSeg] rel=$relativePath → null (builtin extract failed)")
+        } else {
+            SBLLogger.info("[resolveSeg] rel=$relativePath → builtin $result")
+        }
+        return result
     }
 
     /**
@@ -225,6 +285,7 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
      */
     private fun extractBuiltinSegmentIfNeeded(relativePath: String, expectedSha256: String): String? {
         val context = reactApplicationContext
+        ensureExtractDirFreshForCurrentInstall(context)
         val nativeVersion = try {
             context.packageManager
                 .getPackageInfo(context.packageName, 0).versionName ?: "unknown"
@@ -272,12 +333,15 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
                 }
                 // Atomic rename prevents partial file observation
                 if (tempFile.renameTo(extractedFile)) {
+                    SBLLogger.info("[extractBuiltin] extracted $relativePath → ${extractedFile.absolutePath} (${extractedFile.length()} bytes)")
                     extractedFile.absolutePath
                 } else {
+                    SBLLogger.warn("[extractBuiltin] rename failed for $relativePath: ${tempFile.absolutePath} → ${extractedFile.absolutePath}")
                     tempFile.delete()
                     null
                 }
-            } catch (_: IOException) {
+            } catch (e: IOException) {
+                SBLLogger.warn("[extractBuiltin] IOException for $relativePath: ${e.javaClass.simpleName}: ${e.message}")
                 null
             }
         } finally {

package/ios/SplitBundleLoader.mm

@@ -130,22 +130,32 @@
     // 1. Try OTA bundle root first
     NSString *otaPath = [SplitBundleLoader otaBundlePath];
     if (otaPath) {
-        NSString *otaRoot = [otaPath stringByDeletingLastPathComponent];
+        // Standardize root so hasPrefix matches candidate (iOS resolves /private/var → /var).
+        NSString *otaRoot = [[otaPath stringByDeletingLastPathComponent] stringByStandardizingPath];
         NSString *candidate = [[otaRoot stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
-        if ([candidate hasPrefix:otaRoot] &&
-            [[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
+        BOOL otaPrefixOk = [candidate hasPrefix:otaRoot];
+        BOOL otaExists = [[NSFileManager defaultManager] fileExistsAtPath:candidate];
+        [SBLLogger info:[NSString stringWithFormat:@"[resolveAbs] rel=%@ ota root=%@ cand=%@ prefixOk=%d exists=%d",
+                         relativePath, otaRoot, candidate, otaPrefixOk, otaExists]];
+        if (otaPrefixOk && otaExists) {
             return candidate;
         }
+    } else {
+        [SBLLogger info:[NSString stringWithFormat:@"[resolveAbs] rel=%@ otaPath=(nil) — skipping OTA", relativePath]];
     }
 
     // 2. Fallback to builtin resource path
-    NSString *builtinRoot = [[NSBundle mainBundle] resourcePath];
+    NSString *builtinRoot = [[[NSBundle mainBundle] resourcePath] stringByStandardizingPath];
     NSString *candidate = [[builtinRoot stringByAppendingPathComponent:relativePath] stringByStandardizingPath];
-    if ([candidate hasPrefix:builtinRoot] &&
-        [[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
+    BOOL builtinPrefixOk = [candidate hasPrefix:builtinRoot];
+    BOOL builtinExists = [[NSFileManager defaultManager] fileExistsAtPath:candidate];
+    [SBLLogger info:[NSString stringWithFormat:@"[resolveAbs] rel=%@ builtin root=%@ cand=%@ prefixOk=%d exists=%d",
+                     relativePath, builtinRoot, candidate, builtinPrefixOk, builtinExists]];
+    if (builtinPrefixOk && builtinExists) {
         return candidate;
     }
 
+    [SBLLogger warn:[NSString stringWithFormat:@"[resolveAbs] rel=%@ → nil (not found in OTA nor builtin)", relativePath]];
     return nil;
 }
 

package/package.json

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