@vanikya/ota-react-native 0.1.8 → 0.2.0

package/README.md

@@ -46,12 +46,101 @@ eas build --platform ios
 
 ### For bare React Native apps
 
-Install pods (iOS):
+1. Install pods (iOS):
 
 ```bash
 cd ios && pod install
 ```
 
+2. **IMPORTANT**: You must manually configure native code to load OTA bundles. Without this, downloaded bundles will never be applied.
+
+#### Android Setup (MainApplication.kt)
+
+Add the `getJSBundleFile()` override inside your `ReactNativeHost`:
+
+```kotlin
+import android.content.SharedPreferences
+import java.io.File
+
+// Inside your MainApplication class, find the ReactNativeHost and add:
+override fun getJSBundleFile(): String? {
+    val prefs: SharedPreferences = applicationContext.getSharedPreferences("OTAUpdate", android.content.Context.MODE_PRIVATE)
+    val bundlePath = prefs.getString("BundlePath", null)
+    if (bundlePath != null && File(bundlePath).exists()) {
+        return bundlePath
+    }
+    return null  // Falls back to default bundle
+}
+```
+
+Example full `MainApplication.kt`:
+
+```kotlin
+package com.yourapp
+
+import android.app.Application
+import android.content.SharedPreferences
+import java.io.File
+import com.facebook.react.PackageList
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.defaults.DefaultReactNativeHost
+
+class MainApplication : Application(), ReactApplication {
+
+    override val reactNativeHost: ReactNativeHost =
+        object : DefaultReactNativeHost(this) {
+            // ADD THIS METHOD for OTA updates
+            override fun getJSBundleFile(): String? {
+                val prefs: SharedPreferences = applicationContext.getSharedPreferences("OTAUpdate", android.content.Context.MODE_PRIVATE)
+                val bundlePath = prefs.getString("BundlePath", null)
+                if (bundlePath != null && File(bundlePath).exists()) {
+                    return bundlePath
+                }
+                return null
+            }
+
+            override fun getPackages() = PackageList(this).packages
+            override fun getJSMainModuleName() = "index"
+            override fun getUseDeveloperSupport() = BuildConfig.DEBUG
+            override val isNewArchEnabled = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            override val isHermesEnabled = BuildConfig.IS_HERMES_ENABLED
+        }
+
+    // ... rest of your MainApplication
+}
+```
+
+#### iOS Setup (AppDelegate.swift)
+
+Modify `bundleURL()` to check for OTA bundles first:
+
+```swift
+// Add this helper function inside AppDelegate class
+private func getOTABundleURL() -> URL? {
+    if let bundlePath = UserDefaults.standard.string(forKey: "OTAUpdateBundlePath") {
+        if FileManager.default.fileExists(atPath: bundlePath) {
+            return URL(fileURLWithPath: bundlePath)
+        }
+    }
+    return nil
+}
+
+// Modify or add this bundleURL function
+func bundleURL() -> URL? {
+    // Check for downloaded OTA bundle first
+    if let otaBundle = getOTABundleURL() {
+        return otaBundle
+    }
+    #if DEBUG
+    return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
+    #else
+    return Bundle.main.url(forResource: "main", withExtension: "jsbundle")
+    #endif
+}
+```
+
 ## Quick Start
 
 ### 1. Wrap your app with OTAProvider
@@ -339,6 +428,51 @@ async function recoverFromCorruptedUpdate() {
 
 The SDK now validates downloaded bundles to prevent HTML error pages or corrupted files from being saved as bundles.
 
+## Troubleshooting
+
+### Update downloads but doesn't apply after restart
+
+This is usually because the native code to load OTA bundles is missing. Check:
+
+1. **For Expo apps**: Make sure you rebuilt the app with EAS Build after adding the plugin. OTA updates do NOT work in Expo Go.
+
+2. **For bare React Native**: Make sure you added the native code changes described in the "For bare React Native apps" section above.
+
+3. **Verify native code was injected**: During the EAS build, look for these log messages:
+   - `[OTAUpdate] Android: Successfully injected getJSBundleFile`
+   - `[OTAUpdate] iOS: Successfully modified bundleURL`
+
+4. **Check if bundle path is saved**: The path is stored in:
+   - Android: SharedPreferences key `"BundlePath"` in `"OTAUpdate"` preferences
+   - iOS: UserDefaults key `"OTAUpdateBundlePath"`
+
+### Bundle downloads but hash verification fails
+
+1. Make sure your server is returning the actual JavaScript bundle, not an HTML error page
+2. Check that the bundle wasn't corrupted during upload
+3. Try re-publishing the release with `ota release`
+
+### App crashes after OTA update
+
+Call `clearCorruptedBundle()` on app startup to recover:
+
+```tsx
+import { UpdateStorage } from '@vanikya/ota-react-native';
+
+// In your App.tsx or entry point
+useEffect(() => {
+  const storage = new UpdateStorage();
+  storage.clearCorruptedBundle();
+}, []);
+```
+
+### Debugging
+
+Enable debug logs by checking `__DEV__` console output. The SDK logs:
+- `[OTAUpdate] Bundle registered with native module`
+- `[OTAUpdate] Bundle verified successfully`
+- `[OTAUpdate] Update ready`
+
 ## License
 
 MIT

package/android/src/main/java/com/otaupdate/OTAUpdateModule.kt

@@ -5,6 +5,10 @@ import android.content.SharedPreferences
 import android.util.Base64
 import com.facebook.react.bridge.*
 import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import java.net.HttpURLConnection
+import java.net.URL
 import java.security.MessageDigest
 
 class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
@@ -92,6 +96,65 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
         }
     }
 
+    // Download file directly to disk - bypasses JS memory entirely
+    // This is critical for large bundles (5MB+)
+    @ReactMethod
+    fun downloadFile(urlString: String, destPath: String, promise: Promise) {
+        Thread {
+            var connection: HttpURLConnection? = null
+            var inputStream: InputStream? = null
+            var outputStream: FileOutputStream? = null
+
+            try {
+                val url = URL(urlString)
+                connection = url.openConnection() as HttpURLConnection
+                connection.connectTimeout = 30000
+                connection.readTimeout = 60000
+                connection.requestMethod = "GET"
+                connection.connect()
+
+                val responseCode = connection.responseCode
+                if (responseCode != HttpURLConnection.HTTP_OK) {
+                    promise.reject("DOWNLOAD_ERROR", "Download failed with status $responseCode")
+                    return@Thread
+                }
+
+                // Ensure parent directory exists
+                val destFile = File(destPath)
+                destFile.parentFile?.mkdirs()
+
+                inputStream = connection.inputStream
+                outputStream = FileOutputStream(destFile)
+
+                val buffer = ByteArray(8192) // 8KB buffer for efficient streaming
+                var bytesRead: Int
+                var totalBytesRead: Long = 0
+
+                while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+                    outputStream.write(buffer, 0, bytesRead)
+                    totalBytesRead += bytesRead
+                }
+
+                outputStream.flush()
+
+                val result = Arguments.createMap()
+                result.putDouble("fileSize", totalBytesRead.toDouble())
+                promise.resolve(result)
+
+            } catch (e: Exception) {
+                promise.reject("DOWNLOAD_ERROR", "Failed to download file: ${e.message}", e)
+            } finally {
+                try {
+                    inputStream?.close()
+                    outputStream?.close()
+                    connection?.disconnect()
+                } catch (e: Exception) {
+                    // Ignore cleanup errors
+                }
+            }
+        }.start()
+    }
+
     // Cryptography
 
     @ReactMethod
@@ -107,6 +170,37 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
         }
     }
 
+    // Calculate SHA256 from file path - streams file to avoid memory issues
+    // Critical for large bundles (5MB+)
+    @ReactMethod
+    fun calculateSHA256FromFile(filePath: String, promise: Promise) {
+        Thread {
+            try {
+                val file = File(filePath)
+                if (!file.exists()) {
+                    promise.reject("FILE_ERROR", "File not found: $filePath")
+                    return@Thread
+                }
+
+                val digest = MessageDigest.getInstance("SHA-256")
+                val buffer = ByteArray(8192) // 8KB buffer
+                var bytesRead: Int
+
+                file.inputStream().use { inputStream ->
+                    while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+                        digest.update(buffer, 0, bytesRead)
+                    }
+                }
+
+                val hash = digest.digest()
+                val hexString = hash.joinToString("") { "%02x".format(it) }
+                promise.resolve(hexString)
+            } catch (e: Exception) {
+                promise.reject("HASH_ERROR", "Failed to calculate hash: ${e.message}", e)
+            }
+        }.start()
+    }
+
     @ReactMethod
     fun verifySignature(base64Content: String, signatureHex: String, publicKeyHex: String, promise: Promise) {
         // Ed25519 signature verification

package/app.plugin.js

@@ -1,6 +1,15 @@
-const { withMainApplication, withAppDelegate, withDangerousMod } = require('@expo/config-plugins');
-const fs = require('fs');
-const path = require('path');
+const { withMainApplication, withAppDelegate } = require('@expo/config-plugins');
+
+/**
+ * OTA Update Expo Config Plugin
+ *
+ * This plugin modifies the native code to enable OTA bundle loading:
+ * - Android: Overrides getJSBundleFile() in MainApplication.kt
+ * - iOS: Modifies bundleURL() in AppDelegate.swift
+ *
+ * The modifications check SharedPreferences (Android) / UserDefaults (iOS)
+ * for a pending OTA bundle path and load it instead of the default bundle.
+ */
 
 function withOTAUpdateAndroid(config) {
   return withMainApplication(config, (config) => {
@@ -8,25 +17,73 @@ function withOTAUpdateAndroid(config) {
 
     // Check if already modified
     if (contents.includes('getJSBundleFile')) {
+      console.log('[OTAUpdate] Android: getJSBundleFile already present, skipping');
       return config;
     }
 
     // Add imports if not present
     if (!contents.includes('import android.content.SharedPreferences')) {
+      // Find the package declaration and add imports after it
+      const packageMatch = contents.match(/^package\s+[\w.]+\s*\n/m);
+      if (packageMatch) {
+        const insertPos = packageMatch.index + packageMatch[0].length;
+        const imports = `\nimport android.content.SharedPreferences\nimport java.io.File\n`;
+        contents = contents.slice(0, insertPos) + imports + contents.slice(insertPos);
+      }
+    }
+
+    // Strategy 1: Look for "override val reactNativeHost" pattern (Expo SDK 50+)
+    // This is more reliable than matching getUseDeveloperSupport
+    const reactNativeHostPattern = /(override\s+val\s+reactNativeHost\s*:\s*ReactNativeHost\s*=\s*object\s*:\s*DefaultReactNativeHost\s*\(\s*this\s*\)\s*\{)/;
+
+    if (reactNativeHostPattern.test(contents)) {
+      const getJSBundleFileOverride = `
+      override fun getJSBundleFile(): String? {
+        val prefs: SharedPreferences = applicationContext.getSharedPreferences("OTAUpdate", android.content.Context.MODE_PRIVATE)
+        val bundlePath = prefs.getString("BundlePath", null)
+        if (bundlePath != null && File(bundlePath).exists()) {
+          return bundlePath
+        }
+        return null
+      }
+`;
       contents = contents.replace(
-        /^(package .+?\n)/m,
-        `$1\nimport android.content.SharedPreferences\nimport java.io.File\n`
+        reactNativeHostPattern,
+        `$1${getJSBundleFileOverride}`
       );
+      console.log('[OTAUpdate] Android: Successfully injected getJSBundleFile (pattern 1)');
+      config.modResults.contents = contents;
+      return config;
     }
 
-    // For Kotlin-based MainApplication (Expo SDK 50+)
-    // Find the ReactNativeHost and add getJSBundleFile override
-    const kotlinPattern = /override\s+fun\s+getUseDeveloperSupport\(\):\s+Boolean\s*=\s*BuildConfig\.DEBUG/;
+    // Strategy 2: Look for DefaultReactNativeHost with different formatting
+    const altPattern = /(object\s*:\s*DefaultReactNativeHost\s*\(\s*this\s*\)\s*\{)/;
 
-    if (kotlinPattern.test(contents)) {
+    if (altPattern.test(contents)) {
+      const getJSBundleFileOverride = `
+      override fun getJSBundleFile(): String? {
+        val prefs: SharedPreferences = applicationContext.getSharedPreferences("OTAUpdate", android.content.Context.MODE_PRIVATE)
+        val bundlePath = prefs.getString("BundlePath", null)
+        if (bundlePath != null && File(bundlePath).exists()) {
+          return bundlePath
+        }
+        return null
+      }
+`;
       contents = contents.replace(
-        kotlinPattern,
-        `override fun getJSBundleFile(): String? {
+        altPattern,
+        `$1${getJSBundleFileOverride}`
+      );
+      console.log('[OTAUpdate] Android: Successfully injected getJSBundleFile (pattern 2)');
+      config.modResults.contents = contents;
+      return config;
+    }
+
+    // Strategy 3: Look for getUseDeveloperSupport with flexible whitespace
+    const devSupportPattern = /(override\s+fun\s+getUseDeveloperSupport\s*\(\s*\)\s*[:\s]*Boolean\s*[=\{])/;
+
+    if (devSupportPattern.test(contents)) {
+      const getJSBundleFileOverride = `override fun getJSBundleFile(): String? {
         val prefs: SharedPreferences = applicationContext.getSharedPreferences("OTAUpdate", android.content.Context.MODE_PRIVATE)
         val bundlePath = prefs.getString("BundlePath", null)
         if (bundlePath != null && File(bundlePath).exists()) {
@@ -35,10 +92,45 @@ function withOTAUpdateAndroid(config) {
         return null
       }
 
-      override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG`
+      `;
+      contents = contents.replace(
+        devSupportPattern,
+        `${getJSBundleFileOverride}$1`
       );
+      console.log('[OTAUpdate] Android: Successfully injected getJSBundleFile (pattern 3)');
+      config.modResults.contents = contents;
+      return config;
+    }
+
+    // Strategy 4: Look for ReactNativeHost in any form
+    const genericPattern = /(ReactNativeHost\s*[\(\{])/;
+
+    if (genericPattern.test(contents)) {
+      // Find the opening brace after ReactNativeHost and insert after it
+      const match = contents.match(/ReactNativeHost[^{]*\{/);
+      if (match) {
+        const insertPos = match.index + match[0].length;
+        const getJSBundleFileOverride = `
+      override fun getJSBundleFile(): String? {
+        val prefs: SharedPreferences = applicationContext.getSharedPreferences("OTAUpdate", android.content.Context.MODE_PRIVATE)
+        val bundlePath = prefs.getString("BundlePath", null)
+        if (bundlePath != null && File(bundlePath).exists()) {
+          return bundlePath
+        }
+        return null
+      }
+`;
+        contents = contents.slice(0, insertPos) + getJSBundleFileOverride + contents.slice(insertPos);
+        console.log('[OTAUpdate] Android: Successfully injected getJSBundleFile (pattern 4)');
+        config.modResults.contents = contents;
+        return config;
+      }
     }
 
+    console.warn('[OTAUpdate] Android: Could not find suitable injection point for getJSBundleFile');
+    console.warn('[OTAUpdate] Android: Please manually add getJSBundleFile override to MainApplication.kt');
+    console.warn('[OTAUpdate] Android: See https://vanikya.github.io/ota-update/ for manual setup instructions');
+
     config.modResults.contents = contents;
     return config;
   });
@@ -50,17 +142,17 @@ function withOTAUpdateIOS(config) {
 
     // Check if already modified
     if (contents.includes('OTAUpdateBundlePath')) {
+      console.log('[OTAUpdate] iOS: OTAUpdateBundlePath already present, skipping');
       return config;
     }
 
     // For Swift AppDelegate
     if (config.modResults.language === 'swift') {
-      // Add helper function before the class closing brace
+      // Helper function to get OTA bundle URL
       const helperFunction = `
   // OTA Update: Check for downloaded bundle
   private func getOTABundleURL() -> URL? {
-    let defaults = UserDefaults.standard
-    if let bundlePath = defaults.string(forKey: "OTAUpdateBundlePath") {
+    if let bundlePath = UserDefaults.standard.string(forKey: "OTAUpdateBundlePath") {
       let fileURL = URL(fileURLWithPath: bundlePath)
       if FileManager.default.fileExists(atPath: bundlePath) {
         return fileURL
@@ -70,25 +162,109 @@ function withOTAUpdateIOS(config) {
   }
 `;
 
-      // Find bundleURL method and modify it
-      const bundleURLPattern = /func\s+bundleURL\(\)\s*->\s*URL\?\s*\{[\s\S]*?\n\s*\}/;
+      // Strategy 1: Look for bundleURL() with flexible pattern
+      // Match: func bundleURL() -> URL? { ... } with any content inside
+      const bundleURLPattern1 = /(func\s+bundleURL\s*\(\s*\)\s*->\s*URL\?\s*\{)([\s\S]*?)(\n\s*\})/;
+
+      if (bundleURLPattern1.test(contents)) {
+        contents = contents.replace(
+          bundleURLPattern1,
+          (match, funcStart, funcBody, funcEnd) => {
+            // Check if it already has OTA check
+            if (funcBody.includes('getOTABundleURL')) {
+              return match;
+            }
+            return `${funcStart}
+    // OTA Update: Check for downloaded bundle first
+    if let otaBundle = getOTABundleURL() {
+      return otaBundle
+    }
+${funcBody}${funcEnd}${helperFunction}`;
+          }
+        );
+        console.log('[OTAUpdate] iOS: Successfully modified bundleURL (pattern 1)');
+        config.modResults.contents = contents;
+        return config;
+      }
+
+      // Strategy 2: Look for sourceURL(for bridge:) pattern (older Expo versions)
+      const sourceURLPattern = /(func\s+sourceURL\s*\(\s*for\s+bridge\s*:\s*RCTBridge\s*\)\s*->\s*URL\?\s*\{)([\s\S]*?)(\n\s*\})/;
 
-      if (bundleURLPattern.test(contents)) {
+      if (sourceURLPattern.test(contents)) {
         contents = contents.replace(
-          bundleURLPattern,
-          `func bundleURL() -> URL? {
+          sourceURLPattern,
+          (match, funcStart, funcBody, funcEnd) => {
+            if (funcBody.includes('getOTABundleURL')) {
+              return match;
+            }
+            return `${funcStart}
     // OTA Update: Check for downloaded bundle first
     if let otaBundle = getOTABundleURL() {
       return otaBundle
     }
+${funcBody}${funcEnd}${helperFunction}`;
+          }
+        );
+        console.log('[OTAUpdate] iOS: Successfully modified sourceURL (pattern 2)');
+        config.modResults.contents = contents;
+        return config;
+      }
+
+      // Strategy 3: Add bundleURL method if it doesn't exist but class exists
+      const appDelegateClassPattern = /(class\s+AppDelegate\s*[^{]*\{)/;
+
+      if (appDelegateClassPattern.test(contents) && !contents.includes('func bundleURL')) {
+        const newBundleURLMethod = `
+  // OTA Update: Bundle URL with OTA support
+  func bundleURL() -> URL? {
+    // Check for downloaded OTA bundle first
+    if let otaBundle = getOTABundleURL() {
+      return otaBundle
+    }
     #if DEBUG
     return RCTBundleURLProvider.sharedSettings().jsBundleURL(forBundleRoot: "index")
     #else
     return Bundle.main.url(forResource: "main", withExtension: "jsbundle")
     #endif
   }
-${helperFunction}`
+${helperFunction}
+`;
+        contents = contents.replace(
+          appDelegateClassPattern,
+          `$1${newBundleURLMethod}`
         );
+        console.log('[OTAUpdate] iOS: Successfully added bundleURL method (pattern 3)');
+        config.modResults.contents = contents;
+        return config;
+      }
+
+      console.warn('[OTAUpdate] iOS: Could not find suitable injection point');
+      console.warn('[OTAUpdate] iOS: Please manually modify AppDelegate.swift');
+      console.warn('[OTAUpdate] iOS: See https://vanikya.github.io/ota-update/ for manual setup instructions');
+    } else if (config.modResults.language === 'objc' || config.modResults.language === 'objcpp') {
+      // Objective-C AppDelegate (older Expo versions)
+      const sourceURLPattern = /(- \(NSURL \*\)sourceURLForBridge:\(RCTBridge \*\)bridge\s*\{)([\s\S]*?)(\n\})/;
+
+      if (sourceURLPattern.test(contents)) {
+        const helperCode = `
+  // Check for OTA bundle
+  NSString *bundlePath = [[NSUserDefaults standardUserDefaults] stringForKey:@"OTAUpdateBundlePath"];
+  if (bundlePath && [[NSFileManager defaultManager] fileExistsAtPath:bundlePath]) {
+    return [NSURL fileURLWithPath:bundlePath];
+  }
+`;
+        contents = contents.replace(
+          sourceURLPattern,
+          (match, funcStart, funcBody, funcEnd) => {
+            if (funcBody.includes('OTAUpdateBundlePath')) {
+              return match;
+            }
+            return `${funcStart}${helperCode}${funcBody}${funcEnd}`;
+          }
+        );
+        console.log('[OTAUpdate] iOS: Successfully modified sourceURLForBridge (Obj-C)');
+        config.modResults.contents = contents;
+        return config;
       }
     }
 
@@ -102,3 +278,7 @@ module.exports = function withOTAUpdate(config) {
   config = withOTAUpdateIOS(config);
   return config;
 };
+
+// Export individual functions for testing
+module.exports.withOTAUpdateAndroid = withOTAUpdateAndroid;
+module.exports.withOTAUpdateIOS = withOTAUpdateIOS;

package/ios/OTAUpdate.m

@@ -35,11 +35,20 @@ RCT_EXTERN_METHOD(makeDirectory:(NSString *)path
                   resolver:(RCTPromiseResolveBlock)resolver
                   rejecter:(RCTPromiseRejectBlock)rejecter)
 
+RCT_EXTERN_METHOD(downloadFile:(NSString *)urlString
+                  destPath:(NSString *)destPath
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
 // Cryptography
 RCT_EXTERN_METHOD(calculateSHA256:(NSString *)base64Content
                   resolver:(RCTPromiseResolveBlock)resolver
                   rejecter:(RCTPromiseRejectBlock)rejecter)
 
+RCT_EXTERN_METHOD(calculateSHA256FromFile:(NSString *)filePath
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
 RCT_EXTERN_METHOD(verifySignature:(NSString *)base64Content
                   signatureHex:(NSString *)signatureHex
                   publicKeyHex:(NSString *)publicKeyHex