expo-updates 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -10,6 +10,29 @@
 
 ### 💡 Others
 
+## 0.18.0 — 2023-06-22
+
+_This version does not introduce any user-facing changes._
+
+## 0.17.1 — 2023-06-21
+
+### 📚 3rd party library updates
+
+- Updated `junit` to `4.13.2`. ([#22395](https://github.com/expo/expo/pull/22395) by [@josephyanks](https://github.com/josephyanks))
+
+### 🎉 New features
+
+- [Android] Load updates in background thread and prevent ANR from initial launch. ([#20273](https://github.com/expo/expo/pull/20273) by [@kudo](https://github.com/kudo))
+- Added support for React Native 0.72. ([#22588](https://github.com/expo/expo/pull/22588) by [@kudo](https://github.com/kudo))
+- Added the Brotli compression support for EAS Update on Android. ([#22982](https://github.com/expo/expo/pull/22982) by [@kudo](https://github.com/kudo))
+- [Android][iOS] State machine implementation. ([#22845](https://github.com/expo/expo/pull/22845) by [@douglowder](https://github.com/douglowder))
+
+### 🐛 Bug fixes
+
+- [Android] Resolve up the project root when creating production manifest. ([#22044](https://github.com/expo/expo/pull/22044) by [@EvanBacon](https://github.com/EvanBacon))
+- Fixed Android build warnings for Gradle version 8. ([#22537](https://github.com/expo/expo/pull/22537), [#22609](https://github.com/expo/expo/pull/22609) by [@kudo](https://github.com/kudo))
+- Fixed broken `create-manifest-android.gradle` on Android Gradle version 8. ([#22538](https://github.com/expo/expo/pull/22538) by [@kudo](https://github.com/kudo))
+
 ## 0.17.0 — 2023-05-08
 
 ### 🛠 Breaking changes
@@ -37,6 +60,7 @@
 - Fix empty body no-op multipart response. ([#22227](https://github.com/expo/expo/pull/22227) by [@wschurman](https://github.com/wschurman))
 - Put extra data mutation in transaction. ([#22252](https://github.com/expo/expo/pull/22252) by [@wschurman](https://github.com/wschurman))
 - [iOS] fix bizarre bug when downloading update twice. ([#22355](https://github.com/expo/expo/pull/22355) by [@douglowder](https://github.com/douglowder))
+- Fix rollback to embedded logic. ([#22433](https://github.com/expo/expo/pull/22433), [#22434](https://github.com/expo/expo/pull/22434) by [@wschurman](https://github.com/wschurman))
 
 ### 💡 Others
 

package/README.md

@@ -1,4 +1,11 @@
-# expo-updates
+<p>
+  <a href="https://docs.expo.dev/versions/latest/sdk/updates/">
+    <img
+      src="../../.github/resources/expo-updates.svg"
+      alt="expo-updates"
+      height="64" />
+  </a>
+</p>
 
 `expo-updates` fetches and manages updates to your app stored on a remote server.
 

package/android/build.gradle

@@ -4,12 +4,10 @@ apply plugin: 'kotlin-kapt'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '0.17.0'
+version = '0.18.0'
 
 def ex_updates_native_debug = System.getenv("EX_UPDATES_NATIVE_DEBUG") == "1" ? "true" : "false"
 
-apply from: "../scripts/create-manifest-android.gradle"
-
 buildscript {
   def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
   if (expoModulesCorePlugin.exists()) {
@@ -40,19 +38,11 @@ buildscript {
   }
 }
 
-// Creating sources with comments
-task androidSourcesJar(type: Jar) {
-  classifier = 'sources'
-  from android.sourceSets.main.java.srcDirs
-}
-
 afterEvaluate {
   publishing {
     publications {
       release(MavenPublication) {
         from components.release
-        // Add additional sourcesJar to artifacts
-        artifact(androidSourcesJar)
       }
     }
     repositories {
@@ -75,14 +65,18 @@ android {
     jvmTarget = JavaVersion.VERSION_11.majorVersion
   }
 
+  namespace "expo.modules.updates"
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 33)
     versionCode 31
-    versionName '0.17.0'
+    versionName '0.18.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())
+
     // uncomment below to export the database schema when making changes
     /* javaCompileOptions {
       annotationProcessorOptions {
@@ -102,6 +96,11 @@ android {
     androidTest.assets.srcDirs += files("$projectDir/src/androidTest/schemas".toString())
     androidTest.assets.srcDirs += files("$projectDir/src/androidTest/certificates".toString())
   }
+  publishing {
+    singleVariant("release") {
+      withSourcesJar()
+    }
+  }
 }
 
 dependencies {
@@ -121,6 +120,7 @@ dependencies {
 
   implementation("com.squareup.okhttp3:okhttp:4.9.2")
   implementation("com.squareup.okhttp3:okhttp-urlconnection:4.9.2")
+  implementation("com.squareup.okhttp3:okhttp-brotli:4.9.2")
   implementation("com.squareup.okio:okio:2.9.0")
   implementation("commons-codec:commons-codec:1.10")
   implementation("commons-io:commons-io:2.6")
@@ -128,7 +128,7 @@ dependencies {
   implementation("org.apache.commons:commons-lang3:3.9")
   implementation("org.bouncycastle:bcutil-jdk15to18:1.70")
 
-  testImplementation 'junit:junit:4.13.1'
+  testImplementation 'junit:junit:4.13.2'
   testImplementation 'androidx.test:core:1.4.0'
   testImplementation 'io.mockk:mockk:1.12.3'
   testImplementation "org.jetbrains.kotlin:kotlin-test-junit:${getKotlinVersion()}"

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,3 @@
-<manifest package="expo.modules.updates"
-    xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
 </manifest>

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

@@ -12,6 +12,7 @@ import com.facebook.react.ReactInstanceManager
 import com.facebook.react.ReactNativeHost
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.bridge.WritableMap
 import expo.modules.updates.db.BuildData
 import expo.modules.updates.db.DatabaseHolder
 import expo.modules.updates.db.Reaper
@@ -25,7 +26,7 @@ import expo.modules.updates.launcher.Launcher
 import expo.modules.updates.launcher.Launcher.LauncherCallback
 import expo.modules.updates.launcher.NoDatabaseLauncher
 import expo.modules.updates.loader.*
-import expo.modules.updates.loader.LoaderTask.BackgroundUpdateStatus
+import expo.modules.updates.loader.LoaderTask.RemoteUpdateStatus
 import expo.modules.updates.loader.LoaderTask.LoaderTaskCallback
 import expo.modules.updates.logging.UpdatesErrorCode
 import expo.modules.updates.logging.UpdatesLogReader
@@ -33,6 +34,12 @@ import expo.modules.updates.logging.UpdatesLogger
 import expo.modules.updates.manifest.UpdateManifest
 import expo.modules.updates.selectionpolicy.SelectionPolicy
 import expo.modules.updates.selectionpolicy.SelectionPolicyFactory
+import expo.modules.updates.statemachine.UpdatesStateChangeEventSender
+import expo.modules.updates.statemachine.UpdatesStateContext
+import expo.modules.updates.statemachine.UpdatesStateEvent
+import expo.modules.updates.statemachine.UpdatesStateEventType
+import expo.modules.updates.statemachine.UpdatesStateMachine
+import expo.modules.updates.statemachine.UpdatesStateValue
 import java.io.File
 import java.lang.ref.WeakReference
 
@@ -58,7 +65,7 @@ import java.lang.ref.WeakReference
 class UpdatesController private constructor(
   context: Context,
   var updatesConfiguration: UpdatesConfiguration
-) {
+) : UpdatesStateChangeEventSender {
   private var reactNativeHost: WeakReference<ReactNativeHost>? = if (context is ReactApplication) {
     WeakReference((context as ReactApplication).reactNativeHost)
   } else {
@@ -67,6 +74,7 @@ class UpdatesController private constructor(
 
   var updatesDirectory: File? = null
   var updatesDirectoryException: Exception? = null
+  var stateMachine: UpdatesStateMachine = UpdatesStateMachine(context, this)
 
   private var launcher: Launcher? = null
   val databaseHolder = DatabaseHolder(UpdatesDatabase.getInstance(context))
@@ -273,6 +281,22 @@ class UpdatesController private constructor(
           return true
         }
 
+        override fun onRemoteCheckForUpdateStarted() {
+          stateMachine.processEvent(UpdatesStateEvent.Check())
+        }
+
+        override fun onRemoteCheckForUpdateFinished(result: LoaderTask.RemoteCheckResult) {
+          var event = UpdatesStateEvent.CheckComplete()
+          if (result.manifest != null) {
+            event = UpdatesStateEvent.CheckCompleteWithUpdate(
+              result.manifest
+            )
+          } else if (result.isRollBackToEmbedded == true) {
+            event = UpdatesStateEvent.CheckCompleteWithRollback()
+          }
+          stateMachine.processEvent(event)
+        }
+
         override fun onRemoteUpdateManifestResponseManifestLoaded(updateManifest: UpdateManifest) {
           remoteLoadStatus = ErrorRecoveryDelegate.RemoteLoadStatus.NEW_UPDATE_LOADING
         }
@@ -285,13 +309,34 @@ class UpdatesController private constructor(
           notifyController()
         }
 
-        override fun onBackgroundUpdateFinished(
-          status: BackgroundUpdateStatus,
+        override fun onRemoteUpdateLoadStarted() {
+          stateMachine.processEvent(UpdatesStateEvent.Download())
+        }
+
+        override fun onRemoteUpdateAssetLoaded(
+          asset: AssetEntity,
+          successfulAssetCount: Int,
+          failedAssetCount: Int,
+          totalAssetCount: Int
+        ) {
+          val body = mapOf(
+            "assetInfo" to mapOf(
+              "name" to asset.embeddedAssetFilename,
+              "successfulAssetCount" to successfulAssetCount,
+              "failedAssetCount" to failedAssetCount,
+              "totalAssetCount" to totalAssetCount
+            )
+          )
+          logger.info("AppController appLoaderTask didLoadAsset: $body", UpdatesErrorCode.None, null, asset.expectedHash)
+        }
+
+        override fun onRemoteUpdateFinished(
+          status: RemoteUpdateStatus,
           update: UpdateEntity?,
           exception: Exception?
         ) {
           when (status) {
-            BackgroundUpdateStatus.ERROR -> {
+            RemoteUpdateStatus.ERROR -> {
               if (exception == null) {
                 throw AssertionError("Background update with error status must have a nonnull exception object")
               }
@@ -299,9 +344,31 @@ class UpdatesController private constructor(
               remoteLoadStatus = ErrorRecoveryDelegate.RemoteLoadStatus.IDLE
               val params = Arguments.createMap()
               params.putString("message", exception.message)
-              UpdatesUtils.sendEventToReactNative(reactNativeHost, UPDATE_ERROR_EVENT, params)
+              sendLegacyUpdateEventToJS(UPDATE_ERROR_EVENT, params)
+
+              // Since errors can happen through a number of paths, we do these checks
+              // to make sure the state machine is valid
+              when (stateMachine.state) {
+                UpdatesStateValue.Idle -> {
+                  stateMachine.processEvent(UpdatesStateEvent.Download())
+                  stateMachine.processEvent(
+                    UpdatesStateEvent.DownloadError(exception.message ?: "")
+                  )
+                }
+                UpdatesStateValue.Checking -> {
+                  stateMachine.processEvent(
+                    UpdatesStateEvent.CheckError(exception.message ?: "")
+                  )
+                }
+                else -> {
+                  // .downloading
+                  stateMachine.processEvent(
+                    UpdatesStateEvent.DownloadError(exception.message ?: "")
+                  )
+                }
+              }
             }
-            BackgroundUpdateStatus.UPDATE_AVAILABLE -> {
+            RemoteUpdateStatus.UPDATE_AVAILABLE -> {
               if (update == null) {
                 throw AssertionError("Background update with error status must have a nonnull update object")
               }
@@ -309,16 +376,19 @@ class UpdatesController private constructor(
               logger.info("UpdatesController onBackgroundUpdateFinished: Update available", UpdatesErrorCode.None)
               val params = Arguments.createMap()
               params.putString("manifestString", update.manifest.toString())
-              UpdatesUtils.sendEventToReactNative(reactNativeHost, UPDATE_AVAILABLE_EVENT, params)
+              sendLegacyUpdateEventToJS(UPDATE_AVAILABLE_EVENT, params)
+              stateMachine.processEvent(
+                UpdatesStateEvent.DownloadCompleteWithUpdate(update.manifest)
+              )
             }
-            BackgroundUpdateStatus.NO_UPDATE_AVAILABLE -> {
+            RemoteUpdateStatus.NO_UPDATE_AVAILABLE -> {
               remoteLoadStatus = ErrorRecoveryDelegate.RemoteLoadStatus.IDLE
               logger.error("UpdatesController onBackgroundUpdateFinished: No update available", UpdatesErrorCode.NoUpdatesAvailable)
-              UpdatesUtils.sendEventToReactNative(
-                reactNativeHost,
-                UPDATE_NO_UPDATE_AVAILABLE_EVENT,
-                null
-              )
+              sendLegacyUpdateEventToJS(UPDATE_NO_UPDATE_AVAILABLE_EVENT, null)
+              // TODO: handle rollbacks properly, but this works for now
+              if (stateMachine.state == UpdatesStateValue.Downloading) {
+                stateMachine.processEvent(UpdatesStateEvent.DownloadComplete())
+              }
             }
           }
           errorRecovery.notifyNewRemoteLoadStatus(remoteLoadStatus)
@@ -438,6 +508,8 @@ class UpdatesController private constructor(
       return
     }
 
+    stateMachine.processEvent(UpdatesStateEvent.Restart())
+
     val oldLaunchAssetFile = launcher!!.launchAssetFile
 
     val databaseLocal = getDatabase()
@@ -482,11 +554,24 @@ class UpdatesController private constructor(
           if (shouldRunReaper) {
             runReaper()
           }
+          stateMachine.reset()
         }
       }
     )
   }
 
+  override fun sendUpdateStateChangeEventToBridge(eventType: UpdatesStateEventType, context: UpdatesStateContext) {
+    sendEventToJS(UPDATES_STATE_CHANGE_EVENT_NAME, eventType.type, context.writableMap)
+  }
+
+  fun sendLegacyUpdateEventToJS(eventType: String, params: WritableMap?) {
+    sendEventToJS(UPDATES_EVENT_NAME, eventType, params)
+  }
+
+  private fun sendEventToJS(eventName: String, eventType: String, params: WritableMap?) {
+    UpdatesUtils.sendEventToReactNative(reactNativeHost, logger, eventName, eventType, params)
+  }
+
   companion object {
     private val TAG = UpdatesController::class.java.simpleName
 
@@ -494,6 +579,9 @@ class UpdatesController private constructor(
     private const val UPDATE_NO_UPDATE_AVAILABLE_EVENT = "noUpdateAvailable"
     private const val UPDATE_ERROR_EVENT = "error"
 
+    private const val UPDATES_EVENT_NAME = "Expo.nativeUpdatesEvent"
+    private const val UPDATES_STATE_CHANGE_EVENT_NAME = "Expo.nativeUpdatesStateChangeEvent"
+
     private var singletonInstance: UpdatesController? = null
     @JvmStatic val instance: UpdatesController
       get() {

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

@@ -10,7 +10,8 @@ import java.io.File
 
 // this unused import must stay because of versioning
 /* ktlint-disable no-unused-imports */
-import expo.modules.updates.UpdatesConfiguration
+import expo.modules.updates.statemachine.UpdatesStateMachine
+
 /* ktlint-enable no-unused-imports */
 
 /**
@@ -23,6 +24,7 @@ interface UpdatesInterface {
   val directory: File?
   val databaseHolder: DatabaseHolder
   val fileDownloader: FileDownloader
+  val stateMachine: UpdatesStateMachine?
 
   val isEmergencyLaunch: Boolean
   val isEmbeddedLaunch: Boolean

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

@@ -18,6 +18,7 @@ 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.UpdatesStateEvent
 import java.util.Date
 
 // these unused imports must stay because of versioning
@@ -40,6 +41,8 @@ class UpdatesModule(
 ) : ExportedModule(context) {
   private inline fun <reified T> moduleRegistry() = moduleRegistryDelegate.getFromModuleRegistry<T>()
 
+  private val logger = UpdatesLogger(context)
+
   private val updatesService: UpdatesInterface? by moduleRegistry()
 
   override fun onCreate(moduleRegistry: ModuleRegistry) {
@@ -141,69 +144,91 @@ class UpdatesModule(
         )
         return
       }
-      val databaseHolder = updatesServiceLocal.databaseHolder
-      val extraHeaders = FileDownloader.getExtraHeadersForRemoteUpdateRequest(
-        databaseHolder.database,
-        updatesServiceLocal.configuration,
-        updatesServiceLocal.launchedUpdate,
-        updatesServiceLocal.embeddedUpdate
-      )
-      databaseHolder.releaseDatabase()
-      updatesServiceLocal.fileDownloader.downloadRemoteUpdate(
-        updatesServiceLocal.configuration,
-        extraHeaders,
-        context,
-        object : RemoteUpdateDownloadCallback {
-          override fun onFailure(message: String, e: Exception) {
-            promise.reject("ERR_UPDATES_CHECK", message, e)
-            Log.e(TAG, message, e)
-          }
+      updatesServiceLocal.stateMachine?.processEvent(UpdatesStateEvent.Check())
+      AsyncTask.execute {
+        val databaseHolder = updatesServiceLocal.databaseHolder
+        val extraHeaders = FileDownloader.getExtraHeadersForRemoteUpdateRequest(
+          databaseHolder.database,
+          updatesServiceLocal.configuration,
+          updatesServiceLocal.launchedUpdate,
+          updatesServiceLocal.embeddedUpdate
+        )
+        databaseHolder.releaseDatabase()
+        updatesServiceLocal.fileDownloader.downloadRemoteUpdate(
+          updatesServiceLocal.configuration,
+          extraHeaders,
+          context,
+          object : RemoteUpdateDownloadCallback {
+            override fun onFailure(message: String, e: Exception) {
+              promise.reject("ERR_UPDATES_CHECK", message, e)
+              Log.e(TAG, message, e)
+            }
 
-          override fun onSuccess(updateResponse: UpdateResponse) {
-            val updateDirective = updateResponse.directiveUpdateResponsePart?.updateDirective
-            val updateManifest = updateResponse.manifestUpdateResponsePart?.updateManifest
+            override fun onSuccess(updateResponse: UpdateResponse) {
+              val updateDirective = updateResponse.directiveUpdateResponsePart?.updateDirective
+              val updateManifest = updateResponse.manifestUpdateResponsePart?.updateManifest
+
+              val updateInfo = Bundle()
+              if (updateDirective != null) {
+                if (updateDirective is UpdateDirective.RollBackToEmbeddedUpdateDirective) {
+                  updateInfo.putBoolean("isRollBackToEmbedded", true)
+                  promise.resolve(updateInfo)
+                  updatesServiceLocal.stateMachine?.processEvent(
+                    UpdatesStateEvent.CheckCompleteWithRollback()
+                  )
+                  return
+                }
+              }
 
-            val updateInfo = Bundle()
-            if (updateDirective != null) {
-              if (updateDirective is UpdateDirective.RollBackToEmbeddedUpdateDirective) {
-                updateInfo.putBoolean("isRollBackToEmbedded", true)
+              if (updateManifest == null) {
+                updateInfo.putBoolean("isAvailable", false)
                 promise.resolve(updateInfo)
+                updatesServiceLocal.stateMachine?.processEvent(
+                  UpdatesStateEvent.CheckComplete()
+                )
                 return
               }
-            }
 
-            if (updateManifest == null) {
-              updateInfo.putBoolean("isAvailable", false)
-              promise.resolve(updateInfo)
-              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("isAvailable", true)
-              updateInfo.putString("manifestString", updateManifest.manifest.toString())
-              promise.resolve(updateInfo)
-              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("isAvailable", true)
+                updateInfo.putString("manifestString", updateManifest.manifest.toString())
+                promise.resolve(updateInfo)
+                updatesServiceLocal.stateMachine?.processEvent(
+                  UpdatesStateEvent.CheckCompleteWithUpdate(
+                    updateManifest.manifest.getRawJson()
+                  )
+                )
+                return
+              }
 
-            if (updatesServiceLocal.selectionPolicy.shouldLoadNewUpdate(
-                updateManifest.updateEntity,
-                launchedUpdate,
-                updateResponse.responseHeaderData?.manifestFilters
-              )
-            ) {
-              updateInfo.putBoolean("isAvailable", true)
-              updateInfo.putString("manifestString", updateManifest.manifest.toString())
-              promise.resolve(updateInfo)
-            } else {
-              updateInfo.putBoolean("isAvailable", false)
-              promise.resolve(updateInfo)
+              if (updatesServiceLocal.selectionPolicy.shouldLoadNewUpdate(
+                  updateManifest.updateEntity,
+                  launchedUpdate,
+                  updateResponse.responseHeaderData?.manifestFilters
+                )
+              ) {
+                updateInfo.putBoolean("isAvailable", true)
+                updateInfo.putString("manifestString", updateManifest.manifest.toString())
+                promise.resolve(updateInfo)
+                updatesServiceLocal.stateMachine?.processEvent(
+                  UpdatesStateEvent.CheckCompleteWithUpdate(
+                    updateManifest.manifest.getRawJson()
+                  )
+                )
+              } else {
+                updateInfo.putBoolean("isAvailable", false)
+                promise.resolve(updateInfo)
+                updatesServiceLocal.stateMachine?.processEvent(
+                  UpdatesStateEvent.CheckComplete()
+                )
+              }
             }
           }
-        }
-      )
+        )
+      }
     } catch (e: IllegalStateException) {
       promise.reject(
         "ERR_UPDATES_CHECK",
@@ -223,6 +248,7 @@ class UpdatesModule(
         )
         return
       }
+      updatesServiceLocal.stateMachine?.processEvent(UpdatesStateEvent.Download())
       AsyncTask.execute {
         val databaseHolder = updatesServiceLocal.databaseHolder
         RemoteLoader(
@@ -238,6 +264,9 @@ class UpdatesModule(
               override fun onFailure(e: Exception) {
                 databaseHolder.releaseDatabase()
                 promise.reject("ERR_UPDATES_FETCH", "Failed to download new update", e)
+                updatesServiceLocal.stateMachine?.processEvent(
+                  UpdatesStateEvent.DownloadError("Failed to download new update: ${e.message}")
+                )
               }
 
               override fun onAssetLoaded(
@@ -276,9 +305,15 @@ class UpdatesModule(
 
                 if (loaderResult.updateDirective is UpdateDirective.RollBackToEmbeddedUpdateDirective) {
                   updateInfo.putBoolean("isRollBackToEmbedded", true)
+                  updatesServiceLocal.stateMachine?.processEvent(
+                    UpdatesStateEvent.DownloadCompleteWithRollback()
+                  )
                 } else {
                   if (loaderResult.updateEntity == null) {
                     updateInfo.putBoolean("isNew", false)
+                    updatesServiceLocal.stateMachine?.processEvent(
+                      UpdatesStateEvent.DownloadComplete()
+                    )
                   } else {
                     updatesServiceLocal.resetSelectionPolicy()
                     updateInfo.putBoolean("isNew", true)
@@ -286,6 +321,9 @@ class UpdatesModule(
                       "manifestString",
                       loaderResult.updateEntity.manifest.toString()
                     )
+                    updatesServiceLocal.stateMachine?.processEvent(
+                      UpdatesStateEvent.DownloadCompleteWithUpdate(loaderResult.updateEntity.manifest)
+                    )
                   }
                 }
 
@@ -295,15 +333,14 @@ class UpdatesModule(
           )
       }
     } catch (e: IllegalStateException) {
-      promise.reject(
-        "ERR_UPDATES_FETCH",
-        "The updates module controller has not been properly initialized. If you're using a development client, you cannot fetch updates. Otherwise, make sure you have called the native method UpdatesController.initialize()."
-      )
+      val message = "The updates module controller has not been properly initialized. If you're using a development client, you cannot fetch updates. Otherwise, make sure you have called the native method UpdatesController.initialize()."
+      promise.reject("ERR_UPDATES_FETCH", message)
     }
   }
 
   @ExpoMethod
   fun getExtraParamsAsync(promise: Promise) {
+    logger.debug("Called getExtraParamsAsync")
     val updatesServiceLocal = updatesService
     if (!updatesServiceLocal!!.configuration.isEnabled) {
       promise.reject(
@@ -315,17 +352,36 @@ class UpdatesModule(
 
     AsyncTask.execute {
       val databaseHolder = updatesServiceLocal.databaseHolder
-      promise.resolve(
-        ManifestMetadata.getExtraParams(
+      try {
+        val result = ManifestMetadata.getExtraParams(
           databaseHolder.database,
           updatesServiceLocal.configuration,
         )
-      )
+        databaseHolder.releaseDatabase()
+        val resultMap = when (result) {
+          null -> Bundle()
+          else -> {
+            Bundle().apply {
+              result.forEach {
+                putString(it.key, it.value)
+              }
+            }
+          }
+        }
+        promise.resolve(resultMap)
+      } catch (e: Exception) {
+        databaseHolder.releaseDatabase()
+        promise.reject(
+          "ERR_UPDATES_FETCH",
+          "Exception in getExtraParamsAsync: ${e.message}, ${e.stackTraceToString()}"
+        )
+      }
     }
   }
 
   @ExpoMethod
   fun setExtraParamAsync(key: String, value: String?, promise: Promise) {
+    logger.debug("Called setExtraParamAsync with key = $key, value = $value")
     val updatesServiceLocal = updatesService
     if (!updatesServiceLocal!!.configuration.isEnabled) {
       promise.reject(
@@ -337,13 +393,22 @@ class UpdatesModule(
 
     AsyncTask.execute {
       val databaseHolder = updatesServiceLocal.databaseHolder
-      ManifestMetadata.setExtraParam(
-        databaseHolder.database,
-        updatesServiceLocal.configuration,
-        key,
-        value
-      )
-      promise.resolve(null)
+      try {
+        ManifestMetadata.setExtraParam(
+          databaseHolder.database,
+          updatesServiceLocal.configuration,
+          key,
+          value
+        )
+        databaseHolder.releaseDatabase()
+        promise.resolve(null)
+      } catch (e: Exception) {
+        databaseHolder.releaseDatabase()
+        promise.reject(
+          "ERR_UPDATES_FETCH",
+          "Exception in setExtraParamAsync: ${e.message}, ${e.stackTraceToString()}"
+        )
+      }
     }
   }