@onekeyfe/react-native-split-bundle-loader 0.1.1 → 1.1.50

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

@@ -9,6 +9,7 @@ import com.facebook.react.module.annotations.ReactModule
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
+import java.util.concurrent.Semaphore
 
 /**
  * TurboModule entry point for SplitBundleLoader.
@@ -26,6 +27,9 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
     companion object {
         const val NAME = "SplitBundleLoader"
         private const val BUILTIN_EXTRACT_DIR = "onekey-builtin-segments"
+        // #18: Limit concurrent asset extractions to avoid I/O contention
+        private const val MAX_CONCURRENT_EXTRACTS = 2
+        private val extractSemaphore = Semaphore(MAX_CONCURRENT_EXTRACTS)
     }
 
     override fun getName(): String = NAME
@@ -73,6 +77,9 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
             result.putString("bundleVersion", bundleVersion)
 
             promise.resolve(result)
+
+            // #17: Clean up old version extract directories asynchronously
+            cleanupOldExtractDirs(context, nativeVersion)
         } catch (e: Exception) {
             promise.reject("SPLIT_BUNDLE_CONTEXT_ERROR", e.message, e)
         }
@@ -92,7 +99,7 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         try {
             val segId = segmentId.toInt()
 
-            val absolutePath = resolveSegmentPath(relativePath)
+            val absolutePath = resolveSegmentPath(relativePath, sha256)
             if (absolutePath == null) {
                 promise.reject(
                     "SPLIT_BUNDLE_NOT_FOUND",
@@ -101,28 +108,56 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
                 return
             }
 
-            // Register segment via CatalystInstance
+            // #19: Try CatalystInstance first (bridge mode), fall back to
+            // ReactHost registerSegment if available (bridgeless / new arch).
             val reactContext = reactApplicationContext
             if (reactContext.hasCatalystInstance()) {
                 reactContext.catalystInstance.registerSegment(segId, absolutePath)
                 SBLLogger.info("Loaded segment $segmentKey (id=$segId)")
                 promise.resolve(null)
             } else {
-                promise.reject(
-                    "SPLIT_BUNDLE_NO_INSTANCE",
-                    "CatalystInstance not available"
-                )
+                // Bridgeless: try ReactHost via reflection
+                val registered = tryRegisterViaBridgeless(segId, absolutePath)
+                if (registered) {
+                    SBLLogger.info("Loaded segment $segmentKey (id=$segId) via bridgeless")
+                    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
     // -----------------------------------------------------------------------
 
-    private fun resolveSegmentPath(relativePath: String): String? {
+    private fun resolveSegmentPath(relativePath: String, expectedSha256: String): String? {
         // 1. Try OTA bundle directory first
         val otaBundlePath = getOtaBundlePath()
         if (!otaBundlePath.isNullOrEmpty()) {
@@ -136,14 +171,17 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         }
 
         // 2. Try builtin: extract from assets if needed
-        return extractBuiltinSegmentIfNeeded(relativePath)
+        return extractBuiltinSegmentIfNeeded(relativePath, expectedSha256)
     }
 
     /**
      * For Android builtin segments, APK assets can't be passed directly as file paths.
      * Extract the asset to the extract cache directory on first access.
+     *
+     * #16: Validates extracted file size against the asset to detect truncated extractions.
+     * #18: Uses semaphore to limit concurrent extractions.
      */
-    private fun extractBuiltinSegmentIfNeeded(relativePath: String): String? {
+    private fun extractBuiltinSegmentIfNeeded(relativePath: String, expectedSha256: String): String? {
         val context = reactApplicationContext
         val nativeVersion = try {
             context.packageManager
@@ -155,32 +193,101 @@ class SplitBundleLoaderModule(reactContext: ReactApplicationContext) :
         val extractDir = File(context.filesDir, "$BUILTIN_EXTRACT_DIR/$nativeVersion")
         val extractedFile = File(extractDir, relativePath)
 
-        // Already extracted
+        // #16: If file exists, verify it's not truncated by checking size against asset
         if (extractedFile.exists()) {
-            return extractedFile.absolutePath
+            val assetSize = getAssetSize(context.assets, relativePath)
+            if (assetSize >= 0 && extractedFile.length() == assetSize) {
+                return extractedFile.absolutePath
+            }
+            // Truncated or size mismatch — delete and re-extract
+            SBLLogger.warn("Extracted file size mismatch for $relativePath, re-extracting")
+            extractedFile.delete()
         }
 
-        // Extract from assets
-        val assets: AssetManager = context.assets
-        return try {
-            assets.open(relativePath).use { input ->
-                extractedFile.parentFile?.let { parent ->
-                    if (!parent.exists()) parent.mkdirs()
+        // #18: Limit concurrent extractions
+        extractSemaphore.acquire()
+        try {
+            // Double-check after acquiring semaphore (another thread may have extracted)
+            if (extractedFile.exists()) {
+                return extractedFile.absolutePath
+            }
+
+            val assets: AssetManager = context.assets
+            return try {
+                // Extract to temp file first, then atomically rename
+                val tempFile = File(extractedFile.parentFile, "${extractedFile.name}.tmp")
+                assets.open(relativePath).use { input ->
+                    extractedFile.parentFile?.let { parent ->
+                        if (!parent.exists()) parent.mkdirs()
+                    }
+                    FileOutputStream(tempFile).use { output ->
+                        val buffer = ByteArray(8192)
+                        var len: Int
+                        while (input.read(buffer).also { len = it } != -1) {
+                            output.write(buffer, 0, len)
+                        }
+                    }
                 }
-                FileOutputStream(extractedFile).use { output ->
+                // Atomic rename prevents partial file observation
+                if (tempFile.renameTo(extractedFile)) {
+                    extractedFile.absolutePath
+                } else {
+                    tempFile.delete()
+                    null
+                }
+            } catch (_: IOException) {
+                null
+            }
+        } finally {
+            extractSemaphore.release()
+        }
+    }
+
+    /**
+     * Returns the size of an asset file, or -1 if it can't be determined.
+     */
+    private fun getAssetSize(assets: AssetManager, assetPath: String): Long {
+        return try {
+            assets.openFd(assetPath).use { it.length }
+        } catch (_: IOException) {
+            // Asset may be compressed; fall back to reading the stream
+            try {
+                assets.open(assetPath).use { input ->
+                    var size = 0L
                     val buffer = ByteArray(8192)
                     var len: Int
                     while (input.read(buffer).also { len = it } != -1) {
-                        output.write(buffer, 0, len)
+                        size += len
                     }
+                    size
                 }
+            } catch (_: IOException) {
+                -1
             }
-            extractedFile.absolutePath
-        } catch (_: IOException) {
-            null
         }
     }
 
+    /**
+     * #17: Asynchronously clean up extract directories from previous native versions.
+     */
+    private fun cleanupOldExtractDirs(context: Context, currentVersion: String) {
+        Thread {
+            try {
+                val baseDir = File(context.filesDir, BUILTIN_EXTRACT_DIR)
+                if (!baseDir.exists() || !baseDir.isDirectory) return@Thread
+                val dirs = baseDir.listFiles() ?: return@Thread
+                for (dir in dirs) {
+                    if (dir.isDirectory && dir.name != currentVersion) {
+                        SBLLogger.info("Cleaning up old extract dir: ${dir.name}")
+                        dir.deleteRecursively()
+                    }
+                }
+            } catch (e: Exception) {
+                SBLLogger.warn("Failed to cleanup old extract dirs: ${e.message}")
+            }
+        }.start()
+    }
+
     private fun getOtaBundlePath(): String? {
         return try {
             val bundleUpdateStore = Class.forName(

package/ios/SplitBundleLoader.mm

@@ -2,6 +2,11 @@
 #import "SBLLogger.h"
 #import <React/RCTBridge.h>
 
+// Bridgeless (New Architecture) support: RCTHost segment registration
+@interface RCTHost (SplitBundle)
+- (void)registerSegmentWithId:(NSNumber *)segmentId path:(NSString *)path;
+@end
+
 @implementation SplitBundleLoader
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
@@ -21,6 +26,73 @@
     return NO;
 }
 
+// MARK: - OTA bundle path helper
+
+/// Safely retrieves the OTA bundle path via typed NSInvocation to avoid
+/// performSelector ARC/signature issues (#15).
++ (nullable NSString *)otaBundlePath
+{
+    Class cls = NSClassFromString(@"ReactNativeBundleUpdate.BundleUpdateStore");
+    if (!cls) return nil;
+
+    SEL sel = NSSelectorFromString(@"currentBundleMainJSBundle");
+    if (![cls respondsToSelector:sel]) return nil;
+
+    NSMethodSignature *sig = [cls methodSignatureForSelector:sel];
+    if (!sig || strcmp(sig.methodReturnType, @encode(id)) != 0) {
+        [SBLLogger warn:@"OTA method signature mismatch — skipping"];
+        return nil;
+    }
+
+    NSInvocation *inv = [NSInvocation invocationWithMethodSignature:sig];
+    inv.target = cls;
+    inv.selector = sel;
+    [inv invoke];
+
+    __unsafe_unretained id rawResult = nil;
+    [inv getReturnValue:&rawResult];
+    if (![rawResult isKindOfClass:[NSString class]]) return nil;
+
+    NSString *result = (NSString *)rawResult;
+    if (result.length == 0) return nil;
+
+    if ([result hasPrefix:@"file://"]) {
+        result = [[NSURL URLWithString:result] path];
+    }
+    return result;
+}
+
+// MARK: - Segment registration helper
+
+/// Registers a segment with the current runtime, supporting both legacy bridge
+/// and bridgeless (RCTHost) architectures (#13).
++ (BOOL)registerSegment:(int)segmentId path:(NSString *)path error:(NSError **)outError
+{
+    // Try legacy bridge first
+    RCTBridge *bridge = [RCTBridge currentBridge];
+    if (bridge && [bridge respondsToSelector:@selector(registerSegmentWithId:path:)]) {
+        [bridge registerSegmentWithId:@(segmentId) path:path];
+        return YES;
+    }
+
+    // Try bridgeless RCTHost via AppDelegate
+    id<UIApplicationDelegate> appDelegate = [UIApplication sharedApplication].delegate;
+    if ([appDelegate respondsToSelector:NSSelectorFromString(@"reactHost")]) {
+        id host = [appDelegate performSelector:NSSelectorFromString(@"reactHost")];
+        if (host && [host respondsToSelector:@selector(registerSegmentWithId:path:)]) {
+            [host registerSegmentWithId:@(segmentId) path:path];
+            return YES;
+        }
+    }
+
+    if (outError) {
+        *outError = [NSError errorWithDomain:@"SplitBundleLoader"
+                                        code:1
+                                    userInfo:@{NSLocalizedDescriptionKey: @"Neither RCTBridge nor RCTHost available for segment registration"}];
+    }
+    return NO;
+}
+
 // MARK: - getRuntimeBundleContext
 
 - (void)getRuntimeBundleContext:(RCTPromiseResolveBlock)resolve
@@ -33,31 +105,12 @@
         NSString *nativeVersion = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleShortVersionString"] ?: @"";
         NSString *bundleVersion = @"";
 
-        // Check if OTA bundle is active via BundleUpdateStore
-        Class bundleUpdateStoreClass = NSClassFromString(@"ReactNativeBundleUpdate.BundleUpdateStore");
-        if (bundleUpdateStoreClass) {
-            NSString *otaBundlePath = nil;
-            SEL sel = NSSelectorFromString(@"currentBundleMainJSBundle");
-            if ([bundleUpdateStoreClass respondsToSelector:sel]) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-                id result = [bundleUpdateStoreClass performSelector:sel];
-#pragma clang diagnostic pop
-                otaBundlePath = [result isKindOfClass:[NSString class]] ? (NSString *)result : nil;
-            }
-            if (otaBundlePath && otaBundlePath.length > 0) {
-                NSString *filePath = otaBundlePath;
-                if ([otaBundlePath hasPrefix:@"file://"]) {
-                    filePath = [[NSURL URLWithString:otaBundlePath] path];
-                }
-                if ([[NSFileManager defaultManager] fileExistsAtPath:filePath]) {
-                    sourceKind = @"ota";
-                    bundleRoot = [filePath stringByDeletingLastPathComponent];
-                }
-            }
+        NSString *otaPath = [SplitBundleLoader otaBundlePath];
+        if (otaPath && [[NSFileManager defaultManager] fileExistsAtPath:otaPath]) {
+            sourceKind = @"ota";
+            bundleRoot = [otaPath stringByDeletingLastPathComponent];
         }
 
-        // Builtin: use main bundle resource path
         if ([sourceKind isEqualToString:@"builtin"]) {
             bundleRoot = [[NSBundle mainBundle] resourcePath] ?: @"";
         }
@@ -85,32 +138,15 @@
 {
     @try {
         int segId = (int)segmentId;
-
-        // Resolve absolute path
         NSString *absolutePath = nil;
 
         // 1. Try OTA bundle root first
-        Class bundleUpdateStoreClass = NSClassFromString(@"ReactNativeBundleUpdate.BundleUpdateStore");
-        if (bundleUpdateStoreClass) {
-            NSString *otaBundlePath = nil;
-            SEL sel = NSSelectorFromString(@"currentBundleMainJSBundle");
-            if ([bundleUpdateStoreClass respondsToSelector:sel]) {
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
-                id result = [bundleUpdateStoreClass performSelector:sel];
-#pragma clang diagnostic pop
-                otaBundlePath = [result isKindOfClass:[NSString class]] ? (NSString *)result : nil;
-            }
-            if (otaBundlePath && otaBundlePath.length > 0) {
-                NSString *filePath = otaBundlePath;
-                if ([otaBundlePath hasPrefix:@"file://"]) {
-                    filePath = [[NSURL URLWithString:otaBundlePath] path];
-                }
-                NSString *otaRoot = [filePath stringByDeletingLastPathComponent];
-                NSString *candidate = [otaRoot stringByAppendingPathComponent:relativePath];
-                if ([[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
-                    absolutePath = candidate;
-                }
+        NSString *otaPath = [SplitBundleLoader otaBundlePath];
+        if (otaPath) {
+            NSString *otaRoot = [otaPath stringByDeletingLastPathComponent];
+            NSString *candidate = [otaRoot stringByAppendingPathComponent:relativePath];
+            if ([[NSFileManager defaultManager] fileExistsAtPath:candidate]) {
+                absolutePath = candidate;
             }
         }
 
@@ -130,14 +166,15 @@
             return;
         }
 
-        // Register segment via RCTBridge
-        RCTBridge *bridge = [RCTBridge currentBridge];
-        if (bridge) {
-            [bridge registerSegmentWithId:@(segId) path:absolutePath];
+        // Register segment (#13: supports both bridge and bridgeless)
+        NSError *regError = nil;
+        if ([SplitBundleLoader registerSegment:segId path:absolutePath error:&regError]) {
             [SBLLogger info:[NSString stringWithFormat:@"Loaded segment %@ (id=%d)", segmentKey, segId]];
             resolve(nil);
         } else {
-            reject(@"SPLIT_BUNDLE_NO_BRIDGE", @"RCTBridge not available", nil);
+            reject(@"SPLIT_BUNDLE_NO_RUNTIME",
+                   regError.localizedDescription ?: @"Runtime not available",
+                   regError);
         }
     } @catch (NSException *exception) {
         reject(@"SPLIT_BUNDLE_LOAD_ERROR",

package/package.json

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