@otaupdate/react-native 1.0.0

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

@@ -0,0 +1,211 @@
+package com.otaupdate
+
+import android.util.Log
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+
+/** Thrown for any recoverable download/verify/unzip failure. */
+class OtaInstallException(message: String, cause: Throwable? = null) : Exception(message, cause)
+
+data class InstalledPackage(val bundlePath: String, val packageHash: String, val size: Long)
+
+/**
+ * Downloads a release zip, verifies its SHA-256 against the value the server
+ * published, and unzips it into the store. Verification happens before
+ * anything is unpacked, so a corrupted or tampered payload never reaches disk
+ * as a runnable bundle.
+ */
+object OtaUpdateInstaller {
+
+  private const val BUFFER_SIZE = 8 * 1024
+  private const val CONNECT_TIMEOUT_MS = 15_000
+  private const val READ_TIMEOUT_MS = 60_000
+
+  /**
+   * Decompression bomb guards. A verified SHA-256 proves the archive is the one
+   * the server published — it says nothing about how much it expands to. A
+   * hostile or corrupt package could otherwise fill the device.
+   */
+  private const val MAX_COMPRESSION_RATIO = 120L
+  private const val MAX_TOTAL_EXTRACTED_BYTES = 600L * 1024 * 1024
+  private const val MAX_ENTRIES = 20_000
+
+  /** Filenames React Native will accept as the JS bundle. */
+  private val BUNDLE_CANDIDATES = listOf("index.android.bundle", "main.jsbundle", "index.bundle")
+
+  fun install(
+    store: OtaUpdateStore,
+    downloadUrl: String,
+    expectedHash: String,
+    onProgress: (received: Long, total: Long) -> Unit,
+  ): InstalledPackage {
+    if (store.hasFailed(expectedHash)) {
+      throw OtaInstallException(
+        "Refusing to reinstall $expectedHash — a previous attempt failed to boot",
+      )
+    }
+
+    val targetDir = store.packageDir(expectedHash)
+    // Already downloaded and verified on an earlier attempt.
+    resolveBundle(targetDir)?.let { existing ->
+      return InstalledPackage(existing.absolutePath, expectedHash, dirSize(targetDir))
+    }
+
+    val tempZip = File.createTempFile("ota-", ".zip", store.packageDir("").parentFile)
+    try {
+      val actualHash = download(downloadUrl, tempZip, onProgress)
+      if (!actualHash.equals(expectedHash, ignoreCase = true)) {
+        throw OtaInstallException(
+          "Bundle integrity check failed: expected $expectedHash but downloaded $actualHash",
+        )
+      }
+
+      targetDir.deleteRecursively()
+      targetDir.mkdirs()
+      unzip(tempZip, targetDir, tempZip.length())
+
+      val bundle = resolveBundle(targetDir)
+        ?: throw OtaInstallException(
+          "The release package contains no JS bundle (looked for ${BUNDLE_CANDIDATES.joinToString(", ")})",
+        )
+
+      return InstalledPackage(bundle.absolutePath, expectedHash, dirSize(targetDir))
+    } catch (e: Exception) {
+      targetDir.deleteRecursively()
+      throw if (e is OtaInstallException) e else OtaInstallException(e.message ?: "Update failed", e)
+    } finally {
+      tempZip.delete()
+    }
+  }
+
+  /** Streams to disk while hashing, so the payload is never held in memory. */
+  private fun download(
+    url: String,
+    destination: File,
+    onProgress: (received: Long, total: Long) -> Unit,
+  ): String {
+    val connection = (URL(url).openConnection() as HttpURLConnection).apply {
+      connectTimeout = CONNECT_TIMEOUT_MS
+      readTimeout = READ_TIMEOUT_MS
+      instanceFollowRedirects = true
+      requestMethod = "GET"
+    }
+
+    try {
+      val status = connection.responseCode
+      if (status !in 200..299) {
+        throw OtaInstallException("Bundle download failed with HTTP $status")
+      }
+
+      val total = connection.contentLengthLong.takeIf { it > 0 } ?: -1L
+      val digest = MessageDigest.getInstance("SHA-256")
+      var received = 0L
+      var lastReported = 0L
+
+      connection.inputStream.use { input ->
+        FileOutputStream(destination).use { output ->
+          val buffer = ByteArray(BUFFER_SIZE)
+          while (true) {
+            val read = input.read(buffer)
+            if (read == -1) break
+            digest.update(buffer, 0, read)
+            output.write(buffer, 0, read)
+            received += read
+            // Throttle to ~1% steps; the bridge cannot keep up with per-chunk.
+            if (total <= 0 || received - lastReported >= total / 100 || received == total) {
+              lastReported = received
+              onProgress(received, total)
+            }
+          }
+        }
+      }
+
+      return digest.digest().joinToString("") { "%02x".format(it) }
+    } finally {
+      connection.disconnect()
+    }
+  }
+
+  private fun unzip(zip: File, targetDir: File, archiveBytes: Long) {
+    // Cap on total output, derived from the archive's own size. Streaming
+    // enforcement is required: an entry's declared size is attacker-controlled,
+    // so the only trustworthy number is what we have actually written.
+    val ceiling = minOf(
+      MAX_TOTAL_EXTRACTED_BYTES,
+      maxOf(archiveBytes, 1L) * MAX_COMPRESSION_RATIO,
+    )
+    var totalWritten = 0L
+    var entries = 0
+
+    ZipInputStream(zip.inputStream().buffered()).use { input ->
+      var entry: ZipEntry? = input.nextEntry
+      while (entry != null) {
+        if (++entries > MAX_ENTRIES) {
+          throw OtaInstallException("Release package has too many entries (> $MAX_ENTRIES)")
+        }
+
+        val outFile = File(targetDir, entry.name)
+        // Zip-slip guard: an entry name like ../../x would otherwise write
+        // outside the package directory.
+        if (!outFile.canonicalPath.startsWith(targetDir.canonicalPath + File.separator)) {
+          throw OtaInstallException("Refusing to extract unsafe zip entry: ${entry.name}")
+        }
+
+        if (entry.isDirectory) {
+          outFile.mkdirs()
+        } else {
+          outFile.parentFile?.mkdirs()
+          FileOutputStream(outFile).use { output ->
+            val buffer = ByteArray(BUFFER_SIZE)
+            while (true) {
+              val read = input.read(buffer)
+              if (read == -1) break
+              totalWritten += read
+              if (totalWritten > ceiling) {
+                throw OtaInstallException(
+                  "Release package expands beyond the safe limit (> $ceiling bytes) — refusing to extract",
+                )
+              }
+              output.write(buffer, 0, read)
+            }
+          }
+        }
+        input.closeEntry()
+        entry = input.nextEntry
+      }
+    }
+  }
+
+  /**
+   * Finds the JS bundle inside an extracted package. Tolerates archives that
+   * wrap everything in a single top-level folder, which is what most zip tools
+   * produce by default.
+   */
+  private fun resolveBundle(dir: File): File? {
+    if (!dir.isDirectory) return null
+
+    for (name in BUNDLE_CANDIDATES) {
+      val direct = File(dir, name)
+      if (direct.isFile) return direct
+    }
+
+    val children = dir.listFiles() ?: return null
+    val onlyDir = children.singleOrNull()?.takeIf { it.isDirectory }
+    if (onlyDir != null) {
+      resolveBundle(onlyDir)?.let { return it }
+    }
+
+    return dir.walkTopDown()
+      .maxDepth(4)
+      .firstOrNull { it.isFile && (it.name.endsWith(".bundle") || it.name.endsWith(".jsbundle")) }
+      ?.also { Log.i(OtaUpdateStore.TAG, "using bundle ${it.name} found at depth") }
+  }
+
+  private fun dirSize(dir: File): Long =
+    dir.walkTopDown().filter { it.isFile }.sumOf { it.length() }
+}

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

@@ -0,0 +1,278 @@
+package com.otaupdate
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.concurrent.Executors
+
+class OtaUpdateModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), LifecycleEventListener {
+
+  companion object {
+    const val NAME = "OtaUpdate"
+    private const val PROGRESS_EVENT = "OtaUpdateDownloadProgress"
+
+    const val INSTALL_MODE_ON_NEXT_RESTART = 0
+    const val INSTALL_MODE_ON_NEXT_RESUME = 1
+    const val INSTALL_MODE_IMMEDIATE = 2
+  }
+
+  private val executor = Executors.newSingleThreadExecutor()
+  private val store: OtaUpdateStore by lazy { OtaUpdate.store(reactContext) }
+
+  /** Set when an ON_NEXT_RESUME install is waiting for the app to background. */
+  private var restartOnResume = false
+  private var minimumBackgroundDurationMs = 0L
+  private var backgroundedAt = 0L
+
+  init {
+    reactContext.addLifecycleEventListener(this)
+  }
+
+  override fun getName(): String = NAME
+
+  override fun getConstants(): Map<String, Any> = mapOf(
+    "INSTALL_MODE_ON_NEXT_RESTART" to INSTALL_MODE_ON_NEXT_RESTART,
+    "INSTALL_MODE_ON_NEXT_RESUME" to INSTALL_MODE_ON_NEXT_RESUME,
+    "INSTALL_MODE_IMMEDIATE" to INSTALL_MODE_IMMEDIATE,
+  )
+
+  // NativeEventEmitter requires these to exist, even though the native side
+  // does the subscribing itself.
+  @ReactMethod fun addListener(eventName: String) = Unit
+
+  @ReactMethod fun removeListeners(count: Int) = Unit
+
+  // --- Configuration --------------------------------------------------------
+
+  @ReactMethod
+  fun getConfiguration(promise: Promise) {
+    try {
+      val map = Arguments.createMap().apply {
+        putString("deploymentKey", OtaUpdate.deploymentKey(reactContext))
+        putString("serverUrl", OtaUpdate.serverUrl(reactContext))
+        putString("appVersion", OtaUpdate.appVersion(reactContext))
+        putString("clientUniqueId", store.clientUniqueId())
+        putString("packageHash", store.currentHash)
+        putString("label", store.packageInfo(store.currentHash)?.optString("label"))
+        // Read from the native runtime, not settable from JS — this is what
+        // makes backend bundle-identifier enforcement meaningful.
+        putString("bundleIdentifier", reactContext.packageName)
+      }
+      promise.resolve(map)
+    } catch (e: Exception) {
+      promise.reject("ota_config_error", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun getCurrentPackage(promise: Promise) {
+    try {
+      val hash = store.currentHash
+      val info = store.packageInfo(hash)
+      if (hash == null || info == null) {
+        promise.resolve(null)
+        return
+      }
+      val map = Arguments.createMap().apply {
+        putString("packageHash", hash)
+        putString("label", info.optString("label"))
+        putString("description", info.optString("description").takeIf { it.isNotEmpty() })
+        putBoolean("isMandatory", info.optBoolean("isMandatory"))
+        putString("bundlePath", info.optString("bundlePath"))
+        putDouble("size", info.optLong("size").toDouble())
+        putString("appVersion", OtaUpdate.appVersion(reactContext))
+        putBoolean("isPending", store.isPending())
+        putBoolean("isFirstRun", OtaUpdateStore.isFirstRunOfUpdate())
+      }
+      promise.resolve(map)
+    } catch (e: Exception) {
+      promise.reject("ota_current_package_error", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun isFirstRun(packageHash: String, promise: Promise) {
+    promise.resolve(OtaUpdateStore.isFirstRunOfUpdate() && store.currentHash == packageHash)
+  }
+
+  // --- Download -------------------------------------------------------------
+
+  @ReactMethod
+  fun downloadUpdate(update: ReadableMap, promise: Promise) {
+    val downloadUrl = update.getString("downloadUrl")
+    val packageHash = update.getString("packageHash")
+    val label = update.getString("label") ?: ""
+
+    if (downloadUrl.isNullOrEmpty() || packageHash.isNullOrEmpty()) {
+      promise.reject("ota_invalid_update", "downloadUrl and packageHash are required")
+      return
+    }
+
+    // Networking and unzipping must stay off the UI and JS threads.
+    executor.execute {
+      try {
+        val installed = OtaUpdateInstaller.install(store, downloadUrl, packageHash) { received, total ->
+          emitProgress(received, total)
+        }
+
+        store.recordPackage(
+          hash = packageHash,
+          label = label,
+          bundlePath = installed.bundlePath,
+          description = if (update.hasKey("description")) update.getString("description") else null,
+          isMandatory = update.hasKey("isMandatory") && update.getBoolean("isMandatory"),
+          size = installed.size,
+          appVersion = OtaUpdate.appVersion(reactContext),
+        )
+
+        val result = Arguments.createMap().apply {
+          putString("bundlePath", installed.bundlePath)
+          putString("packageHash", packageHash)
+          putString("label", label)
+          putDouble("size", installed.size.toDouble())
+        }
+        promise.resolve(result)
+      } catch (e: Exception) {
+        Log.e(OtaUpdateStore.TAG, "download failed", e)
+        promise.reject("ota_download_failed", e.message, e)
+      }
+    }
+  }
+
+  private fun emitProgress(received: Long, total: Long) {
+    if (!reactContext.hasActiveReactInstance()) return
+    val payload: WritableMap = Arguments.createMap().apply {
+      putDouble("receivedBytes", received.toDouble())
+      putDouble("totalBytes", total.toDouble())
+    }
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(PROGRESS_EVENT, payload)
+  }
+
+  // --- Install --------------------------------------------------------------
+
+  @ReactMethod
+  fun installUpdate(packageHash: String, installMode: Int, minimumBackgroundDuration: Int, promise: Promise) {
+    try {
+      store.markPending(packageHash)
+
+      when (installMode) {
+        INSTALL_MODE_IMMEDIATE -> {
+          promise.resolve(null)
+          Handler(Looper.getMainLooper()).post { reload() }
+        }
+        INSTALL_MODE_ON_NEXT_RESUME -> {
+          restartOnResume = true
+          minimumBackgroundDurationMs = minimumBackgroundDuration * 1000L
+          promise.resolve(null)
+        }
+        else -> {
+          // ON_NEXT_RESTART: nothing more to do — getJSBundleFile picks it up.
+          promise.resolve(null)
+        }
+      }
+    } catch (e: Exception) {
+      promise.reject("ota_install_failed", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun notifyApplicationReady(promise: Promise) {
+    try {
+      store.notifyApplicationReady()
+      // Reclaim disk from superseded packages once we know the current one works.
+      executor.execute { runCatching { store.pruneOldPackages() } }
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("ota_notify_failed", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun restartApp(onlyIfUpdateIsPending: Boolean, promise: Promise) {
+    if (onlyIfUpdateIsPending && !store.isPending()) {
+      promise.resolve(false)
+      return
+    }
+    promise.resolve(true)
+    Handler(Looper.getMainLooper()).post { reload() }
+  }
+
+  @ReactMethod
+  fun clearUpdates(promise: Promise) {
+    try {
+      store.reset()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("ota_clear_failed", e.message, e)
+    }
+  }
+
+  /**
+   * Recreates the React context so the new bundle is loaded. Handles both the
+   * bridge and bridgeless (new architecture) hosts; the bridgeless path is
+   * reached reflectively so this module still compiles against RN 0.71.
+   */
+  private fun reload() {
+    val application = reactContext.applicationContext
+    if (application !is ReactApplication) {
+      Log.e(OtaUpdateStore.TAG, "Application does not implement ReactApplication — cannot restart")
+      return
+    }
+
+    try {
+      val reactHost = runCatching {
+        ReactApplication::class.java.getMethod("getReactHost").invoke(application)
+      }.getOrNull()
+
+      if (reactHost != null) {
+        reactHost.javaClass.methods
+          .firstOrNull { it.name == "reload" && it.parameterTypes.size == 1 }
+          ?.invoke(reactHost, "OTA update applied")
+          ?: Log.e(OtaUpdateStore.TAG, "ReactHost has no reload(String) method")
+        return
+      }
+
+      application.reactNativeHost.reactInstanceManager.recreateReactContextInBackground()
+    } catch (e: Exception) {
+      Log.e(OtaUpdateStore.TAG, "failed to restart the React context", e)
+    }
+  }
+
+  // --- ON_NEXT_RESUME wiring -----------------------------------------------
+
+  override fun onHostResume() {
+    if (!restartOnResume) return
+    val backgroundedFor = System.currentTimeMillis() - backgroundedAt
+    if (backgroundedAt > 0 && backgroundedFor >= minimumBackgroundDurationMs) {
+      restartOnResume = false
+      Handler(Looper.getMainLooper()).post { reload() }
+    }
+  }
+
+  override fun onHostPause() {
+    backgroundedAt = System.currentTimeMillis()
+  }
+
+  override fun onHostDestroy() {
+    backgroundedAt = 0
+  }
+
+  override fun invalidate() {
+    reactContext.removeLifecycleEventListener(this)
+    executor.shutdown()
+    super.invalidate()
+  }
+}

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

@@ -0,0 +1,15 @@
+package com.otaupdate
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/** Registered automatically by React Native autolinking. */
+class OtaUpdatePackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+    listOf(OtaUpdateModule(reactContext))
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    emptyList()
+}