expo-updates 55.0.28 → 55.0.29

package/CHANGELOG.md

@@ -10,6 +10,17 @@
 
 ### 💡 Others
 
+## 55.0.29 — 2026-08-27
+
+### 🐛 Bug fixes
+
+- [Android] Widen `UpdatesLogEntry.create`'s catch from `JSONException` to `Exception` so log-line parse failures consistently degrade to "skip the entry" instead of propagating. ([#46182](https://github.com/expo/expo/pull/46182) by [@jakequade-pc](https://github.com/jakequade-pc))
+- [Android] Correct `UpdatesLogReader.ONE_DAY_MILLISECONDS` from `86400` (seconds) to `86_400_000` (milliseconds), so the "older than one day" purge filter actually retains a day's worth of entries instead of ~86 seconds' worth. ([#46182](https://github.com/expo/expo/pull/46182) by [@jakequade-pc](https://github.com/jakequade-pc))
+
+### 💡 Others
+
+- [Android] Log purge completion errors via `android.util.Log.e` directly instead of `logger.error`, so the failure path doesn't re-enter the `PersistentFileLog` dispatch queue from inside one of its own tasks. ([#46182](https://github.com/expo/expo/pull/46182) by [@jakequade-pc](https://github.com/jakequade-pc))
+
 ## 55.0.28 — 2026-08-25
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -42,7 +42,7 @@ expoModule {
 }
 
 group = 'host.exp.exponent'
-version = '55.0.28'
+version = '55.0.29'
 
 // Utility method to derive boolean values from the environment or from Java properties,
 // and return them as strings to be used in BuildConfig fields
@@ -89,7 +89,7 @@ android {
   namespace "expo.modules.updates"
   defaultConfig {
     versionCode 31
-    versionName '55.0.28'
+    versionName '55.0.29'
     consumerProguardFiles("proguard-rules.pro")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 

package/android/src/main/java/expo/modules/updates/EnabledUpdatesController.kt

@@ -4,6 +4,7 @@ import android.app.Activity
 import android.content.Context
 import android.net.Uri
 import android.os.Bundle
+import android.util.Log
 import com.facebook.react.ReactHost
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.devsupport.interfaces.DevSupportManager
@@ -18,7 +19,6 @@ import expo.modules.updates.events.IUpdatesEventManager
 import expo.modules.updates.events.UpdatesEventManager
 import expo.modules.updates.launcher.Launcher.LauncherCallback
 import expo.modules.updates.loader.FileDownloader
-import expo.modules.updates.logging.UpdatesErrorCode
 import expo.modules.updates.logging.UpdatesLogReader
 import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.manifest.EmbeddedManifestUtils
@@ -35,6 +35,7 @@ import expo.modules.updates.statemachine.UpdatesStateValue
 import expo.modules.updatesinterface.UpdatesInterface
 import expo.modules.updatesinterface.UpdatesStateChangeListener
 import expo.modules.updatesinterface.UpdatesStateChangeSubscription
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -89,7 +90,12 @@ class EnabledUpdatesController(
   private fun purgeUpdatesLogsOlderThanOneDay() {
     UpdatesLogReader(context.filesDir).purgeLogEntries {
       if (it != null) {
-        logger.error("UpdatesLogReader: error in purgeLogEntries", it, UpdatesErrorCode.Unknown)
+        // Log directly via android.util.Log rather than through `logger.error`,
+        // which writes via the PersistentFileLog dispatch queue. This callback
+        // is invoked from inside one of that queue's own tasks, so feeding
+        // another entry back into the queue from here re-enters it. Bypassing
+        // the queue keeps the failure path off its own back.
+        Log.e("expo-updates", "UpdatesLogReader: error in purgeLogEntries", it)
       }
     }
   }
@@ -256,7 +262,7 @@ class EnabledUpdatesController(
   }
 
   override suspend fun fetchUpdate() = suspendCancellableCoroutine { continuation ->
-    val procedure = FetchUpdateProcedure(context, updatesConfiguration, logger, databaseHolder, updatesDirectory, fileDownloader, selectionPolicy, launchedUpdate) {
+    val procedure = FetchUpdateProcedure(context, updatesConfiguration, logger, databaseHolder, updatesDirectory, fileDownloader, selectionPolicy, launchedUpdate, controllerScope) {
       continuation.resume(it)
     }
     stateMachine.queueExecution(procedure)
@@ -280,6 +286,8 @@ class EnabledUpdatesController(
           }
         }
         continuation.resume(resultMap)
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         continuation.resumeWithException(e.toCodedException())
       }
@@ -288,7 +296,7 @@ class EnabledUpdatesController(
 
   override suspend fun setExtraParam(key: String, value: String?) = suspendCancellableCoroutine { continuation ->
     controllerScope.launch {
-      runCatching {
+      try {
         ManifestMetadata.setExtraParam(
           databaseHolder.database,
           updatesConfiguration,
@@ -296,7 +304,9 @@ class EnabledUpdatesController(
           value
         )
         continuation.resume(Unit)
-      }.onFailure { e ->
+      } catch (e: CancellationException) {
+        throw e
+      } catch (e: Exception) {
         continuation.resumeWithException(e.toCodedException())
       }
     }

package/android/src/main/java/expo/modules/updates/UpdatesDevLauncherController.kt

@@ -34,9 +34,11 @@ import expo.modules.updatesinterface.UpdatesDevLauncherInterface
 import expo.modules.updatesinterface.UpdatesInterfaceCallbacks
 import expo.modules.updatesinterface.UpdatesStateChangeListener
 import expo.modules.updatesinterface.UpdatesStateChangeSubscription
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
 import org.json.JSONObject
@@ -183,7 +185,8 @@ class UpdatesDevLauncherController(
       databaseHolder.database,
       fileDownloader,
       updatesDirectory,
-      null
+      null,
+      controllerScope
     )
     controllerScope.launch {
       val progressJob = launch {
@@ -215,6 +218,8 @@ class UpdatesDevLauncherController(
           return@launch
         }
         launchUpdate(loaderResult.updateEntity, updatesConfiguration!!, fileDownloader, callback)
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         // reset controller's configuration to what it was before this request
         updatesConfiguration = previousUpdatesConfiguration
@@ -309,6 +314,8 @@ class UpdatesDevLauncherController(
           get() = launcher.launchAssetFile!!
       })
       runReaper()
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       // reset controller's configuration to what it was before this request
       updatesConfiguration = previousUpdatesConfiguration
@@ -385,7 +392,7 @@ class UpdatesDevLauncherController(
   }
 
   override fun shutdown() {
-    // no-op
+    controllerScope.cancel()
   }
 
   companion object {

package/android/src/main/java/expo/modules/updates/loader/EmbeddedLoader.kt

@@ -9,6 +9,9 @@ import expo.modules.updates.UpdatesUtils
 import expo.modules.updates.db.entity.UpdateEntity
 import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.utils.AndroidResourceAssetUtils
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import java.io.File
 import java.io.FileNotFoundException
 import java.lang.AssertionError
@@ -32,14 +35,16 @@ class EmbeddedLoader internal constructor(
   database: UpdatesDatabase,
   updatesDirectory: File,
   private val loaderFiles: LoaderFiles,
-  private val shouldCopyEmbeddedAssets: Boolean = BuildConfig.EX_UPDATES_COPY_EMBEDDED_ASSETS
+  private val shouldCopyEmbeddedAssets: Boolean = BuildConfig.EX_UPDATES_COPY_EMBEDDED_ASSETS,
+  scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 ) : Loader(
   context,
   configuration,
   logger,
   database,
   updatesDirectory,
-  loaderFiles
+  loaderFiles,
+  scope
 ) {
 
   constructor(
@@ -47,8 +52,9 @@ class EmbeddedLoader internal constructor(
     configuration: UpdatesConfiguration,
     logger: UpdatesLogger,
     database: UpdatesDatabase,
-    updatesDirectory: File
-  ) : this(context, configuration, logger, database, updatesDirectory, LoaderFiles())
+    updatesDirectory: File,
+    scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+  ) : this(context, configuration, logger, database, updatesDirectory, LoaderFiles(), scope = scope)
 
   override suspend fun loadRemoteUpdate(
     database: UpdatesDatabase,

package/android/src/main/java/expo/modules/updates/loader/Loader.kt

@@ -25,6 +25,7 @@ import kotlinx.coroutines.SupervisorJob
 import java.io.File
 import java.io.IOException
 import java.util.*
+import java.util.Collections
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -46,9 +47,9 @@ abstract class Loader protected constructor(
   private var updateResponse: UpdateResponse? = null
   private var updateEntity: UpdateEntity? = null
   private var assetTotal = 0
-  private var erroredAssetList = mutableListOf<AssetEntity>()
-  private var existingAssetList = mutableListOf<AssetEntity>()
-  private var finishedAssetList = mutableListOf<AssetEntity>()
+  private var erroredAssetList: MutableList<AssetEntity> = Collections.synchronizedList(mutableListOf())
+  private var existingAssetList: MutableList<AssetEntity> = Collections.synchronizedList(mutableListOf())
+  private var finishedAssetList: MutableList<AssetEntity> = Collections.synchronizedList(mutableListOf())
   private val _progressFlow = MutableSharedFlow<AssetLoadProgress>()
   private var assetProgressMap: MutableMap<AssetEntity, Double> = ConcurrentHashMap()
 
@@ -117,9 +118,9 @@ abstract class Loader protected constructor(
     updateResponse = null
     updateEntity = null
     assetTotal = 0
-    erroredAssetList = mutableListOf()
-    existingAssetList = mutableListOf()
-    finishedAssetList = mutableListOf()
+    erroredAssetList = Collections.synchronizedList(mutableListOf())
+    existingAssetList = Collections.synchronizedList(mutableListOf())
+    finishedAssetList = Collections.synchronizedList(mutableListOf())
     assetProgressMap = ConcurrentHashMap()
     assetLoadProgressBlock = null
   }

package/android/src/main/java/expo/modules/updates/loader/LoaderTask.kt

@@ -17,6 +17,7 @@ import expo.modules.updates.manifest.EmbeddedManifestUtils
 import expo.modules.updates.manifest.ManifestMetadata
 import expo.modules.updates.manifest.Update
 import expo.modules.updates.selectionpolicy.SelectionPolicy
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.CoroutineScope
 import org.json.JSONObject
@@ -189,6 +190,8 @@ class LoaderTask(
           callback.onFinishedAllLoading()
         }
       }
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       if (!shouldCheckForUpdate) {
         finish(e)
@@ -209,6 +212,8 @@ class LoaderTask(
       isRunning = false
       runReaper()
       callback.onFinishedAllLoading()
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       finish(e)
       isRunning = false
@@ -296,10 +301,12 @@ class LoaderTask(
         )
       ) {
         try {
-          val embeddedLoader = EmbeddedLoader(context, configuration, logger, database, directory)
+          val embeddedLoader = EmbeddedLoader(context, configuration, logger, database, directory, scope)
           embeddedLoader.load { _ ->
             Loader.OnUpdateResponseLoadedResult(shouldDownloadManifestIfPresentInResponse = true)
           }
+        } catch (e: CancellationException) {
+          throw e
         } catch (e: Exception) {
           logger.error("Unexpected error copying embedded update", e, UpdatesErrorCode.Unknown)
         }
@@ -315,7 +322,7 @@ class LoaderTask(
   private suspend fun launchRemoteUpdateInBackground() {
     val database = databaseHolder.database
     callback.onRemoteCheckForUpdateStarted()
-    val remoteLoader = RemoteLoader(context, configuration, logger, database, fileDownloader, directory, candidateLauncher?.launchedUpdate)
+    val remoteLoader = RemoteLoader(context, configuration, logger, database, fileDownloader, directory, candidateLauncher?.launchedUpdate, scope)
 
     remoteLoader.assetLoadProgressBlock = { progress ->
       callback.onRemoteUpdateProgressChanged(progress)

package/android/src/main/java/expo/modules/updates/loader/RemoteLoader.kt

@@ -10,6 +10,9 @@ import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.manifest.EmbeddedManifestUtils
 import expo.modules.updates.manifest.ManifestMetadata
 import expo.modules.updates.selectionpolicy.SelectionPolicy
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import java.io.File
 
 data class ProcessSuccessLoaderResult(
@@ -32,8 +35,9 @@ class RemoteLoader internal constructor(
   private val mFileDownloader: FileDownloader,
   updatesDirectory: File,
   private val launchedUpdate: UpdateEntity?,
-  private val loaderFiles: LoaderFiles
-) : Loader(context, configuration, logger, database, updatesDirectory, loaderFiles) {
+  private val loaderFiles: LoaderFiles,
+  scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+) : Loader(context, configuration, logger, database, updatesDirectory, loaderFiles, scope) {
   constructor(
     context: Context,
     configuration: UpdatesConfiguration,
@@ -41,8 +45,9 @@ class RemoteLoader internal constructor(
     database: UpdatesDatabase,
     fileDownloader: FileDownloader,
     updatesDirectory: File,
-    launchedUpdate: UpdateEntity?
-  ) : this(context, configuration, logger, database, fileDownloader, updatesDirectory, launchedUpdate, LoaderFiles())
+    launchedUpdate: UpdateEntity?,
+    scope: CoroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+  ) : this(context, configuration, logger, database, fileDownloader, updatesDirectory, launchedUpdate, LoaderFiles(), scope)
 
   override suspend fun loadRemoteUpdate(
     database: UpdatesDatabase,

package/android/src/main/java/expo/modules/updates/logging/UpdatesLogEntry.kt

@@ -3,7 +3,6 @@ package expo.modules.updates.logging
 import expo.modules.jsonutils.getNullable
 import expo.modules.jsonutils.require
 import org.json.JSONArray
-import org.json.JSONException
 import org.json.JSONObject
 
 /**
@@ -59,7 +58,11 @@ data class UpdatesLogEntry(
             List(jsonArray.length()) { i -> jsonArray.getString(i) }
           }
         )
-      } catch (e: JSONException) {
+      } catch (e: Exception) {
+        // `JSONObject.require<T>` can surface a ClassCastException via a blind
+        // cast in the catch-all branch (e.g. an int-sized numeric `duration`
+        // token surfaces as `Integer`), which would otherwise escape and
+        // propagate to the caller.
         null
       }
     }

package/android/src/main/java/expo/modules/updates/logging/UpdatesLogReader.kt

@@ -54,6 +54,6 @@ class UpdatesLogReader(
   }
 
   companion object {
-    private const val ONE_DAY_MILLISECONDS = 86400
+    private const val ONE_DAY_MILLISECONDS = 86_400_000L
   }
 }

package/android/src/main/java/expo/modules/updates/procedures/CheckForUpdateProcedure.kt

@@ -43,6 +43,8 @@ class CheckForUpdateProcedure(
     try {
       val updateResponse = downloadRemoteUpdate(extraHeaders)
       processUpdatesResponse(updateResponse, procedureContext, embeddedUpdate)
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       procedureContext.processStateEvent(UpdatesStateEvent.CheckError(e.localizedMessageWithCauseLocalizedMessage()))
       callback(IUpdatesController.CheckForUpdateResult.ErrorResult(e))

package/android/src/main/java/expo/modules/updates/procedures/FetchUpdateProcedure.kt

@@ -14,6 +14,7 @@ import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.selectionpolicy.SelectionPolicy
 import expo.modules.updates.statemachine.UpdatesStateEvent
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
 import java.io.File
 
 class FetchUpdateProcedure(
@@ -25,6 +26,7 @@ class FetchUpdateProcedure(
   private val fileDownloader: FileDownloader,
   private val selectionPolicy: SelectionPolicy,
   private val launchedUpdate: UpdateEntity?,
+  private val scope: CoroutineScope,
   private val callback: (IUpdatesController.FetchUpdateResult) -> Unit
 ) : StateMachineProcedure() {
   override val loggerTimerLabel = "timer-fetch-update"
@@ -36,6 +38,8 @@ class FetchUpdateProcedure(
     try {
       val loaderResult = startRemoteLoader(database, procedureContext)
       processSuccessLoaderResult(loaderResult, procedureContext)
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       logger.error("Failed to download new update", e)
       procedureContext.processStateEvent(
@@ -55,7 +59,8 @@ class FetchUpdateProcedure(
       database,
       fileDownloader,
       updatesDirectory,
-      launchedUpdate
+      launchedUpdate,
+      scope
     )
 
     remoteLoader.assetLoadProgressBlock = { progress ->

package/android/src/main/java/expo/modules/updates/procedures/RelaunchProcedure.kt

@@ -13,6 +13,7 @@ import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.reloadscreen.ReloadScreenManager
 import expo.modules.updates.selectionpolicy.SelectionPolicy
 import expo.modules.updates.statemachine.UpdatesStateEvent
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -57,6 +58,8 @@ class RelaunchProcedure(
     )
     try {
       launchWith(newLauncher)
+    } catch (e: CancellationException) {
+      throw e
     } catch (e: Exception) {
       logger.error("Error launching new launcher", e, UpdatesErrorCode.Unknown)
       callback.onFailure(e)
@@ -91,6 +94,8 @@ class RelaunchProcedure(
           getCurrentLauncher().launchedUpdate,
           selectionPolicy
         )
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         logger.error("Could not run Reaper.", e, UpdatesErrorCode.Unknown)
       }

package/android/src/main/java/expo/modules/updates/procedures/StartupProcedure.kt

@@ -21,6 +21,7 @@ import expo.modules.updates.manifest.Update
 import expo.modules.updates.selectionpolicy.SelectionPolicy
 import expo.modules.updates.statemachine.UpdatesStateEvent
 import expo.modules.updates.statemachine.UpdatesStateValue
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -242,7 +243,7 @@ class StartupProcedure(
           return
         }
         remoteLoadStatus = ErrorRecoveryDelegate.RemoteLoadStatus.NEW_UPDATE_LOADING
-        val remoteLoader = RemoteLoader(context, updatesConfiguration, logger, databaseHolder.database, fileDownloader, updatesDirectory, launchedUpdate)
+        val remoteLoader = RemoteLoader(context, updatesConfiguration, logger, databaseHolder.database, fileDownloader, updatesDirectory, launchedUpdate, procedureScope)
         procedureScope.launch {
           try {
             val loaderResult = remoteLoader.load { updateResponse ->
@@ -267,6 +268,8 @@ class StartupProcedure(
                 ErrorRecoveryDelegate.RemoteLoadStatus.IDLE
               }
             )
+          } catch (e: CancellationException) {
+            throw e
           } catch (e: Exception) {
             logger.error("UpdatesController loadRemoteUpdate onFailure", e, UpdatesErrorCode.UpdateFailedToLoad, launchedUpdate?.loggingId, null)
             setRemoteLoadStatus(ErrorRecoveryDelegate.RemoteLoadStatus.IDLE)

package/android/src/main/java/expo/modules/updates/reloadscreen/ReloadScreenView.kt

@@ -11,6 +11,7 @@ import android.view.View
 import android.widget.FrameLayout
 import android.widget.ImageView
 import android.widget.ProgressBar
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
@@ -135,6 +136,8 @@ class ReloadScreenView @JvmOverloads constructor(
             imageView.setImageBitmap(it)
           } ?: handleImageLoadFailure()
         }
+      } catch (e: CancellationException) {
+        throw e
       } catch (e: Exception) {
         withContext(Dispatchers.Main) {
           handleImageLoadFailure()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-updates",
-  "version": "55.0.28",
+  "version": "55.0.29",
   "description": "Fetches and manages remotely-hosted assets and updates to your app's JS bundle.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -71,5 +71,5 @@
     "react": "*",
     "react-native": "*"
   },
-  "gitHead": "856b99321eeb04bd528b33f90c0e7fa2859a1fcb"
+  "gitHead": "5defc36eae34b72f7bee8385276200242e5458fe"
 }