@capawesome/capacitor-live-update 8.6.0 → 8.7.0

package/android/src/main/java/io/capawesome/capacitorjs/plugins/liveupdate/classes/options/FetchLatestBundleOptions.java

@@ -6,17 +6,39 @@ import com.getcapacitor.PluginCall;
 
 public class FetchLatestBundleOptions {
 
+    @Nullable
+    private final String appId;
+
+    @Nullable
+    private final String bundleId;
+
     @Nullable
     private final String channel;
 
     public FetchLatestBundleOptions(@NonNull PluginCall call) {
-        this.channel = call.getString("channel", null);
+        this(null, null, call.getString("channel", null));
     }
 
     public FetchLatestBundleOptions(@Nullable String channel) {
+        this(null, null, channel);
+    }
+
+    public FetchLatestBundleOptions(@Nullable String appId, @Nullable String bundleId, @Nullable String channel) {
+        this.appId = appId;
+        this.bundleId = bundleId;
         this.channel = channel;
     }
 
+    @Nullable
+    public String getAppId() {
+        return appId;
+    }
+
+    @Nullable
+    public String getBundleId() {
+        return bundleId;
+    }
+
     @Nullable
     public String getChannel() {
         return channel;

package/android/src/main/java/io/capawesome/capacitorjs/plugins/liveupdate/classes/results/FetchLatestBundleResult.java

@@ -48,6 +48,36 @@ public class FetchLatestBundleResult implements Result {
         this.signature = signature;
     }
 
+    @Nullable
+    public ArtifactType getArtifactType() {
+        return artifactType;
+    }
+
+    @Nullable
+    public String getBundleId() {
+        return bundleId;
+    }
+
+    @Nullable
+    public String getChecksum() {
+        return checksum;
+    }
+
+    @Nullable
+    public JSONObject getCustomProperties() {
+        return customProperties;
+    }
+
+    @Nullable
+    public String getDownloadUrl() {
+        return downloadUrl;
+    }
+
+    @Nullable
+    public String getSignature() {
+        return signature;
+    }
+
     @NonNull
     public JSObject toJSObject() {
         JSObject result = new JSObject();

package/android/src/main/java/io/capawesome/capacitorjs/plugins/liveupdate/providers/ionic/LiveUpdateIonicManager.kt

@@ -0,0 +1,229 @@
+package io.capawesome.capacitorjs.plugins.liveupdate.providers.ionic
+
+import android.content.Context
+import com.getcapacitor.Logger
+import io.capawesome.capacitorjs.plugins.liveupdate.LiveUpdate
+import io.capawesome.capacitorjs.plugins.liveupdate.LiveUpdateConfig
+import io.capawesome.capacitorjs.plugins.liveupdate.LiveUpdatePlugin
+import io.capawesome.capacitorjs.plugins.liveupdate.classes.options.DownloadBundleOptions
+import io.capawesome.capacitorjs.plugins.liveupdate.classes.options.FetchLatestBundleOptions
+import io.capawesome.capacitorjs.plugins.liveupdate.classes.results.FetchLatestBundleResult
+import io.capawesome.capacitorjs.plugins.liveupdate.enums.ArtifactType
+import io.capawesome.capacitorjs.plugins.liveupdate.interfaces.EmptyCallback
+import io.capawesome.capacitorjs.plugins.liveupdate.interfaces.NonEmptyCallback
+import io.ionic.liveupdateprovider.MetadataSyncResult
+import io.ionic.liveupdateprovider.ProviderError
+import io.ionic.liveupdateprovider.ProviderManager
+import io.ionic.liveupdateprovider.ProviderSyncResult
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.async
+import org.json.JSONObject
+
+/**
+ * Ionic Live Update Provider manager backed by the Capawesome live update plugin.
+ *
+ * Each manager persists its active bundle scoped by its resolved app ID and channel, so that
+ * multiple shells (Portals or Federated Capacitor apps) do not collide with each other or with
+ * the standalone plugin's `currentBundleId` / `nextBundleId` state.
+ *
+ * Provider configuration keys (V1):
+ * - `appId` (optional) — Capawesome Cloud app UUID; falls back to plugin config, required in either
+ * - `channel` (optional) — channel to sync; falls back to plugin config
+ * - `publicKey`, `serverDomain`, `httpTimeout` (optional) — same as the plugin config; only
+ *   applied by the headless constructor, otherwise the running plugin's config is used
+ */
+class LiveUpdateIonicManager
+@Throws(ProviderError.InvalidConfiguration::class)
+constructor(context: Context, configuration: Map<String, *>, private val liveUpdate: LiveUpdate) : ProviderManager {
+
+    /**
+     * Creates a manager without a running Capacitor plugin, e.g. for Ionic Portals hosts
+     * that construct the manager directly and attach it to a Portal via
+     * `setLiveUpdateProviderManager(...)`. Uses a headless [LiveUpdate] instance configured
+     * via the configuration map.
+     */
+    @Throws(ProviderError.InvalidConfiguration::class)
+    constructor(
+        context: Context,
+        configuration: Map<String, *>
+    ) : this(context, configuration, LiveUpdate(createLiveUpdateConfig(configuration), context.applicationContext))
+
+    companion object {
+        /**
+         * Downloads in flight per bundle ID, shared by all managers, so that concurrent syncs
+         * download the same bundle only once.
+         */
+        private val bundleDownloads = ConcurrentHashMap<String, Deferred<Unit>>()
+        private val bundleDownloadScope = CoroutineScope(SupervisorJob())
+
+        @Throws(ProviderError.InvalidConfiguration::class)
+        private fun createLiveUpdateConfig(configuration: Map<String, *>): LiveUpdateConfig {
+            val config = LiveUpdateConfig()
+            getOptionalValue<String>(configuration, "publicKey")?.let { config.publicKey = it }
+            getOptionalValue<String>(configuration, "serverDomain")?.let { config.serverDomain = it }
+            getOptionalValue<Number>(configuration, "httpTimeout")?.let { config.httpTimeout = it.toInt() }
+            return config
+        }
+
+        @Throws(ProviderError.InvalidConfiguration::class)
+        private inline fun <reified T> getOptionalValue(configuration: Map<String, *>, key: String): T? {
+            val value = configuration[key] ?: return null
+            return value as? T ?: throw ProviderError.InvalidConfiguration("$key has an invalid type.")
+        }
+    }
+
+    override var latestAppDirectory: File? = null
+        private set
+
+    private val appId: String
+    private val channel: String?
+    private val preferences: LiveUpdateIonicPreferences
+    private val versionCode: String = liveUpdate.versionCodeAsString
+    private var syncedBundleId: String? = null
+
+    init {
+        val resolvedAppId = configuration["appId"] as? String ?: liveUpdate.appId
+        if (resolvedAppId.isNullOrEmpty()) {
+            throw ProviderError.InvalidConfiguration(LiveUpdatePlugin.ERROR_APP_ID_MISSING)
+        }
+        appId = resolvedAppId
+        channel = configuration["channel"] as? String ?: liveUpdate.channel
+        val stateKey = if (channel.isNullOrEmpty()) appId else "$appId.$channel"
+        val sharedPreferences =
+            context.applicationContext.getSharedPreferences(LiveUpdateIonicPreferences.SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
+        preferences = LiveUpdateIonicPreferences(sharedPreferences, stateKey)
+        preferences.resetLastSyncedBundleIdIfVersionChanged(versionCode)
+        restoreSyncedBundle()
+        deleteSupersededBundles()
+    }
+
+    override suspend fun sync(): ProviderSyncResult? {
+        try {
+            val result = fetchLatestBundle()
+
+            // No update available; nothing to report.
+            val bundleId = result.bundleId
+            if (bundleId == null || bundleId == syncedBundleId) {
+                return null
+            }
+
+            // Use the bundle on disk, or download it (or wait for a running download of the same bundle).
+            val directory = liveUpdate.getBundleDirectory(bundleId) ?: run {
+                downloadBundleOnce(bundleId, result)
+                liveUpdate.getBundleDirectory(bundleId) ?: throw Exception(LiveUpdatePlugin.ERROR_BUNDLE_DIRECTORY_NOT_FOUND)
+            }
+            applySyncedBundle(bundleId, directory)
+            return MetadataSyncResult(buildMetadata(bundleId, result.customProperties))
+        } catch (exception: Exception) {
+            Logger.error(LiveUpdatePlugin.TAG, "Ionic provider sync failed: ${exception.message}", exception)
+            throw exception
+        }
+    }
+
+    private fun applySyncedBundle(bundleId: String, directory: File) {
+        syncedBundleId = bundleId
+        latestAppDirectory = directory
+        preferences.setLastSyncedBundleId(bundleId, versionCode)
+    }
+
+    private fun buildMetadata(bundleId: String, customProperties: JSONObject?): Map<String, Any> {
+        val metadata = mutableMapOf<String, Any>("bundleId" to bundleId)
+        channel?.let { metadata["channel"] = it }
+        customProperties?.let {
+            val customPropertiesMap = jsonObjectToMap(it)
+            if (customPropertiesMap.isNotEmpty()) {
+                metadata["customProperties"] = customPropertiesMap
+            }
+        }
+        return metadata
+    }
+
+    /**
+     * Deletes the bundles this manager no longer points at, unless another manager or the
+     * plugin still uses them. Never runs right after a sync, because a visible portal may
+     * still serve the previous bundle.
+     */
+    private fun deleteSupersededBundles() {
+        val supersededBundleIds = preferences.getSupersededBundleIds()
+        if (supersededBundleIds.isEmpty()) {
+            return
+        }
+        val referencedBundleIds = preferences.getLastSyncedBundleIdsOfAllManagers()
+        val deletedBundleIds = supersededBundleIds
+            .filter { it !in referencedBundleIds && liveUpdate.tryDeleteUnusedBundle(it) }
+            .toSet()
+        preferences.removeSupersededBundleIds(deletedBundleIds)
+    }
+
+    private suspend fun downloadBundle(bundleId: String, result: FetchLatestBundleResult) {
+        val downloadUrl = result.downloadUrl
+        if (downloadUrl.isNullOrEmpty()) {
+            throw Exception(LiveUpdatePlugin.ERROR_DOWNLOAD_URL_MISSING)
+        }
+        val artifactType = result.artifactType ?: ArtifactType.ZIP
+        val options = DownloadBundleOptions(artifactType, bundleId, result.checksum, result.signature, downloadUrl)
+        suspendCoroutine { continuation ->
+            liveUpdate.downloadBundle(
+                options,
+                object : EmptyCallback {
+                    override fun success() = continuation.resume(Unit)
+
+                    override fun error(exception: Exception) = continuation.resumeWithException(exception)
+                }
+            )
+        }
+    }
+
+    private suspend fun downloadBundleOnce(bundleId: String, result: FetchLatestBundleResult) {
+        val download = bundleDownloads.computeIfAbsent(bundleId) {
+            bundleDownloadScope.async { downloadBundle(bundleId, result) }
+        }
+        try {
+            download.await()
+        } finally {
+            bundleDownloads.remove(bundleId, download)
+        }
+    }
+
+    private suspend fun fetchLatestBundle(): FetchLatestBundleResult = suspendCoroutine { continuation ->
+        liveUpdate.fetchLatestBundle(
+            FetchLatestBundleOptions(appId, syncedBundleId, channel),
+            object : NonEmptyCallback<FetchLatestBundleResult> {
+                override fun success(result: FetchLatestBundleResult) = continuation.resume(result)
+
+                override fun error(exception: Exception) = continuation.resumeWithException(exception)
+            }
+        )
+    }
+
+    private fun jsonObjectToMap(jsonObject: JSONObject): Map<String, Any> {
+        val map = mutableMapOf<String, Any>()
+        val keys = jsonObject.keys()
+        while (keys.hasNext()) {
+            val key = keys.next()
+            val value = jsonObject.opt(key)
+            if (value != null && value != JSONObject.NULL) {
+                map[key] = value
+            }
+        }
+        return map
+    }
+
+    /**
+     * Restores the last synced bundle, if it is still on disk, so the host can load it offline
+     * and the next sync reports it as the bundle in use.
+     */
+    private fun restoreSyncedBundle() {
+        val bundleId = preferences.getLastSyncedBundleId() ?: return
+        val directory = liveUpdate.getBundleDirectory(bundleId) ?: return
+        syncedBundleId = bundleId
+        latestAppDirectory = directory
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/liveupdate/providers/ionic/LiveUpdateIonicPreferences.kt

@@ -0,0 +1,85 @@
+package io.capawesome.capacitorjs.plugins.liveupdate.providers.ionic
+
+import android.content.SharedPreferences
+
+/**
+ * Persisted state of one provider manager, scoped by its state key (`<appId>` or `<appId>.<channel>`).
+ *
+ * All managers share the same [SharedPreferences] file, so a manager can see which bundles
+ * the other managers still point at.
+ */
+class LiveUpdateIonicPreferences(private val sharedPreferences: SharedPreferences, stateKey: String) {
+
+    companion object {
+        const val SHARED_PREFERENCES_NAME = "CapawesomeLiveUpdateIonicProvider"
+        private const val LAST_SYNCED_BUNDLE_ID_PREFIX = "lastSyncedBundleId."
+        private const val LAST_VERSION_CODE_PREFIX = "lastVersionCode."
+        private const val SUPERSEDED_BUNDLE_IDS_PREFIX = "supersededBundleIds."
+    }
+
+    private val lastSyncedBundleIdKey = LAST_SYNCED_BUNDLE_ID_PREFIX + stateKey
+    private val lastVersionCodeKey = LAST_VERSION_CODE_PREFIX + stateKey
+    private val supersededBundleIdsKey = SUPERSEDED_BUNDLE_IDS_PREFIX + stateKey
+
+    fun getLastSyncedBundleId(): String? = sharedPreferences.getString(lastSyncedBundleIdKey, null)
+
+    /**
+     * @return The last synced bundle IDs of all managers.
+     */
+    fun getLastSyncedBundleIdsOfAllManagers(): Set<String> = sharedPreferences.all
+        .filterKeys { it.startsWith(LAST_SYNCED_BUNDLE_ID_PREFIX) }
+        .values
+        .filterIsInstance<String>()
+        .toSet()
+
+    /**
+     * @return The bundles this manager no longer points at and that may be deleted once unused.
+     */
+    fun getSupersededBundleIds(): Set<String> = sharedPreferences.getStringSet(supersededBundleIdsKey, null)?.toSet() ?: emptySet()
+
+    fun removeSupersededBundleIds(bundleIds: Set<String>) {
+        if (bundleIds.isEmpty()) {
+            return
+        }
+        val remainingBundleIds = getSupersededBundleIds() - bundleIds
+        val editor = sharedPreferences.edit()
+        if (remainingBundleIds.isEmpty()) {
+            editor.remove(supersededBundleIdsKey)
+        } else {
+            editor.putStringSet(supersededBundleIdsKey, remainingBundleIds)
+        }
+        editor.apply()
+    }
+
+    /**
+     * Forgets the last synced bundle if it was synced on another app version code,
+     * because the bundle was built for that native version.
+     */
+    fun resetLastSyncedBundleIdIfVersionChanged(versionCode: String) {
+        val lastSyncedBundleId = getLastSyncedBundleId() ?: return
+        val lastVersionCode = sharedPreferences.getString(lastVersionCodeKey, null) ?: return
+        if (lastVersionCode == versionCode) {
+            return
+        }
+        sharedPreferences.edit()
+            .putStringSet(supersededBundleIdsKey, getSupersededBundleIds() + lastSyncedBundleId)
+            .remove(lastSyncedBundleIdKey)
+            .remove(lastVersionCodeKey)
+            .apply()
+    }
+
+    /**
+     * Points this manager at the given bundle, synced on the given app version code,
+     * and records the previous bundle as superseded.
+     */
+    fun setLastSyncedBundleId(bundleId: String, versionCode: String) {
+        val editor = sharedPreferences.edit()
+        val previousBundleId = getLastSyncedBundleId()
+        if (previousBundleId != null && previousBundleId != bundleId) {
+            editor.putStringSet(supersededBundleIdsKey, getSupersededBundleIds() + previousBundleId)
+        }
+        editor.putString(lastSyncedBundleIdKey, bundleId)
+            .putString(lastVersionCodeKey, versionCode)
+            .apply()
+    }
+}

package/ios/Plugin/Classes/Options/DownloadBundleOptions.swift

@@ -8,12 +8,13 @@ import Capacitor
     private var signature: String?
     private var url: String
 
-    init(artifactType: String, bundleId: String, checksum: String?, signature: String?, url: String) {
-        if artifactType == "manifest" {
-            self.artifactType = .manifest
-        } else {
-            self.artifactType = .zip
-        }
+    convenience init(artifactType: String, bundleId: String, checksum: String?, signature: String?, url: String) {
+        let artifactType: ArtifactType = artifactType == "manifest" ? .manifest : .zip
+        self.init(artifactType: artifactType, bundleId: bundleId, checksum: checksum, signature: signature, url: url)
+    }
+
+    init(artifactType: ArtifactType, bundleId: String, checksum: String?, signature: String?, url: String) {
+        self.artifactType = artifactType
         self.bundleId = bundleId
         self.checksum = checksum
         self.signature = signature

package/ios/Plugin/Classes/Options/FetchLatestBundleOptions.swift

@@ -2,16 +2,32 @@ import Foundation
 import Capacitor
 
 @objc public class FetchLatestBundleOptions: NSObject {
+    private var appId: String?
+    private var bundleId: String?
     private var channel: String?
 
-    init(_ call: CAPPluginCall) {
-        self.channel = call.getString("channel")
+    convenience init(_ call: CAPPluginCall) {
+        self.init(appId: nil, bundleId: nil, channel: call.getString("channel"))
     }
 
-    init(channel: String?) {
+    convenience init(channel: String?) {
+        self.init(appId: nil, bundleId: nil, channel: channel)
+    }
+
+    init(appId: String?, bundleId: String?, channel: String?) {
+        self.appId = appId
+        self.bundleId = bundleId
         self.channel = channel
     }
 
+    func getAppId() -> String? {
+        return appId
+    }
+
+    func getBundleId() -> String? {
+        return bundleId
+    }
+
     func getChannel() -> String? {
         return channel
     }

package/ios/Plugin/Classes/Results/FetchLatestBundleResult.swift

@@ -20,6 +20,30 @@ import Capacitor
         self.signature = signature
     }
 
+    func getArtifactType() -> ArtifactType? {
+        return artifactType
+    }
+
+    public func getBundleId() -> String? {
+        return bundleId
+    }
+
+    public func getChecksum() -> String? {
+        return checksum
+    }
+
+    public func getCustomProperties() -> [String: Any]? {
+        return customProperties
+    }
+
+    public func getDownloadUrl() -> String? {
+        return downloadUrl
+    }
+
+    public func getSignature() -> String? {
+        return signature
+    }
+
     public func toJSObject() -> AnyObject {
         var result = JSObject()
         if artifactType == .manifest {

package/ios/Plugin/Enums/CustomError.swift

@@ -3,6 +3,7 @@ import Foundation
 public enum CustomError: Error {
     case appIdMissing
     case bundleAlreadyExists
+    case bundleDirectoryNotFound
     case bundleIdMissing
     case bundleIndexHtmlMissing
     case bundleNotFound
@@ -10,9 +11,12 @@ public enum CustomError: Error {
     case channelMissing
     case checksumCalculationFailed
     case checksumMismatch
+    case configurationValueInvalid(key: String)
     case customIdMissing
     case downloadFailed
+    case downloadUrlMissing
     case httpTimeout
+    case pluginNotInitialized
     case signatureMissing
     case signatureVerificationFailed
     case syncInProgress
@@ -27,6 +31,8 @@ extension CustomError: LocalizedError {
             return NSLocalizedString("appId must be configured.", comment: "appIdMissing")
         case .bundleAlreadyExists:
             return NSLocalizedString("bundle already exists.", comment: "bundleAlreadyExists")
+        case .bundleDirectoryNotFound:
+            return NSLocalizedString("Bundle directory could not be resolved.", comment: "bundleDirectoryNotFound")
         case .bundleIdMissing:
             return NSLocalizedString("bundleId must be provided.", comment: "bundleIdMissing")
         case .bundleIndexHtmlMissing:
@@ -41,12 +47,19 @@ extension CustomError: LocalizedError {
             return NSLocalizedString("Failed to calculate checksum.", comment: "checksumCalculationFailed")
         case .checksumMismatch:
             return NSLocalizedString("Checksum mismatch.", comment: "checksumMismatch")
+        case .configurationValueInvalid(let key):
+            let format = NSLocalizedString("%@ has an invalid type.", comment: "configurationValueInvalid")
+            return String(format: format, key)
         case .customIdMissing:
             return NSLocalizedString("customId must be provided.", comment: "customIdMissing")
         case .downloadFailed:
             return NSLocalizedString("Bundle could not be downloaded.", comment: "downloadFailed")
+        case .downloadUrlMissing:
+            return NSLocalizedString("Bundle does not have a valid download URL.", comment: "downloadUrlMissing")
         case .httpTimeout:
             return NSLocalizedString("Request timed out.", comment: "httpTimeout")
+        case .pluginNotInitialized:
+            return NSLocalizedString("Plugin is not initialized.", comment: "pluginNotInitialized")
         case .signatureMissing:
             return NSLocalizedString("Bundle does not contain a signature.", comment: "signatureMissing")
         case .signatureVerificationFailed: