expo-updates 0.10.15 → 0.11.0

package/CHANGELOG.md

@@ -10,39 +10,43 @@
 
 ### 💡 Others
 
-## 0.10.15 — 2021-11-11
+## 0.11.0 — 2021-12-03
 
-### 🐛 Bug fixes
-
-- Fix iOS auto-layout breaking for RCTRootView. on a iPad simulator, the view is not updated after rotation. ([#15100](https://github.com/expo/expo/pull/15100) by [@kudo](https://github.com/kudo))
-
-## 0.10.14 — 2021-11-09
-
-### 🐛 Bug fixes
-
-- Retain embedded asset fields when merging existing asset entities on Android. ([#15123](https://github.com/expo/expo/pull/15123) by [@esamelson](https://github.com/esamelson))
-
-## 0.10.13 — 2021-11-05
-
-### 🐛 Bug fixes
-
-- Fix issue with assets that are duplicated in the local SQLite db being reaped when they are still in use. ([#15049](https://github.com/expo/expo/pull/15049) by [@esamelson](https://github.com/esamelson))
-
-## 0.10.12 — 2021-11-04
+### 🛠 Breaking changes
 
-### 🐛 Bug fixes
+- Add local SQLite fields for error recovery manager on iOS. ([#14610](https://github.com/expo/expo/pull/14610) by [@esamelson](https://github.com/esamelson))
+- Add DB migration for above. ([#14718](https://github.com/expo/expo/pull/14718) by [@esamelson](https://github.com/esamelson))
+- Add local SQLite fields and DB migration for error recovery manager on Android. ([#15218](https://github.com/expo/expo/pull/15218) by [@esamelson](https://github.com/esamelson))
+- Add DEFAULT 0 to new error recovery DB columns. ([#15360](https://github.com/expo/expo/pull/15360) by [@esamelson](https://github.com/esamelson))
 
-- Workaround for bridge being initialized twice on startup. ([#15019](https://github.com/expo/expo/pull/15019) by [@kudo](https://github.com/kudo))
+### 🎉 New features
 
-## 0.10.11 — 2021-11-02
+- Add error recovery manager on iOS. ([#14397](https://github.com/expo/expo/pull/14397) by [@esamelson](https://github.com/esamelson))
+- Hook up error recovery manager to rest of module on iOS. ([#14398](https://github.com/expo/expo/pull/14398) by [@esamelson](https://github.com/esamelson))
+- Move persisted error log to EXUpdatesErrorRecovery on iOS. ([#14399](https://github.com/expo/expo/pull/14399) by [@esamelson](https://github.com/esamelson))
+- Add native EXUpdatesCheckOnLaunch: ERROR_RECOVERY_ONLY setting on iOS. ([#14673](https://github.com/expo/expo/pull/14673) by [@esamelson](https://github.com/esamelson))
+- Small fixes for error recovery manager on iOS. ([#15223](https://github.com/expo/expo/pull/15223) by [@esamelson](https://github.com/esamelson))
+- Add native checkOnLaunch: ERROR_RECOVERY_ONLY setting on Android. ([#15219](https://github.com/expo/expo/pull/15219) by [@esamelson](https://github.com/esamelson))
+- Enhance node binary resolution for Xcode build phases scripts by the vendoring source-login-scripts.sh. ([#15336](https://github.com/expo/expo/pull/15336) by [@kudo](https://github.com/kudo))
 
 ### 🐛 Bug fixes
 
+- Fix auto setup `EXUpdatesAppDelegate` breaking reanimated installation. ([#14755](https://github.com/expo/expo/pull/14755) by [@kudo](https://github.com/kudo))
+- Fix support for `react.entryFile` gradle config. ([#14934](https://github.com/expo/expo/pull/14934) by [@EvanBacon](https://github.com/EvanBacon))
+- Fix Android app.manifest not generated when in OneSignal gradle plugin integration. ([#14938](https://github.com/expo/expo/pull/14938) by [@kudo](https://github.com/kudo))
+- Fix Android app.manifest not generated from [#14938](https://github.com/expo/expo/pull/14938) regression. ([#14953](https://github.com/expo/expo/pull/14953) by [@kudo](https://github.com/kudo))
+- Fix iOS app.manifest generation error in `eas build --local` mode. ([#14956](https://github.com/expo/expo/pull/14956) by [@kudo](https://github.com/kudo))
 - Fix handling of unexpectedly missing assets on iOS. ([#15008](https://github.com/expo/expo/pull/15008) by [@esamelson](https://github.com/esamelson))
+- Fix issue with assets that are duplicated in the local SQLite db being reaped when they are still in use. ([#15049](https://github.com/expo/expo/pull/15049) by [@esamelson](https://github.com/esamelson))
+- Retain embedded asset fields when merging existing asset entities on Android. ([#15123](https://github.com/expo/expo/pull/15123) by [@esamelson](https://github.com/esamelson))
+- Fix `RCTBridge` initialized twice on startup. ([#15142](https://github.com/expo/expo/pull/15142) by [@kudo](https://github.com/kudo))
 
-## 0.10.10 — 2021-11-02
+### 💡 Others
 
-_This version does not introduce any user-facing changes._
+- Add error when entryfile is not found in expo-updates scripts. ([#15234](https://github.com/expo/expo/pull/15234) by [@AamuLumi](https://github.com/AamuLumi))
+- Update `@expo/config` and `@expo/metro-config` dependencies. ([#14801](https://github.com/expo/expo/pull/14801) by [@Simek](https://github.com/Simek))
+- Refactor and unify Loader classes on Android. ([#14334](https://github.com/expo/expo/pull/14334) by [@esamelson](https://github.com/esamelson))
+- Kotlinize expo-updates. ([#14818](https://github.com/expo/expo/pull/14334) by [@wschurman](https://github.com/wschurman))
 
 ## 0.10.9 — 2021-10-29
 

package/android/build.gradle

@@ -1,9 +1,10 @@
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
 apply plugin: 'maven'
 
 group = 'host.exp.exponent'
-version = '0.10.15'
+version = '0.11.0'
 
 apply from: "../scripts/create-manifest-android.gradle"
 
@@ -55,11 +56,15 @@ android {
     targetCompatibility JavaVersion.VERSION_1_8
   }
 
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_1_8
+  }
+
   defaultConfig {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 30)
     versionCode 31
-    versionName '0.10.15'
+    versionName '0.11.0'
     consumerProguardFiles("proguard-rules.pro")
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     // uncomment below to export the database schema when making changes
@@ -90,10 +95,10 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
-  def room_version = "2.1.0"
+  def room_version = "2.3.0"
 
   implementation "androidx.room:room-runtime:$room_version"
-  annotationProcessor "androidx.room:room-compiler:$room_version"
+  kapt "androidx.room:room-compiler:$room_version"
 
   implementation("com.squareup.okhttp3:okhttp:3.12.1")
   implementation("com.squareup.okhttp3:okhttp-urlconnection:3.12.1")

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

@@ -0,0 +1,195 @@
+package expo.modules.updates
+
+import android.content.Context
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.util.Log
+
+class UpdatesConfiguration {
+  enum class CheckAutomaticallyConfiguration {
+    NEVER, ERROR_RECOVERY_ONLY, WIFI_ONLY, ALWAYS
+  }
+
+  var isEnabled = false
+    private set
+  var expectsSignedManifest = false
+    private set
+  var scopeKey: String? = null
+    private set
+  var updateUrl: Uri? = null
+    private set
+  var sdkVersion: String? = null
+    private set
+  var runtimeVersion: String? = null
+    private set
+  var releaseChannel = UPDATES_CONFIGURATION_RELEASE_CHANNEL_DEFAULT_VALUE
+    private set
+  var launchWaitMs = UPDATES_CONFIGURATION_LAUNCH_WAIT_MS_DEFAULT_VALUE
+    private set
+  var checkOnLaunch = CheckAutomaticallyConfiguration.ALWAYS
+    private set
+  var hasEmbeddedUpdate = true
+  var requestHeaders = mapOf<String, String>()
+    private set
+
+  val isMissingRuntimeVersion: Boolean
+    get() = (runtimeVersion == null || runtimeVersion!!.isEmpty()) &&
+      (sdkVersion == null || sdkVersion!!.isEmpty())
+
+  fun loadValuesFromMetadata(context: Context): UpdatesConfiguration {
+    try {
+      val ai = context.packageManager.getApplicationInfo(context.packageName, PackageManager.GET_META_DATA)
+      updateUrl = ai.metaData.getString("expo.modules.updates.EXPO_UPDATE_URL")?.let { Uri.parse(it) }
+      scopeKey = ai.metaData.getString("expo.modules.updates.EXPO_SCOPE_KEY")
+      maybeSetDefaultScopeKey()
+      isEnabled = ai.metaData.getBoolean("expo.modules.updates.ENABLED", true)
+      sdkVersion = ai.metaData.getString("expo.modules.updates.EXPO_SDK_VERSION")
+      releaseChannel = ai.metaData.getString("expo.modules.updates.EXPO_RELEASE_CHANNEL", "default")
+      launchWaitMs = ai.metaData.getInt("expo.modules.updates.EXPO_UPDATES_LAUNCH_WAIT_MS", 0)
+      runtimeVersion = ai.metaData["expo.modules.updates.EXPO_RUNTIME_VERSION"]?.toString()?.replaceFirst("^string:".toRegex(), "")
+
+      val checkOnLaunchString = ai.metaData.getString("expo.modules.updates.EXPO_UPDATES_CHECK_ON_LAUNCH", "ALWAYS")
+      checkOnLaunch = try {
+        CheckAutomaticallyConfiguration.valueOf(checkOnLaunchString)
+      } catch (e: IllegalArgumentException) {
+        Log.e(
+          TAG,
+          "Invalid value $checkOnLaunchString for expo.modules.updates.EXPO_UPDATES_CHECK_ON_LAUNCH in AndroidManifest; defaulting to ALWAYS"
+        )
+        CheckAutomaticallyConfiguration.ALWAYS
+      }
+
+      requestHeaders = UpdatesUtils.getHeadersMapFromJSONString(
+        ai.metaData.getString(
+          "expo.modules.updates.UPDATES_CONFIGURATION_REQUEST_HEADERS_KEY",
+          "{}"
+        )
+      )
+
+      // used only for expo-updates development
+      hasEmbeddedUpdate = ai.metaData.getBoolean("expo.modules.updates.HAS_EMBEDDED_UPDATE", true)
+    } catch (e: Exception) {
+      Log.e(TAG, "Could not read expo-updates configuration data in AndroidManifest", e)
+    }
+    return this
+  }
+
+  fun loadValuesFromMap(map: Map<String, Any>): UpdatesConfiguration {
+    val isEnabledFromMap = map.readValueCheckingType<Boolean>(UPDATES_CONFIGURATION_ENABLED_KEY)
+    if (isEnabledFromMap != null) {
+      isEnabled = isEnabledFromMap
+    }
+
+    expectsSignedManifest = map.readValueCheckingType("expectsSignedManifest") ?: false
+
+    val updateUrlFromMap = map.readValueCheckingType<Uri>(UPDATES_CONFIGURATION_UPDATE_URL_KEY)
+    if (updateUrlFromMap != null) {
+      updateUrl = updateUrlFromMap
+    }
+
+    val scopeKeyFromMap = map.readValueCheckingType<String>(UPDATES_CONFIGURATION_SCOPE_KEY_KEY)
+    if (scopeKeyFromMap != null) {
+      scopeKey = scopeKeyFromMap
+    }
+    maybeSetDefaultScopeKey()
+
+    val requestHeadersFromMap = map.readValueCheckingType<Map<String, String>>(UPDATES_CONFIGURATION_REQUEST_HEADERS_KEY)
+    if (requestHeadersFromMap != null) {
+      requestHeaders = requestHeadersFromMap
+    }
+
+    val releaseChannelFromMap = map.readValueCheckingType<String>(UPDATES_CONFIGURATION_RELEASE_CHANNEL_KEY)
+    if (releaseChannelFromMap != null) {
+      releaseChannel = releaseChannelFromMap
+    }
+
+    val sdkVersionFromMap = map.readValueCheckingType<String>(UPDATES_CONFIGURATION_SDK_VERSION_KEY)
+    if (sdkVersionFromMap != null) {
+      sdkVersion = sdkVersionFromMap
+    }
+
+    val runtimeVersionFromMap = map.readValueCheckingType<String>(UPDATES_CONFIGURATION_RUNTIME_VERSION_KEY)
+    if (runtimeVersionFromMap != null) {
+      runtimeVersion = runtimeVersionFromMap
+    }
+
+    val checkOnLaunchFromMap = map.readValueCheckingType<String>(UPDATES_CONFIGURATION_CHECK_ON_LAUNCH_KEY)
+    if (checkOnLaunchFromMap != null) {
+      try {
+        checkOnLaunch = CheckAutomaticallyConfiguration.valueOf(checkOnLaunchFromMap)
+      } catch (e: IllegalArgumentException) {
+        throw AssertionError("UpdatesConfiguration failed to initialize: invalid value $checkOnLaunchFromMap provided for checkOnLaunch")
+      }
+    }
+
+    val launchWaitMsFromMap = map.readValueCheckingType<Int>(UPDATES_CONFIGURATION_LAUNCH_WAIT_MS_KEY)
+    if (launchWaitMsFromMap != null) {
+      launchWaitMs = launchWaitMsFromMap
+    }
+
+    val hasEmbeddedUpdateFromMap = map.readValueCheckingType<Boolean>(UPDATES_CONFIGURATION_HAS_EMBEDDED_UPDATE_KEY)
+    if (hasEmbeddedUpdateFromMap != null) {
+      hasEmbeddedUpdate = hasEmbeddedUpdateFromMap
+    }
+
+    return this
+  }
+
+  private inline fun <reified T : Any> Map<String, Any>.readValueCheckingType(key: String): T? {
+    if (!containsKey(key)) {
+      return null
+    }
+    val value = this[key]
+    return if (value is T) {
+      value
+    } else {
+      throw AssertionError("UpdatesConfiguration failed to initialize: bad value of type " + value!!.javaClass.simpleName + " provided for key " + key)
+    }
+  }
+
+  private fun maybeSetDefaultScopeKey() {
+    // set updateUrl as the default value if none is provided
+    if (scopeKey == null) {
+      if (updateUrl != null) {
+        scopeKey = getNormalizedUrlOrigin(updateUrl!!)
+      }
+    }
+  }
+
+  companion object {
+    private val TAG = UpdatesConfiguration::class.java.simpleName
+
+    const val UPDATES_CONFIGURATION_ENABLED_KEY = "enabled"
+    const val UPDATES_CONFIGURATION_SCOPE_KEY_KEY = "scopeKey"
+    const val UPDATES_CONFIGURATION_UPDATE_URL_KEY = "updateUrl"
+    const val UPDATES_CONFIGURATION_REQUEST_HEADERS_KEY = "requestHeaders"
+    const val UPDATES_CONFIGURATION_RELEASE_CHANNEL_KEY = "releaseChannel"
+    const val UPDATES_CONFIGURATION_SDK_VERSION_KEY = "sdkVersion"
+    const val UPDATES_CONFIGURATION_RUNTIME_VERSION_KEY = "runtimeVersion"
+    const val UPDATES_CONFIGURATION_CHECK_ON_LAUNCH_KEY = "checkOnLaunch"
+    const val UPDATES_CONFIGURATION_LAUNCH_WAIT_MS_KEY = "launchWaitMs"
+    const val UPDATES_CONFIGURATION_HAS_EMBEDDED_UPDATE_KEY = "hasEmbeddedUpdate"
+    private const val UPDATES_CONFIGURATION_RELEASE_CHANNEL_DEFAULT_VALUE = "default"
+    private const val UPDATES_CONFIGURATION_LAUNCH_WAIT_MS_DEFAULT_VALUE = 0
+
+    internal fun getNormalizedUrlOrigin(url: Uri): String {
+      val scheme = url.scheme
+      var port = url.port
+      if (port == getDefaultPortForScheme(scheme)) {
+        port = -1
+      }
+      return if (port > -1) "$scheme://${url.host}:$port" else "$scheme://${url.host}"
+    }
+
+    private fun getDefaultPortForScheme(scheme: String?): Int {
+      if ("http" == scheme || "ws" == scheme) {
+        return 80
+      } else if ("https" == scheme || "wss" == scheme) {
+        return 443
+      } else if ("ftp" == scheme) {
+        return 21
+      }
+      return -1
+    }
+  }
+}

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

@@ -0,0 +1,367 @@
+package expo.modules.updates
+
+import android.content.Context
+import android.net.Uri
+import android.os.AsyncTask
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.JSBundleLoader
+import expo.modules.updates.db.BuildData
+import expo.modules.updates.db.DatabaseHolder
+import expo.modules.updates.db.Reaper
+import expo.modules.updates.db.UpdatesDatabase
+import expo.modules.updates.db.entity.AssetEntity
+import expo.modules.updates.db.entity.UpdateEntity
+import expo.modules.updates.launcher.DatabaseLauncher
+import expo.modules.updates.launcher.Launcher
+import expo.modules.updates.launcher.Launcher.LauncherCallback
+import expo.modules.updates.launcher.NoDatabaseLauncher
+import expo.modules.updates.loader.FileDownloader
+import expo.modules.updates.loader.LoaderTask
+import expo.modules.updates.loader.LoaderTask.BackgroundUpdateStatus
+import expo.modules.updates.loader.LoaderTask.LoaderTaskCallback
+import expo.modules.updates.manifest.UpdateManifest
+import expo.modules.updates.selectionpolicy.SelectionPolicy
+import expo.modules.updates.selectionpolicy.SelectionPolicyFactory
+import java.io.File
+import java.lang.ref.WeakReference
+
+class UpdatesController private constructor(
+  context: Context,
+  var updatesConfiguration: UpdatesConfiguration
+) {
+  private var reactNativeHost: WeakReference<ReactNativeHost>? = if (context is ReactApplication) {
+    WeakReference((context as ReactApplication).reactNativeHost)
+  } else {
+    null
+  }
+
+  var updatesDirectory: File? = null
+  var updatesDirectoryException: Exception? = null
+
+  private var launcher: Launcher? = null
+  val databaseHolder = DatabaseHolder(UpdatesDatabase.getInstance(context))
+
+  private var mSelectionPolicy: SelectionPolicy? = null
+  private var defaultSelectionPolicy: SelectionPolicy = SelectionPolicyFactory.createFilterAwarePolicy(
+    UpdatesUtils.getRuntimeVersion(updatesConfiguration)
+  )
+  val fileDownloader: FileDownloader = FileDownloader(context)
+
+  // launch conditions
+  private var isLoaderTaskFinished = false
+  var isEmergencyLaunch = false
+    private set
+
+  /**
+   * If UpdatesController.initialize() is not provided with a [ReactApplication], this method
+   * can be used to set a [ReactNativeHost] on the class. This is optional, but required in
+   * order for `Updates.reload()` and some Updates module events to work.
+   * @param reactNativeHost the ReactNativeHost of the application running the Updates module
+   */
+  fun setReactNativeHost(reactNativeHost: ReactNativeHost) {
+    this.reactNativeHost = WeakReference(reactNativeHost)
+  }
+
+  /**
+   * Returns the path on disk to the launch asset (JS bundle) file for the React Native host to use.
+   * Blocks until the configured timeout runs out, or a new update has been downloaded and is ready
+   * to use (whichever comes sooner). ReactNativeHost.getJSBundleFile() should call into this.
+   *
+   * If this returns null, something has gone wrong and expo-updates has not been able to launch or
+   * find an update to use. In (and only in) this case, `getBundleAssetName()` will return a nonnull
+   * fallback value to use.
+   */
+  @get:Synchronized
+  val launchAssetFile: String?
+    get() {
+      while (!isLoaderTaskFinished) {
+        try {
+          (this as java.lang.Object).wait()
+        } catch (e: InterruptedException) {
+          Log.e(TAG, "Interrupted while waiting for launch asset file", e)
+        }
+      }
+      return launcher?.launchAssetFile
+    }
+
+  /**
+   * Returns the filename of the launch asset (JS bundle) file embedded in the APK bundle, which can
+   * be read using `context.getAssets()`. This is only nonnull if `getLaunchAssetFile` is null and
+   * should only be used in such a situation. ReactNativeHost.getBundleAssetName() should call into
+   * this.
+   */
+  val bundleAssetName: String?
+    get() = launcher?.bundleAssetName
+
+  /**
+   * Returns a map of the locally downloaded assets for the current update. Keys are the remote URLs
+   * of the assets and values are local paths. This should be exported by the Updates JS module and
+   * can be used by `expo-asset` or a similar module to override React Native's asset resolution and
+   * use the locally downloaded assets.
+   */
+  val localAssetFiles: Map<AssetEntity, String>?
+    get() = launcher?.localAssetFiles
+
+  val isUsingEmbeddedAssets: Boolean
+    get() = launcher?.isUsingEmbeddedAssets ?: false
+
+  val database: UpdatesDatabase
+    get() = databaseHolder.database
+
+  fun releaseDatabase() {
+    databaseHolder.releaseDatabase()
+  }
+
+  val updateUrl: Uri?
+    get() = updatesConfiguration.updateUrl
+
+  val launchedUpdate: UpdateEntity?
+    get() = launcher?.launchedUpdate
+
+  val selectionPolicy: SelectionPolicy
+    get() = mSelectionPolicy ?: defaultSelectionPolicy
+
+  // Internal Setters
+
+  /**
+   * For external modules that want to modify the selection policy used at runtime.
+   *
+   * This method does not provide any guarantees about how long the provided selection policy will
+   * persist; sometimes expo-updates will reset the selection policy in situations where it makes
+   * sense to have explicit control (e.g. if the developer/user has programmatically fetched an
+   * update, expo-updates will reset the selection policy so the new update is launched on th
+   * next reload).
+   * @param selectionPolicy The SelectionPolicy to use next, until overridden by expo-updates
+   */
+  fun setNextSelectionPolicy(selectionPolicy: SelectionPolicy?) {
+    mSelectionPolicy = selectionPolicy
+  }
+
+  fun resetSelectionPolicyToDefault() {
+    mSelectionPolicy = null
+  }
+
+  fun setDefaultSelectionPolicy(selectionPolicy: SelectionPolicy) {
+    defaultSelectionPolicy = selectionPolicy
+  }
+
+  fun setLauncher(launcher: Launcher?) {
+    this.launcher = launcher
+  }
+
+  /**
+   * Starts the update process to launch a previously-loaded update and (if configured to do so)
+   * check for a new update from the server. This method should be called as early as possible in
+   * the application's lifecycle.
+   * @param context the base context of the application, ideally a [ReactApplication]
+   */
+  @Synchronized
+  fun start(context: Context) {
+    if (!updatesConfiguration.isEnabled) {
+      launcher = NoDatabaseLauncher(context, updatesConfiguration)
+    }
+    if (updatesConfiguration.updateUrl == null || updatesConfiguration.scopeKey == null) {
+      throw AssertionError("expo-updates is enabled, but no valid URL is configured in AndroidManifest.xml. If you are making a release build for the first time, make sure you have run `expo publish` at least once.")
+    }
+    if (updatesDirectory == null) {
+      launcher = NoDatabaseLauncher(context, updatesConfiguration, updatesDirectoryException)
+      isEmergencyLaunch = true
+    }
+
+    val databaseLocal = database
+    BuildData.ensureBuildDataIsConsistent(updatesConfiguration, databaseLocal)
+    releaseDatabase()
+
+    LoaderTask(
+      updatesConfiguration,
+      databaseHolder,
+      updatesDirectory,
+      fileDownloader,
+      selectionPolicy,
+      object : LoaderTaskCallback {
+        override fun onFailure(e: Exception) {
+          launcher = NoDatabaseLauncher(context, updatesConfiguration, e)
+          isEmergencyLaunch = true
+          notifyController()
+        }
+
+        override fun onCachedUpdateLoaded(update: UpdateEntity): Boolean {
+          return true
+        }
+
+        override fun onRemoteUpdateManifestLoaded(updateManifest: UpdateManifest) {}
+        override fun onSuccess(launcher: Launcher, isUpToDate: Boolean) {
+          this@UpdatesController.launcher = launcher
+          notifyController()
+        }
+
+        override fun onBackgroundUpdateFinished(
+          status: BackgroundUpdateStatus,
+          update: UpdateEntity?,
+          exception: Exception?
+        ) {
+          when (status) {
+            BackgroundUpdateStatus.ERROR -> {
+              if (exception == null) {
+                throw AssertionError("Background update with error status must have a nonnull exception object")
+              }
+              val params = Arguments.createMap()
+              params.putString("message", exception.message)
+              UpdatesUtils.sendEventToReactNative(reactNativeHost, UPDATE_ERROR_EVENT, params)
+            }
+            BackgroundUpdateStatus.UPDATE_AVAILABLE -> {
+              if (update == null) {
+                throw AssertionError("Background update with error status must have a nonnull update object")
+              }
+              val params = Arguments.createMap()
+              params.putString("manifestString", update.manifest.toString())
+              UpdatesUtils.sendEventToReactNative(reactNativeHost, UPDATE_AVAILABLE_EVENT, params)
+            }
+            BackgroundUpdateStatus.NO_UPDATE_AVAILABLE -> {
+              UpdatesUtils.sendEventToReactNative(
+                reactNativeHost,
+                UPDATE_NO_UPDATE_AVAILABLE_EVENT,
+                null
+              )
+            }
+          }
+        }
+      }
+    ).start(context)
+  }
+
+  @Synchronized
+  private fun notifyController() {
+    isLoaderTaskFinished = true
+    (this as java.lang.Object).notify()
+  }
+
+  fun runReaper() {
+    AsyncTask.execute {
+      val databaseLocal = database
+      Reaper.reapUnusedUpdates(
+        updatesConfiguration,
+        databaseLocal,
+        updatesDirectory,
+        launchedUpdate,
+        selectionPolicy
+      )
+      releaseDatabase()
+    }
+  }
+
+  fun relaunchReactApplication(context: Context, callback: LauncherCallback) {
+    val host = reactNativeHost?.get()
+    if (host == null) {
+      callback.onFailure(Exception("Could not reload application. Ensure you have passed the correct instance of ReactApplication into UpdatesController.initialize()."))
+      return
+    }
+
+    val oldLaunchAssetFile = launcher!!.launchAssetFile
+
+    val databaseLocal = database
+    val newLauncher = DatabaseLauncher(
+      updatesConfiguration,
+      updatesDirectory!!,
+      fileDownloader,
+      selectionPolicy
+    )
+    newLauncher.launch(
+      databaseLocal, context,
+      object : LauncherCallback {
+        override fun onFailure(e: Exception) {
+          callback.onFailure(e)
+        }
+
+        override fun onSuccess() {
+          launcher = newLauncher
+          releaseDatabase()
+
+          val instanceManager = host.reactInstanceManager
+
+          val newLaunchAssetFile = launcher!!.launchAssetFile
+          if (newLaunchAssetFile != null && newLaunchAssetFile != oldLaunchAssetFile) {
+            // Unfortunately, even though RN exposes a way to reload an application,
+            // it assumes that the JS bundle will stay at the same location throughout
+            // the entire lifecycle of the app. Since we need to change the location of
+            // the bundle, we need to use reflection to set an otherwise inaccessible
+            // field of the ReactInstanceManager.
+            try {
+              val newJSBundleLoader = JSBundleLoader.createFileLoader(newLaunchAssetFile)
+              val jsBundleLoaderField = instanceManager.javaClass.getDeclaredField("mBundleLoader")
+              jsBundleLoaderField.isAccessible = true
+              jsBundleLoaderField[instanceManager] = newJSBundleLoader
+            } catch (e: Exception) {
+              Log.e(TAG, "Could not reset JSBundleLoader in ReactInstanceManager", e)
+            }
+          }
+          callback.onSuccess()
+          val handler = Handler(Looper.getMainLooper())
+          handler.post { instanceManager.recreateReactContextInBackground() }
+          runReaper()
+        }
+      }
+    )
+  }
+
+  companion object {
+    private val TAG = UpdatesController::class.java.simpleName
+
+    private const val UPDATE_AVAILABLE_EVENT = "updateAvailable"
+    private const val UPDATE_NO_UPDATE_AVAILABLE_EVENT = "noUpdateAvailable"
+    private const val UPDATE_ERROR_EVENT = "error"
+
+    private var singletonInstance: UpdatesController? = null
+    @JvmStatic val instance: UpdatesController
+      get() {
+        return checkNotNull(singletonInstance) { "UpdatesController.instance was called before the module was initialized" }
+      }
+
+    @JvmStatic fun initializeWithoutStarting(context: Context) {
+      if (singletonInstance == null) {
+        val updatesConfiguration = UpdatesConfiguration().loadValuesFromMetadata(context)
+        singletonInstance = UpdatesController(context, updatesConfiguration)
+      }
+    }
+
+    /**
+     * Initializes the UpdatesController singleton. This should be called as early as possible in the
+     * application's lifecycle.
+     * @param context the base context of the application, ideally a [ReactApplication]
+     */
+    @JvmStatic fun initialize(context: Context) {
+      initializeWithoutStarting(context)
+      singletonInstance!!.start(context)
+    }
+
+    /**
+     * Initializes the UpdatesController singleton. This should be called as early as possible in the
+     * application's lifecycle. Use this method to set or override configuration values at runtime
+     * rather than from AndroidManifest.xml.
+     * @param context the base context of the application, ideally a [ReactApplication]
+     */
+    @JvmStatic fun initialize(context: Context, configuration: Map<String, Any>) {
+      if (singletonInstance == null) {
+        val updatesConfiguration = UpdatesConfiguration()
+          .loadValuesFromMetadata(context)
+          .loadValuesFromMap(configuration)
+        singletonInstance = UpdatesController(context, updatesConfiguration)
+        singletonInstance!!.start(context)
+      }
+    }
+  }
+
+  init {
+    try {
+      updatesDirectory = UpdatesUtils.getOrCreateUpdatesDirectory(context)
+    } catch (e: Exception) {
+      updatesDirectoryException = e
+      updatesDirectory = null
+    }
+  }
+}