expo-updates 0.18.10 → 0.19.0

package/CHANGELOG.md

@@ -10,24 +10,50 @@
 
 ### 💡 Others
 
-## 0.18.10 — 2023-07-12
+## 0.19.0 — 2023-07-28
+
+### 🎉 New features
+
+- New useUpdates() JS API. ([#23532](https://github.com/expo/expo/pull/23532) by [@douglowder](https://github.com/douglowder))
+
+### 🐛 Bug fixes
+
+- [Android] Fix rollback embedded update logic. ([#23244](https://github.com/expo/expo/pull/23244) by [@wschurman](https://github.com/wschurman))
+- Correctly handle roll backs in JS module methods. ([#23356](https://github.com/expo/expo/pull/23356), [#23377](https://github.com/expo/expo/pull/23377) by [@wschurman](https://github.com/wschurman))
+- [iOS] Fix unmatched selection policy. ([#23535](https://github.com/expo/expo/pull/23535) by [@chochihim](https://github.com/chochihim))
+- Handle initialization errors in useUpdates(). ([#23640](https://github.com/expo/expo/pull/23640) by [@douglowder](https://github.com/douglowder))
+- [iOS] Fix error handling on iOS during startup check for updates. ([#23663](https://github.com/expo/expo/pull/23663) by [@douglowder](https://github.com/douglowder))
+- Last check dateTime should come from native. ([#23692](https://github.com/expo/expo/pull/23692) by [@douglowder](https://github.com/douglowder))
+
+### 💡 Others
+
+- Native getter for state machine context. ([#23428](https://github.com/expo/expo/pull/23428) by [@douglowder](https://github.com/douglowder))
+- [iOS] Fix template for EX_UPDATES_NATIVE_DEBUG. ([#23602](https://github.com/expo/expo/pull/23602) by [@douglowder](https://github.com/douglowder))
+
+## 0.18.11 - 2023-07-23
+
+### 💡 Others
+
+- [Android] EX_UPDATES_ANDROID_DELAY_LOAD_APP settable by env. ([#23479](https://github.com/expo/expo/pull/23479) by [@douglowder](https://github.com/douglowder))
+
+## 0.18.10 - 2023-07-12
 
 ### 🐛 Bug fixes
 
 - [CLI] Add missing chalk dependency for the `expo-updates` cli. ([#23429](https://github.com/expo/expo/pull/23429) by [@byCedric](https://github.com/byCedric))
 - [CLI] Drop `fs-extra` in favor of `fs`. ([#23431](https://github.com/expo/expo/pull/23431) by [@byCedric](https://github.com/byCedric))
 
-## 0.18.9 — 2023-07-10
+## 0.18.9 - 2023-07-10
 
 ### 🐛 Bug fixes
 
 - [ios] Allow nil scopeKey for bare/embedded updates. ([#23385](https://github.com/expo/expo/pull/23385) by [@wschurman](https://github.com/wschurman))
 
-## 0.18.8 — 2023-07-04
+## 0.18.8 - 2023-07-04
 
 _This version does not introduce any user-facing changes._
 
-## 0.18.7 — 2023-06-30
+## 0.18.7 - 2023-06-30
 
 ### 🐛 Bug fixes
 
@@ -35,7 +61,7 @@ _This version does not introduce any user-facing changes._
 - [iOS] Fix response header casing bug. ([#23234](https://github.com/expo/expo/pull/23234) by [@wschurman](https://github.com/wschurman))
 - Fix tsconfig paths and other SDK 49 Metro features. ([#23276](https://github.com/expo/expo/pull/23276) by [@EvanBacon](https://github.com/EvanBacon))
 
-## 0.18.6 — 2023-06-29
+## 0.18.6 - 2023-06-29
 
 ### 🐛 Bug fixes
 
@@ -53,6 +79,7 @@ _This version does not introduce any user-facing changes._
 
 - [iOS] Use weak delegate for state machine. ([#23060](https://github.com/expo/expo/pull/23060) by [@wschurman](https://github.com/wschurman))
 - [Android] Convert LoaderTask.RemoteCheckResult to sealed class. ([#23061](https://github.com/expo/expo/pull/23061) by [@wschurman](https://github.com/wschurman))
+- [iOS] Use swift enum for AppLoaderTask delegate. ([#23064](https://github.com/expo/expo/pull/23064) by [@wschurman](https://github.com/wschurman))
 
 ## 0.18.3 — 2023-06-24
 

package/android/build.gradle

@@ -4,9 +4,34 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '0.18.10'
+version = '0.19.0'
+
+// Utility method to derive boolean values from the environment or from Java properties,
+// and return them as strings to be used in BuildConfig fields
+def getBoolStringFromPropOrEnv(String name, Boolean defaultValue) {
+  def env_value = System.getenv(name)
+  def prop_value = findProperty(name)
+  def value = defaultValue.toString()
+  // If present, property value in gradle.properties overrides default
+  if (prop_value != null) {
+    value = boolish(prop_value).toString()
+    println("expo-updates: Value of ${name} was overridden by property, new value = ${value}")
+  }
+  // If present, env value overrides default and gradle.properties
+  if (env_value != null) {
+    value = boolish(env_value).toString()
+    println("expo-updates: Value of ${name} was overridden by environment, new value = ${value}")
+  }
+  return value
+}
+
+// If true, app will use bundled manifest and updates will be enabled, even for
+// debug builds. (default false)
+def exUpdatesNativeDebug = getBoolStringFromPropOrEnv("EX_UPDATES_NATIVE_DEBUG", false)
 
-def ex_updates_native_debug = System.getenv("EX_UPDATES_NATIVE_DEBUG") == "1" ? "true" : "false"
+// If true, code will run that delays app loading until updates is initialized, to prevent ANR issues.
+// (default true)
+def exUpdatesAndroidDelayLoadApp = getBoolStringFromPropOrEnv("EX_UPDATES_ANDROID_DELAY_LOAD_APP", true)
 
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
@@ -70,12 +95,12 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 31
-    versionName '0.18.10'
+    versionName '0.19.0'
     consumerProguardFiles("proguard-rules.pro")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
-    buildConfigField("boolean", "EX_UPDATES_NATIVE_DEBUG", ex_updates_native_debug)
-    buildConfigField("boolean", "EX_UPDATES_ANDROID_DELAY_LOAD_APP", boolish(findProperty("EX_UPDATES_ANDROID_DELAY_LOAD_APP") ?: true).toString())
+    buildConfigField("boolean", "EX_UPDATES_NATIVE_DEBUG", exUpdatesNativeDebug)
+    buildConfigField("boolean", "EX_UPDATES_ANDROID_DELAY_LOAD_APP", exUpdatesAndroidDelayLoadApp)
 
     // uncomment below to export the database schema when making changes
     /* javaCompileOptions {

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

@@ -19,12 +19,16 @@ import expo.modules.updates.logging.UpdatesLogEntry
 import expo.modules.updates.logging.UpdatesLogReader
 import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.manifest.ManifestMetadata
+import expo.modules.updates.statemachine.UpdatesStateContext
 import expo.modules.updates.statemachine.UpdatesStateEvent
 import java.util.Date
+import expo.modules.updates.manifest.EmbeddedManifest
+import expo.modules.updates.manifest.UpdateManifest
 
 // these unused imports must stay because of versioning
 /* ktlint-disable no-unused-imports */
 import expo.modules.updates.UpdatesConfiguration
+
 /* ktlint-enable no-unused-imports */
 
 /**
@@ -134,6 +138,28 @@ class UpdatesModule(
     }
   }
 
+  // Used internally by @expo/use-updates useUpdates() to get its initial state
+  @ExpoMethod
+  fun getNativeStateMachineContextAsync(promise: Promise) {
+    try {
+      val updatesServiceLocal = updatesService
+      if (!updatesServiceLocal!!.configuration.isEnabled) {
+        promise.reject(
+          "ERR_UPDATES_DISABLED",
+          "You cannot check for updates when expo-updates is not enabled."
+        )
+        return
+      }
+      val context = updatesServiceLocal.stateMachine?.context ?: UpdatesStateContext()
+      promise.resolve(context.bundle)
+    } catch (e: IllegalStateException) {
+      promise.reject(
+        "ERR_UPDATES_CHECK",
+        "The updates module controller has not been properly initialized. If you're using a development client, you cannot check for updates. Otherwise, make sure you have called the native method UpdatesController.initialize()."
+      )
+    }
+  }
+
   @ExpoMethod
   fun checkForUpdateAsync(promise: Promise) {
     try {
@@ -169,42 +195,46 @@ class UpdatesModule(
               val updateDirective = updateResponse.directiveUpdateResponsePart?.updateDirective
               val updateManifest = updateResponse.manifestUpdateResponsePart?.updateManifest
 
-              val updateInfo = Bundle()
+              val launchedUpdate = updatesServiceLocal.launchedUpdate
+
               if (updateDirective != null) {
                 if (updateDirective is UpdateDirective.RollBackToEmbeddedUpdateDirective) {
-                  updateInfo.putBoolean("isRollBackToEmbedded", true)
-                  updateInfo.putBoolean("isAvailable", false)
-                  promise.resolve(updateInfo)
-                  updatesServiceLocal.stateMachine?.processEvent(
-                    UpdatesStateEvent.CheckCompleteWithRollback()
-                  )
+                  if (!updatesServiceLocal.configuration.hasEmbeddedUpdate) {
+                    promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.NoUpdateAvailable(), updatesServiceLocal)
+                    return
+                  }
+
+                  val embeddedUpdate = EmbeddedManifest.get(context, updatesServiceLocal.configuration)!!.updateEntity
+                  if (embeddedUpdate == null) {
+                    promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.NoUpdateAvailable(), updatesServiceLocal)
+                    return
+                  }
+
+                  if (!updatesServiceLocal.selectionPolicy.shouldLoadRollBackToEmbeddedDirective(
+                      updateDirective,
+                      embeddedUpdate,
+                      launchedUpdate,
+                      updateResponse.responseHeaderData?.manifestFilters
+                    )
+                  ) {
+                    promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.NoUpdateAvailable(), updatesServiceLocal)
+                    return
+                  }
+
+                  promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.RollBackToEmbedded(), updatesServiceLocal)
                   return
                 }
               }
 
               if (updateManifest == null) {
-                updateInfo.putBoolean("isRollBackToEmbedded", false)
-                updateInfo.putBoolean("isAvailable", false)
-                promise.resolve(updateInfo)
-                updatesServiceLocal.stateMachine?.processEvent(
-                  UpdatesStateEvent.CheckCompleteUnavailable()
-                )
+                promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.NoUpdateAvailable(), updatesServiceLocal)
                 return
               }
 
-              val launchedUpdate = updatesServiceLocal.launchedUpdate
               if (launchedUpdate == null) {
                 // this shouldn't ever happen, but if we don't have anything to compare
                 // the new manifest to, let the user know an update is available
-                updateInfo.putBoolean("isRollBackToEmbedded", false)
-                updateInfo.putBoolean("isAvailable", true)
-                updateInfo.putString("manifestString", updateManifest.manifest.toString())
-                promise.resolve(updateInfo)
-                updatesServiceLocal.stateMachine?.processEvent(
-                  UpdatesStateEvent.CheckCompleteWithUpdate(
-                    updateManifest.manifest.getRawJson()
-                  )
-                )
+                promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.UpdateAvailable(updateManifest), updatesServiceLocal)
                 return
               }
 
@@ -214,22 +244,9 @@ class UpdatesModule(
                   updateResponse.responseHeaderData?.manifestFilters
                 )
               ) {
-                updateInfo.putBoolean("isRollBackToEmbedded", false)
-                updateInfo.putBoolean("isAvailable", true)
-                updateInfo.putString("manifestString", updateManifest.manifest.toString())
-                promise.resolve(updateInfo)
-                updatesServiceLocal.stateMachine?.processEvent(
-                  UpdatesStateEvent.CheckCompleteWithUpdate(
-                    updateManifest.manifest.getRawJson()
-                  )
-                )
+                promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.UpdateAvailable(updateManifest), updatesServiceLocal)
               } else {
-                updateInfo.putBoolean("isRollBackToEmbedded", false)
-                updateInfo.putBoolean("isAvailable", false)
-                promise.resolve(updateInfo)
-                updatesServiceLocal.stateMachine?.processEvent(
-                  UpdatesStateEvent.CheckCompleteUnavailable()
-                )
+                promise.resolveWithCheckForUpdateAsyncResult(CheckForUpdateAsyncResult.NoUpdateAvailable(), updatesServiceLocal)
               }
             }
           }
@@ -243,6 +260,51 @@ class UpdatesModule(
     }
   }
 
+  private sealed class CheckForUpdateAsyncResult(private val status: Status) {
+    private enum class Status {
+      NO_UPDATE_AVAILABLE,
+      UPDATE_AVAILABLE,
+      ROLL_BACK_TO_EMBEDDED
+    }
+
+    class NoUpdateAvailable : CheckForUpdateAsyncResult(Status.NO_UPDATE_AVAILABLE)
+    class UpdateAvailable(val updateManifest: UpdateManifest) : CheckForUpdateAsyncResult(Status.UPDATE_AVAILABLE)
+    class RollBackToEmbedded : CheckForUpdateAsyncResult(Status.ROLL_BACK_TO_EMBEDDED)
+  }
+
+  private fun Promise.resolveWithCheckForUpdateAsyncResult(checkForUpdateAsyncResult: CheckForUpdateAsyncResult, updatesServiceLocal: UpdatesInterface) {
+    resolve(
+      Bundle().apply {
+        when (checkForUpdateAsyncResult) {
+          is CheckForUpdateAsyncResult.NoUpdateAvailable -> {
+            putBoolean("isRollBackToEmbedded", false)
+            putBoolean("isAvailable", false)
+          }
+
+          is CheckForUpdateAsyncResult.RollBackToEmbedded -> {
+            putBoolean("isRollBackToEmbedded", true)
+            putBoolean("isAvailable", false)
+          }
+
+          is CheckForUpdateAsyncResult.UpdateAvailable -> {
+            putBoolean("isRollBackToEmbedded", false)
+            putBoolean("isAvailable", true)
+            putString("manifestString", checkForUpdateAsyncResult.updateManifest.manifest.toString())
+          }
+        }
+      }
+    )
+    updatesServiceLocal.stateMachine?.processEvent(
+      when (checkForUpdateAsyncResult) {
+        is CheckForUpdateAsyncResult.NoUpdateAvailable -> UpdatesStateEvent.CheckCompleteUnavailable()
+        is CheckForUpdateAsyncResult.RollBackToEmbedded -> UpdatesStateEvent.CheckCompleteWithRollback()
+        is CheckForUpdateAsyncResult.UpdateAvailable -> UpdatesStateEvent.CheckCompleteWithUpdate(
+          checkForUpdateAsyncResult.updateManifest.manifest.getRawJson()
+        )
+      }
+    )
+  }
+
   @ExpoMethod
   fun fetchUpdateAsync(promise: Promise) {
     try {
@@ -257,10 +319,11 @@ class UpdatesModule(
       updatesServiceLocal.stateMachine?.processEvent(UpdatesStateEvent.Download())
       AsyncTask.execute {
         val databaseHolder = updatesServiceLocal.databaseHolder
+        val database = databaseHolder.database
         RemoteLoader(
           context,
           updatesServiceLocal.configuration,
-          databaseHolder.database,
+          database,
           updatesServiceLocal.fileDownloader,
           updatesServiceLocal.directory,
           updatesServiceLocal.launchedUpdate
@@ -294,7 +357,8 @@ class UpdatesModule(
                   )
                 }
 
-                val updateManifest = updateResponse.manifestUpdateResponsePart?.updateManifest ?: return Loader.OnUpdateResponseLoadedResult(shouldDownloadManifestIfPresentInResponse = false)
+                val updateManifest = updateResponse.manifestUpdateResponsePart?.updateManifest
+                  ?: return Loader.OnUpdateResponseLoadedResult(shouldDownloadManifestIfPresentInResponse = false)
 
                 return Loader.OnUpdateResponseLoadedResult(
                   shouldDownloadManifestIfPresentInResponse = updatesServiceLocal.selectionPolicy.shouldLoadNewUpdate(
@@ -306,44 +370,59 @@ class UpdatesModule(
               }
 
               override fun onSuccess(loaderResult: Loader.LoaderResult) {
-                databaseHolder.releaseDatabase()
-                val updateInfo = Bundle()
-
-                if (loaderResult.updateDirective is UpdateDirective.RollBackToEmbeddedUpdateDirective) {
-                  updateInfo.putBoolean("isRollBackToEmbedded", true)
-                  updateInfo.putBoolean("isNew", false)
-
-                  updatesServiceLocal.stateMachine?.processEvent(
-                    UpdatesStateEvent.DownloadCompleteWithRollback()
-                  )
-                } else {
-                  updateInfo.putBoolean("isRollBackToEmbedded", false)
-
-                  if (loaderResult.updateEntity == null) {
-                    updateInfo.putBoolean("isNew", false)
-                    updatesServiceLocal.stateMachine?.processEvent(
-                      UpdatesStateEvent.DownloadComplete()
-                    )
-                  } else {
-                    updatesServiceLocal.resetSelectionPolicy()
-                    updateInfo.putBoolean("isNew", true)
-
-                    // We need the explicit casting here because when in versioned expo-updates,
-                    // the UpdateEntity and UpdatesModule are in different package namespace,
-                    // Kotlin cannot do the smart casting for that case.
-                    val updateEntity = loaderResult.updateEntity as UpdateEntity
-
-                    updateInfo.putString(
-                      "manifestString",
-                      updateEntity.manifest.toString()
+                RemoteLoader.processSuccessLoaderResult(
+                  context,
+                  updatesServiceLocal.configuration,
+                  database,
+                  updatesServiceLocal.selectionPolicy,
+                  updatesServiceLocal.directory,
+                  updatesServiceLocal.launchedUpdate,
+                  loaderResult
+                ) { availableUpdate, didRollBackToEmbedded ->
+                  databaseHolder.releaseDatabase()
+
+                  if (didRollBackToEmbedded) {
+                    promise.resolve(
+                      Bundle().apply {
+                        putBoolean("isRollBackToEmbedded", true)
+                        putBoolean("isNew", false)
+                      }
                     )
                     updatesServiceLocal.stateMachine?.processEvent(
-                      UpdatesStateEvent.DownloadCompleteWithUpdate(updateEntity.manifest!!)
+                      UpdatesStateEvent.DownloadCompleteWithRollback()
                     )
+                  } else {
+                    if (availableUpdate == null) {
+                      promise.resolve(
+                        Bundle().apply {
+                          putBoolean("isRollBackToEmbedded", false)
+                          putBoolean("isNew", false)
+                        }
+                      )
+                      updatesServiceLocal.stateMachine?.processEvent(
+                        UpdatesStateEvent.DownloadComplete()
+                      )
+                    } else {
+                      updatesServiceLocal.resetSelectionPolicy()
+
+                      // We need the explicit casting here because when in versioned expo-updates,
+                      // the UpdateEntity and UpdatesModule are in different package namespace,
+                      // Kotlin cannot do the smart casting for that case.
+                      val updateEntity = loaderResult.updateEntity as UpdateEntity
+
+                      promise.resolve(
+                        Bundle().apply {
+                          putBoolean("isRollBackToEmbedded", false)
+                          putBoolean("isNew", true)
+                          putString("manifestString", updateEntity.manifest.toString())
+                        }
+                      )
+                      updatesServiceLocal.stateMachine?.processEvent(
+                        UpdatesStateEvent.DownloadCompleteWithUpdate(updateEntity.manifest!!)
+                      )
+                    }
                   }
                 }
-
-                promise.resolve(updateInfo)
               }
             }
           )

package/android/src/main/java/expo/modules/updates/db/dao/UpdateDao.kt

@@ -34,9 +34,6 @@ abstract class UpdateDao {
   @Query("UPDATE updates SET status = :status WHERE id = :id;")
   abstract fun _markUpdateWithStatus(status: UpdateStatus, id: UUID)
 
-  @Update
-  abstract fun _updateUpdate(update: UpdateEntity)
-
   @Query(
     "UPDATE updates SET status = :status WHERE id IN (" +
       "SELECT DISTINCT update_id FROM updates_assets WHERE asset_id IN (:missingAssetIds));"
@@ -78,14 +75,20 @@ abstract class UpdateDao {
 
   fun setUpdateScopeKey(update: UpdateEntity, newScopeKey: String) {
     update.scopeKey = newScopeKey
-    _updateUpdate(update)
+    _setUpdateScopeKeyInternal(update.id, newScopeKey)
   }
 
+  @Query("UPDATE updates SET scope_key = :newScopeKey WHERE id = :id;")
+  abstract fun _setUpdateScopeKeyInternal(id: UUID, newScopeKey: String)
+
   fun setUpdateCommitTime(update: UpdateEntity, commitTime: Date) {
     update.commitTime = commitTime
-    _updateUpdate(update)
+    _setUpdateCommitTime(update.id, commitTime)
   }
 
+  @Query("UPDATE updates SET commit_time = :commitTime WHERE id = :id;")
+  abstract fun _setUpdateCommitTime(id: UUID, commitTime: Date)
+
   @Transaction
   open fun markUpdateFinished(update: UpdateEntity, hasSkippedEmbeddedAssets: Boolean) {
     var statusToMark = UpdateStatus.READY
@@ -103,20 +106,30 @@ abstract class UpdateDao {
   }
 
   fun markUpdateAccessed(update: UpdateEntity) {
-    update.lastAccessed = Date()
-    _updateUpdate(update)
+    val newLastAccessed = Date()
+    update.lastAccessed = newLastAccessed
+    _markUpdateAccessed(update.id, newLastAccessed)
   }
 
+  @Query("UPDATE updates SET last_accessed = :lastAccessed WHERE id = :id;")
+  abstract fun _markUpdateAccessed(id: UUID, lastAccessed: Date)
+
   fun incrementSuccessfulLaunchCount(update: UpdateEntity) {
     update.successfulLaunchCount++
-    _updateUpdate(update)
+    _incrementSuccessfulLaunchCount(update.id)
   }
 
+  @Query("UPDATE updates SET successful_launch_count = successful_launch_count + 1 WHERE id = :id;")
+  abstract fun _incrementSuccessfulLaunchCount(id: UUID)
+
   fun incrementFailedLaunchCount(update: UpdateEntity) {
     update.failedLaunchCount++
-    _updateUpdate(update)
+    _incrementFailedLaunchCount(update.id)
   }
 
+  @Query("UPDATE updates SET failed_launch_count = failed_launch_count + 1 WHERE id = :id;")
+  abstract fun _incrementFailedLaunchCount(id: UUID)
+
   fun markUpdatesWithMissingAssets(missingAssets: List<AssetEntity>) {
     val missingAssetIds = mutableListOf<Long>()
     for (asset in missingAssets) {

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

@@ -372,80 +372,17 @@ class LoaderTask(
           }
 
           override fun onSuccess(loaderResult: Loader.LoaderResult) {
-            val updateEntity = loaderResult.updateEntity
-            val updateDirective = loaderResult.updateDirective
-
-            if (updateDirective != null && updateDirective is UpdateDirective.RollBackToEmbeddedUpdateDirective) {
-              processRollBackToEmbeddedDirective(updateDirective)
-            } else {
-              launchUpdate(updateEntity)
-            }
-          }
-
-          /**
-           * If directive is to roll-back to the embedded update and there is an embedded update,
-           * we need to update embedded update in the DB with the newer commitTime from the directive
-           * so that the selection policy will choose it. That way future updates can continue to be applied
-           * over this roll back, but older ones won't.
-           */
-          private fun processRollBackToEmbeddedDirective(updateDirective: UpdateDirective.RollBackToEmbeddedUpdateDirective) {
-            if (!configuration.hasEmbeddedUpdate) {
-              launchUpdate(null)
-              return
-            }
-
-            val embeddedUpdate = EmbeddedManifest.get(context, configuration)!!.updateEntity
-            if (embeddedUpdate == null) {
-              launchUpdate(null)
-              return
-            }
-
-            val launcher = DatabaseLauncher(configuration, directory, fileDownloader, selectionPolicy)
-            val launchableUpdate = launcher.getLaunchableUpdate(database, context)
-            val manifestFilters = ManifestMetadata.getManifestFilters(database, configuration)
-
-            if (!selectionPolicy.shouldLoadRollBackToEmbeddedDirective(updateDirective, embeddedUpdate, launchableUpdate, manifestFilters)) {
-              launchUpdate(null)
-              return
+            RemoteLoader.processSuccessLoaderResult(
+              context,
+              configuration,
+              database,
+              selectionPolicy,
+              directory,
+              candidateLauncher?.launchedUpdate,
+              loaderResult
+            ) { availableUpdate, _ ->
+              launchUpdate(availableUpdate)
             }
-
-            // update the embedded update commit time in the in-memory embedded update since it is a singleton
-            embeddedUpdate.commitTime = updateDirective.commitTime
-
-            // update the embedded update commit time in the database (requires loading and then updating)
-            EmbeddedLoader(context, configuration, database, directory).start(object : LoaderCallback {
-              /**
-               * This should never happen since we check for the embedded update above
-               */
-              override fun onFailure(e: Exception) {
-                Log.e(
-                  TAG,
-                  "Embedded update erroneously null when applying roll back to embedded directive",
-                  e
-                )
-                launchUpdate(null)
-              }
-
-              override fun onSuccess(loaderResult: Loader.LoaderResult) {
-                val embeddedUpdateToLoad = loaderResult.updateEntity
-                database.updateDao().setUpdateCommitTime(embeddedUpdateToLoad!!, updateDirective.commitTime)
-                launchUpdate(null)
-              }
-
-              override fun onAssetLoaded(
-                asset: AssetEntity,
-                successfulAssetCount: Int,
-                failedAssetCount: Int,
-                totalAssetCount: Int
-              ) {
-              }
-
-              override fun onUpdateResponseLoaded(updateResponse: UpdateResponse): Loader.OnUpdateResponseLoadedResult {
-                return Loader.OnUpdateResponseLoadedResult(
-                  shouldDownloadManifestIfPresentInResponse = true
-                )
-              }
-            })
           }
 
           private fun launchUpdate(availableUpdate: UpdateEntity?) {