@hot-updater/react-native 1.0.0-rc.15 → 1.0.0-rc.17

package/android/src/main/java/com/hotupdater/KeyValueStorageService.kt

@@ -0,0 +1,86 @@
+package com.hotupdater
+
+import android.content.Context
+import android.util.Log
+import androidx.core.util.AtomicFile
+import org.json.JSONObject
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.FileOutputStream
+
+/**
+ * The persistent string key-value store behind `getStorageItem` and
+ * `setStorageItem`, which client plugins use through JS. Keys are opaque
+ * here; JS scopes them per plugin.
+ *
+ * Values live as one JSON object in a file outside device backups. The file
+ * is read once, on first use, and rewritten atomically on every set. A
+ * missing, unreadable, or corrupt file reads as empty and is replaced by the
+ * next set. A set that cannot be persisted still applies for this process.
+ */
+class KeyValueStorageService(
+    private val file: File,
+) {
+    companion object {
+        private const val TAG = "KeyValueStorage"
+        const val FILENAME = "storage.json"
+
+        /** The store kept in `noBackupFilesDir/hot-updater/storage.json`. */
+        fun create(context: Context): KeyValueStorageService = KeyValueStorageService(NoBackupStorage.file(context, FILENAME))
+    }
+
+    private var values: MutableMap<String, String>? = null
+
+    @Synchronized
+    fun getItem(key: String): String? = loadValues()[key]
+
+    /** Stores [value] under [key], or removes [key] when [value] is null. */
+    @Synchronized
+    fun setItem(
+        key: String,
+        value: String?,
+    ) {
+        val values = loadValues()
+        if (value == null) {
+            values.remove(key)
+        } else {
+            values[key] = value
+        }
+        write(values)
+    }
+
+    private fun loadValues(): MutableMap<String, String> = values ?: read().also { values = it }
+
+    private fun read(): MutableMap<String, String> =
+        try {
+            val json =
+                AtomicFile(file).openRead().use { input ->
+                    JSONObject(String(input.readBytes(), Charsets.UTF_8))
+                }
+            val stored = linkedMapOf<String, String>()
+            json.keys().forEach { key ->
+                (json.opt(key) as? String)?.let { stored[key] = it }
+            }
+            stored
+        } catch (_: FileNotFoundException) {
+            linkedMapOf()
+        } catch (e: Exception) {
+            // The message of a parse error can quote stored values, so it is not logged.
+            Log.w(TAG, "Ignoring unreadable storage file (${e.javaClass.simpleName})")
+            linkedMapOf()
+        }
+
+    private fun write(values: Map<String, String>) {
+        val atomicFile = AtomicFile(file)
+        var output: FileOutputStream? = null
+        try {
+            file.parentFile?.mkdirs()
+            output = atomicFile.startWrite()
+            output.write(JSONObject(values).toString().toByteArray(Charsets.UTF_8))
+            atomicFile.finishWrite(output)
+        } catch (e: Exception) {
+            output?.let(atomicFile::failWrite)
+            Log.w(TAG, "Failed to persist storage", e)
+        }
+    }
+}

package/android/src/main/java/com/hotupdater/NetworkState.kt

@@ -0,0 +1,31 @@
+package com.hotupdater
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import android.net.ConnectivityManager
+import android.os.Build
+
+internal object NetworkState {
+    /**
+     * True when the device reports no active network. False when it has one,
+     * or when that cannot be told, as when the app lacks
+     * `ACCESS_NETWORK_STATE`.
+     */
+    fun hasNoActiveNetwork(context: Context): Boolean =
+        try {
+            val permission = context.checkCallingOrSelfPermission(Manifest.permission.ACCESS_NETWORK_STATE)
+            val connectivity = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+            when {
+                permission != PackageManager.PERMISSION_GRANTED || connectivity == null -> false
+                Build.VERSION.SDK_INT >= Build.VERSION_CODES.M -> connectivity.activeNetwork == null
+                else -> hasNoConnectedNetworkLegacy(connectivity)
+            }
+        } catch (_: Exception) {
+            false
+        }
+
+    @Suppress("DEPRECATION")
+    private fun hasNoConnectedNetworkLegacy(connectivity: ConnectivityManager): Boolean =
+        connectivity.activeNetworkInfo?.isConnected != true
+}

package/android/src/main/java/com/hotupdater/NoBackupStorage.kt

@@ -0,0 +1,17 @@
+package com.hotupdater
+
+import android.content.Context
+import java.io.File
+
+/**
+ * SDK state that must never be restored onto another installation lives in
+ * `noBackupFilesDir/hot-updater`, which Android Auto Backup skips.
+ */
+internal object NoBackupStorage {
+    private const val DIRECTORY_NAME = "hot-updater"
+
+    fun file(
+        context: Context,
+        name: String,
+    ): File = File(File(context.noBackupFilesDir, DIRECTORY_NAME), name)
+}

package/android/src/main/java/com/hotupdater/OkHttpDownloadService.kt

@@ -1,6 +1,7 @@
 package com.hotupdater
 
 import android.util.Log
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withContext
@@ -15,10 +16,11 @@ import okio.Source
 import okio.buffer
 import java.io.File
 import java.io.IOException
-import java.net.SocketTimeoutException
+import java.net.MalformedURLException
 import java.net.URL
-import java.net.UnknownHostException
 import java.util.concurrent.TimeUnit
+import javax.net.ssl.SSLHandshakeException
+import javax.net.ssl.SSLPeerUnverifiedException
 
 /**
  * Exception for incomplete downloads with size information
@@ -28,6 +30,47 @@ class IncompleteDownloadException(
     val actualSize: Long,
 ) : IOException("Download incomplete: received $actualSize bytes, expected $expectedSize bytes")
 
+/**
+ * The server answered with a non-2xx status. [originCode] is the storage
+ * origin's XML error `<Code>` (S3, R2, or GCS style) when the body names one.
+ */
+class HttpStatusException(
+    val statusCode: Int,
+    statusMessage: String,
+    val originCode: String? = null,
+) : Exception("HTTP error $statusCode: $statusMessage")
+
+/** How much of an error body is read to find a storage origin's error code. */
+internal const val MAX_ORIGIN_ERROR_BODY_BYTES = 4 * 1024L
+
+private val ORIGIN_ERROR_CODE = Regex("<Error(?:\\s[^>]*)?>(?:(?!</Error>).)*?<Code>([^<]*)</Code>", RegexOption.DOT_MATCHES_ALL)
+private val ORIGIN_CODE_VALUE = Regex("[A-Za-z0-9._-]{1,64}")
+
+/**
+ * Reads the `<Code>` of a storage origin's XML error, as in
+ * `<Error><Code>AccessDenied</Code>...`, from at most the first 4 KB of
+ * [body]. Only a 1 to 64 character code of letters, digits, `.`, `_`, and `-`
+ * is kept, so no key, resource, or message text is ever returned.
+ */
+internal fun readOriginErrorCode(body: ResponseBody?): String? =
+    try {
+        body?.source()?.let { source ->
+            source.request(MAX_ORIGIN_ERROR_BODY_BYTES)
+            val prefix = source.buffer.readByteArray(minOf(source.buffer.size, MAX_ORIGIN_ERROR_BODY_BYTES))
+            parseOriginErrorCode(String(prefix, Charsets.UTF_8))
+        }
+    } catch (_: Exception) {
+        null
+    }
+
+internal fun parseOriginErrorCode(body: String): String? =
+    ORIGIN_ERROR_CODE
+        .find(body)
+        ?.groupValues
+        ?.get(1)
+        ?.trim()
+        ?.takeIf { ORIGIN_CODE_VALUE.matches(it) }
+
 /**
  * Result wrapper for download operations
  */
@@ -134,13 +177,33 @@ private class ProgressResponseBody(
         }
 }
 
+/**
+ * Whether a failed download may succeed if tried again: a network failure or
+ * timeout, a body that ended early, or a 408, 429, or 5xx answer. Another 4xx,
+ * a TLS certificate failure, a canceled call, and a local storage failure
+ * would fail the same way again.
+ */
+internal fun isRetryableDownloadError(error: Exception): Boolean =
+    when (error) {
+        is HttpStatusException -> error.statusCode == 408 || error.statusCode == 429 || error.statusCode >= 500
+        is LocalStorageException -> false
+        is SSLHandshakeException, is SSLPeerUnverifiedException -> false
+        is MalformedURLException -> false
+        is IOException -> error.message != "Canceled"
+        else -> false
+    }
+
 /**
  * OkHttp-based implementation of DownloadService with resume support
  */
-class OkHttpDownloadService : DownloadService {
+class OkHttpDownloadService internal constructor(
+    private val initialRetryDelayMs: Long,
+) : DownloadService {
+    constructor() : this(INITIAL_RETRY_DELAY_MS)
+
     companion object {
         private const val TAG = "OkHttpDownloadService"
-        private const val MAX_RETRIES = 3
+        internal const val MAX_ATTEMPTS = 3
         private const val INITIAL_RETRY_DELAY_MS = 1000L
         private const val TIMEOUT_SECONDS = 30L
     }
@@ -153,6 +216,12 @@ class OkHttpDownloadService : DownloadService {
             .writeTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
             .build()
 
+    /**
+     * Downloads [fileUrl], trying again after a retryable failure (see
+     * [isRetryableDownloadError]) up to [MAX_ATTEMPTS] attempts in all, 1 and
+     * then 2 seconds apart. The last attempt's result is returned, so a
+     * failure keeps what classified it.
+     */
     override suspend fun downloadFile(
         fileUrl: URL,
         destination: File,
@@ -160,39 +229,30 @@ class OkHttpDownloadService : DownloadService {
         progressCallback: (DownloadProgress) -> Unit,
     ): DownloadResult =
         withContext(Dispatchers.IO) {
-            var attempt = 0
-            var lastException: Exception? = null
-
-            while (attempt < MAX_RETRIES) {
-                try {
-                    return@withContext attemptDownload(
-                        fileUrl,
-                        destination,
-                        fileSizeCallback,
-                        progressCallback,
-                    )
-                } catch (e: Exception) {
-                    lastException = e
-                    attempt++
-
-                    if (attempt < MAX_RETRIES && isRetryableException(e)) {
-                        val delayMs = INITIAL_RETRY_DELAY_MS * (1 shl (attempt - 1))
-                        Log.d(
-                            TAG,
-                            "Download failed (attempt $attempt/$MAX_RETRIES): ${e.message}. Retrying in ${delayMs}ms...",
-                        )
-                        delay(delayMs)
-                    } else {
-                        Log.d(TAG, "Download failed: ${e.message}")
-                        break
-                    }
-                }
+            var attempt = 1
+            var result = attemptOrError(fileUrl, destination, fileSizeCallback, progressCallback)
+            while (
+                result is DownloadResult.Error &&
+                attempt < MAX_ATTEMPTS &&
+                isRetryableDownloadError(result.exception)
+            ) {
+                val delayMs = initialRetryDelayMs * (1 shl (attempt - 1))
+                Log.d(
+                    TAG,
+                    "Download failed (attempt $attempt/$MAX_ATTEMPTS): ${result.exception.message}. Retrying in ${delayMs}ms...",
+                )
+                delay(delayMs)
+                attempt++
+                result = attemptOrError(fileUrl, destination, fileSizeCallback, progressCallback)
             }
-
-            DownloadResult.Error(lastException ?: Exception("Download failed after $MAX_RETRIES attempts"))
+            if (result is DownloadResult.Error) {
+                Log.d(TAG, "Download failed (attempt $attempt/$MAX_ATTEMPTS): ${result.exception.message}")
+            }
+            result
         }
 
-    override suspend fun downloadFileOnce(
+    /** One attempt; an exception a callback threw, such as the disk space check's, is its error. */
+    private suspend fun attemptOrError(
         fileUrl: URL,
         destination: File,
         fileSizeCallback: ((Long) -> Unit)?,
@@ -200,10 +260,20 @@ class OkHttpDownloadService : DownloadService {
     ): DownloadResult =
         try {
             attemptDownload(fileUrl, destination, fileSizeCallback, progressCallback)
+        } catch (error: CancellationException) {
+            throw error
         } catch (error: Exception) {
             DownloadResult.Error(error)
         }
 
+    /** One attempt with no retry, for a download with a fallback, such as the archive's per-file downloads. */
+    override suspend fun downloadFileOnce(
+        fileUrl: URL,
+        destination: File,
+        fileSizeCallback: ((Long) -> Unit)?,
+        progressCallback: (DownloadProgress) -> Unit,
+    ): DownloadResult = attemptOrError(fileUrl, destination, fileSizeCallback, progressCallback)
+
     private suspend fun attemptDownload(
         fileUrl: URL,
         destination: File,
@@ -231,10 +301,10 @@ class OkHttpDownloadService : DownloadService {
             }
 
             if (!response.isSuccessful) {
-                val errorMsg = "HTTP error ${response.code}: ${response.message}"
-                Log.d(TAG, errorMsg)
+                val error = HttpStatusException(response.code, response.message, readOriginErrorCode(response.body))
+                Log.d(TAG, "HTTP error ${response.code}: ${response.message}")
                 response.close()
-                return@withContext DownloadResult.Error(Exception(errorMsg))
+                return@withContext DownloadResult.Error(error)
             }
 
             val body = response.body
@@ -261,9 +331,10 @@ class OkHttpDownloadService : DownloadService {
                         progressCallback.invoke(progress)
                     }
 
-                // Write to file
+                // Write to file. A local write failure surfaces as LocalStorageException,
+                // so it is not mistaken for a network failure.
                 progressBody.source().use { source ->
-                    destination.outputStream().use { output ->
+                    LocalStorageOutputStream.open(destination).use { output ->
                         val buffer = ByteArray(8 * 1024)
                         var bytesRead: Int
 
@@ -310,17 +381,4 @@ class OkHttpDownloadService : DownloadService {
                 DownloadResult.Error(e)
             }
         }
-
-    /**
-     * Check if exception is retryable
-     */
-    private fun isRetryableException(e: Exception): Boolean =
-        when (e) {
-            is SocketTimeoutException,
-            is UnknownHostException,
-            is IOException,
-            -> true
-
-            else -> false
-        }
 }

package/android/src/main/java/com/hotupdater/PreviousProcessExit.kt

@@ -0,0 +1,89 @@
+package com.hotupdater
+
+import android.app.ActivityManager
+import android.content.Context
+import android.os.Build
+import android.util.Log
+
+/**
+ * Why the app's previous main process exited, from
+ * `ActivityManager.getHistoricalProcessExitReasons` (Android 11+).
+ *
+ * HotUpdater calls [initialize] when it starts. The reason is read once, on
+ * first use, and kept for the life of the process: the running process never
+ * appears in its own exit history, so reading later returns the same entry.
+ */
+internal object PreviousProcessExit {
+    private const val TAG = "PreviousProcessExit"
+    private const val MAX_EXIT_RECORDS = 5
+
+    /** `ApplicationExitInfo.REASON_*` values, named without the prefix. */
+    private val REASON_NAMES =
+        mapOf(
+            0 to "UNKNOWN",
+            1 to "EXIT_SELF",
+            2 to "SIGNALED",
+            3 to "LOW_MEMORY",
+            4 to "CRASH",
+            5 to "CRASH_NATIVE",
+            6 to "ANR",
+            7 to "INITIALIZATION_FAILURE",
+            8 to "PERMISSION_CHANGE",
+            9 to "EXCESSIVE_RESOURCE_USAGE",
+            10 to "USER_REQUESTED",
+            11 to "USER_STOPPED",
+            12 to "DEPENDENCY_DIED",
+            13 to "OTHER",
+            14 to "FREEZER",
+            15 to "PACKAGE_STATE_CHANGE",
+            16 to "PACKAGE_UPDATED",
+        )
+
+    data class ExitRecord(
+        val processName: String?,
+        val reason: Int,
+        val timestamp: Long,
+    )
+
+    // The application context, which lives as long as the process.
+    @Volatile
+    private var applicationContext: Context? = null
+
+    private val reason: String? by lazy { applicationContext?.let(::read) }
+
+    fun initialize(context: Context) {
+        if (applicationContext == null) {
+            applicationContext = context.applicationContext ?: context
+        }
+    }
+
+    /** The previous main process's exit reason, or null when it is not known. */
+    fun get(): String? = if (applicationContext == null) null else reason
+
+    fun reasonName(reason: Int): String = REASON_NAMES[reason] ?: "UNKNOWN"
+
+    /**
+     * The reason of [mainProcessName]'s most recent exit. Other processes of
+     * the app, such as `:hotupdater_restart`, are skipped.
+     */
+    fun selectReason(
+        records: List<ExitRecord>,
+        mainProcessName: String,
+    ): Int? = records.filter { it.processName == mainProcessName }.maxByOrNull { it.timestamp }?.reason
+
+    private fun read(context: Context): String? {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) return null
+        return try {
+            val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager ?: return null
+            val records =
+                activityManager
+                    .getHistoricalProcessExitReasons(null, 0, MAX_EXIT_RECORDS)
+                    .map { ExitRecord(it.processName, it.reason, it.timestamp) }
+            selectReason(records, context.applicationInfo.processName)?.let(::reasonName)
+        } catch (error: Throwable) {
+            // Never let this diagnostic break startup.
+            Log.w(TAG, "Could not read the previous process exit reason", error)
+            null
+        }
+    }
+}

package/android/src/main/java/com/hotupdater/ReactNativeValueConverters.kt

@@ -1,10 +1,44 @@
 package com.hotupdater
 
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.bridge.WritableNativeArray
 import com.facebook.react.bridge.WritableNativeMap
 
+/** The value an `updateBundle` promise resolves to: `{ delivery, patchFallback }`. */
+internal fun UpdateBundleResult.toWritableMap(): WritableMap =
+    Arguments.createMap().apply {
+        putString("delivery", delivery.value)
+        putBoolean("patchFallback", patchFallback)
+    }
+
+/**
+ * Rejects an `updateBundle` promise with the error's code and message. An
+ * update failure also carries its classification as the rejection's
+ * `userInfo`: `{ stage, reason, httpStatus? }`.
+ */
+internal fun Promise.rejectUpdateBundle(error: HotUpdaterException) {
+    val userInfo = error.failure?.toUserInfo()
+    if (userInfo == null) {
+        reject(error.code, error.message)
+        return
+    }
+    reject(
+        error.code,
+        error.message,
+        Arguments.createMap().apply {
+            userInfo.forEach { (key, value) ->
+                when (value) {
+                    is Int -> putInt(key, value)
+                    else -> putString(key, value.toString())
+                }
+            }
+        },
+    )
+}
+
 internal fun Map<String, Any?>.toWritableNativeMap(): WritableNativeMap {
     val result = WritableNativeMap()
     forEach { (key, value) ->