@vanikya/ota-react-native 0.1.9 → 0.2.2

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/AndroidManifest.xml

@@ -1,3 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- Internet permission is required for downloading OTA bundles -->
+    <uses-permission android:name="android.permission.INTERNET" />
 </manifest>

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

@@ -2,6 +2,8 @@ package com.otaupdate
 
 import android.content.Context
 import android.content.SharedPreferences
+import android.os.Handler
+import android.os.Looper
 import android.util.Base64
 import com.facebook.react.bridge.*
 import java.io.File
@@ -10,6 +12,7 @@ import java.io.InputStream
 import java.net.HttpURLConnection
 import java.net.URL
 import java.security.MessageDigest
+import java.util.concurrent.Executors
 
 class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
@@ -17,6 +20,12 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
         reactContext.getSharedPreferences("OTAUpdate", Context.MODE_PRIVATE)
     }
 
+    // Use a thread pool for background operations instead of raw threads
+    private val executor = Executors.newFixedThreadPool(2)
+
+    // Handler to post results back to the main thread
+    private val mainHandler = Handler(Looper.getMainLooper())
+
     override fun getName(): String = "OTAUpdate"
 
     // File System Operations
@@ -100,25 +109,33 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     // This is critical for large bundles (5MB+)
     @ReactMethod
     fun downloadFile(urlString: String, destPath: String, promise: Promise) {
-        Thread {
+        executor.execute {
             var connection: HttpURLConnection? = null
             var inputStream: InputStream? = null
             var outputStream: FileOutputStream? = null
 
             try {
+                android.util.Log.d("OTAUpdate", "Starting download from: $urlString to: $destPath")
+
                 val url = URL(urlString)
                 connection = url.openConnection() as HttpURLConnection
                 connection.connectTimeout = 30000
-                connection.readTimeout = 60000
+                connection.readTimeout = 120000 // Increased read timeout for large files
                 connection.requestMethod = "GET"
+                connection.setRequestProperty("Accept-Encoding", "identity") // Disable compression for reliable streaming
                 connection.connect()
 
                 val responseCode = connection.responseCode
                 if (responseCode != HttpURLConnection.HTTP_OK) {
-                    promise.reject("DOWNLOAD_ERROR", "Download failed with status $responseCode")
-                    return@Thread
+                    val errorMsg = "Download failed with status $responseCode"
+                    android.util.Log.e("OTAUpdate", errorMsg)
+                    mainHandler.post { promise.reject("DOWNLOAD_ERROR", errorMsg) }
+                    return@execute
                 }
 
+                val contentLength = connection.contentLengthLong
+                android.util.Log.d("OTAUpdate", "Content-Length: $contentLength bytes")
+
                 // Ensure parent directory exists
                 val destFile = File(destPath)
                 destFile.parentFile?.mkdirs()
@@ -137,22 +154,36 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
                 outputStream.flush()
 
+                // Verify written file size
+                val writtenSize = destFile.length()
+                android.util.Log.d("OTAUpdate", "Download complete: $totalBytesRead bytes read, $writtenSize bytes written")
+
+                if (contentLength > 0 && writtenSize != contentLength) {
+                    val errorMsg = "File size mismatch: expected $contentLength, got $writtenSize"
+                    android.util.Log.e("OTAUpdate", errorMsg)
+                    destFile.delete()
+                    mainHandler.post { promise.reject("DOWNLOAD_ERROR", errorMsg) }
+                    return@execute
+                }
+
                 val result = Arguments.createMap()
                 result.putDouble("fileSize", totalBytesRead.toDouble())
-                promise.resolve(result)
+                // Resolve promise on main thread to avoid React Native bridge issues
+                mainHandler.post { promise.resolve(result) }
 
             } catch (e: Exception) {
-                promise.reject("DOWNLOAD_ERROR", "Failed to download file: ${e.message}", e)
+                android.util.Log.e("OTAUpdate", "Download failed: ${e.message}", e)
+                mainHandler.post { 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
+                    android.util.Log.w("OTAUpdate", "Error during cleanup: ${e.message}")
                 }
             }
-        }.start()
+        }
     }
 
     // Cryptography
@@ -174,14 +205,16 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     // Critical for large bundles (5MB+)
     @ReactMethod
     fun calculateSHA256FromFile(filePath: String, promise: Promise) {
-        Thread {
+        executor.execute {
             try {
                 val file = File(filePath)
                 if (!file.exists()) {
-                    promise.reject("FILE_ERROR", "File not found: $filePath")
-                    return@Thread
+                    mainHandler.post { promise.reject("FILE_ERROR", "File not found: $filePath") }
+                    return@execute
                 }
 
+                android.util.Log.d("OTAUpdate", "Calculating hash for: $filePath (${file.length()} bytes)")
+
                 val digest = MessageDigest.getInstance("SHA-256")
                 val buffer = ByteArray(8192) // 8KB buffer
                 var bytesRead: Int
@@ -194,11 +227,14 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
                 val hash = digest.digest()
                 val hexString = hash.joinToString("") { "%02x".format(it) }
-                promise.resolve(hexString)
+                android.util.Log.d("OTAUpdate", "Hash calculated: $hexString")
+                // Resolve promise on main thread
+                mainHandler.post { promise.resolve(hexString) }
             } catch (e: Exception) {
-                promise.reject("HASH_ERROR", "Failed to calculate hash: ${e.message}", e)
+                android.util.Log.e("OTAUpdate", "Hash calculation failed: ${e.message}", e)
+                mainHandler.post { promise.reject("HASH_ERROR", "Failed to calculate hash: ${e.message}", e) }
             }
-        }.start()
+        }
     }
 
     @ReactMethod
@@ -229,21 +265,69 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
     @ReactMethod
     fun applyBundle(bundlePath: String, restart: Boolean, promise: Promise) {
         try {
+            // Validate bundle file exists before storing path
+            val bundleFile = File(bundlePath)
+            if (!bundleFile.exists()) {
+                promise.reject("APPLY_ERROR", "Bundle file does not exist: $bundlePath")
+                return
+            }
+            if (!bundleFile.canRead()) {
+                promise.reject("APPLY_ERROR", "Bundle file is not readable: $bundlePath")
+                return
+            }
+            if (bundleFile.length() < 100) {
+                promise.reject("APPLY_ERROR", "Bundle file is too small (likely corrupted): ${bundleFile.length()} bytes")
+                return
+            }
+
+            // Log for debugging
+            android.util.Log.d("OTAUpdate", "Applying bundle: $bundlePath (${bundleFile.length()} bytes)")
+
             // Store the bundle path for next launch
-            prefs.edit().putString("BundlePath", bundlePath).apply()
+            // CRITICAL: Use commit() instead of apply() to ensure synchronous write
+            // This prevents a race condition where the app kills before the write completes
+            val success = prefs.edit().putString("BundlePath", bundlePath).commit()
+            if (!success) {
+                android.util.Log.e("OTAUpdate", "Failed to save bundle path to SharedPreferences")
+                promise.reject("APPLY_ERROR", "Failed to save bundle path")
+                return
+            }
+            android.util.Log.d("OTAUpdate", "Bundle path saved to SharedPreferences: $bundlePath")
+
+            // Verify the path was actually saved
+            val savedPath = prefs.getString("BundlePath", null)
+            if (savedPath != bundlePath) {
+                android.util.Log.e("OTAUpdate", "Bundle path verification failed: expected $bundlePath, got $savedPath")
+                promise.reject("APPLY_ERROR", "Bundle path verification failed")
+                return
+            }
 
             if (restart) {
-                // Restart the app
-                val context = reactApplicationContext
-                val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-                intent?.addFlags(android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                intent?.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
-                context.startActivity(intent)
-                android.os.Process.killProcess(android.os.Process.myPid())
+                android.util.Log.d("OTAUpdate", "Restarting app to apply bundle...")
+
+                // Resolve promise before restarting so JS knows it succeeded
+                promise.resolve(null)
+
+                // Give a small delay to ensure the promise is sent back to JS
+                mainHandler.postDelayed({
+                    // Restart the app
+                    val context = reactApplicationContext
+                    val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+                    intent?.addFlags(android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP)
+                    intent?.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
+                    intent?.addFlags(android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                    context.startActivity(intent)
+
+                    // Small delay before killing to allow activity to start
+                    mainHandler.postDelayed({
+                        android.os.Process.killProcess(android.os.Process.myPid())
+                    }, 100)
+                }, 100)
+            } else {
+                promise.resolve(null)
             }
-
-            promise.resolve(null)
         } catch (e: Exception) {
+            android.util.Log.e("OTAUpdate", "Failed to apply bundle: ${e.message}", e)
             promise.reject("APPLY_ERROR", "Failed to apply bundle: ${e.message}", e)
         }
     }
@@ -256,7 +340,8 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
 
     @ReactMethod
     fun clearPendingBundle(promise: Promise) {
-        prefs.edit().remove("BundlePath").apply()
+        prefs.edit().remove("BundlePath").commit()
+        android.util.Log.d("OTAUpdate", "Pending bundle cleared")
         promise.resolve(null)
     }
 
@@ -273,6 +358,12 @@ class OTAUpdateModule(reactContext: ReactApplicationContext) : ReactContextBaseJ
         return data
     }
 
+    // Cleanup executor when module is destroyed
+    override fun onCatalystInstanceDestroy() {
+        super.onCatalystInstanceDestroy()
+        executor.shutdown()
+    }
+
     companion object {
         const val NAME = "OTAUpdate"
     }