@hot-updater/react-native 0.36.7 → 1.0.0-rc.0

package/android/src/main/java/com/hotupdater/ReleaseCatalogCacheService.kt

@@ -0,0 +1,166 @@
+package com.hotupdater
+
+import android.util.AtomicFile
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.charset.StandardCharsets
+import java.security.MessageDigest
+
+internal class ReleaseCatalogCacheService(
+    private val rootDirectory: File,
+    private val maxEntries: Int = DEFAULT_MAX_ENTRIES,
+    private val maxEntryBytes: Int = DEFAULT_MAX_ENTRY_BYTES,
+    private val maxTotalBytes: Long = DEFAULT_MAX_TOTAL_BYTES,
+    private val atomicReader: (File) -> ByteArray? = ::readAtomically,
+    private val atomicWriter: (File, ByteArray) -> Boolean = ::writeAtomically,
+    private val atomicRemover: (File) -> Boolean = ::removeAtomically,
+) {
+    companion object {
+        private const val DIGEST_BYTES = 64
+        private const val MAX_COMPILED_CATALOG_BYTES = 256 * 1024
+        private const val MAX_WIRE_ENVELOPE_BYTES = 4 * 1024
+        private const val MAX_ETAG_BYTES = 1024
+        private const val CACHE_FORMAT_BYTES = 3
+        const val DEFAULT_MAX_ENTRIES = 8
+        const val DEFAULT_MAX_ENTRY_BYTES =
+            MAX_COMPILED_CATALOG_BYTES + MAX_WIRE_ENVELOPE_BYTES + MAX_ETAG_BYTES + CACHE_FORMAT_BYTES
+        const val DEFAULT_MAX_TOTAL_BYTES =
+            DEFAULT_MAX_ENTRIES.toLong() * (DEFAULT_MAX_ENTRY_BYTES + DIGEST_BYTES + 1)
+        private const val ENTRY_SUFFIX = ".catalog"
+
+        private fun readAtomically(file: File): ByteArray? =
+            try {
+                val atomicFile = AtomicFile(file)
+                atomicFile.openRead().use { input -> input.readBytes() }
+            } catch (_: Exception) {
+                null
+            }
+
+        private fun removeAtomically(file: File): Boolean {
+            val atomicFile = AtomicFile(file)
+            atomicFile.delete()
+            return !file.exists() &&
+                !File("${file.path}.bak").exists() &&
+                !File("${file.path}.new").exists()
+        }
+
+        private fun writeAtomically(
+            destination: File,
+            bytes: ByteArray,
+        ): Boolean {
+            val atomicFile = AtomicFile(destination)
+            var output: FileOutputStream? = null
+            return try {
+                output = atomicFile.startWrite()
+                output.write(bytes)
+                output.fd.sync()
+                atomicFile.finishWrite(output)
+                true
+            } catch (_: Exception) {
+                output?.let(atomicFile::failWrite)
+                false
+            }
+        }
+    }
+
+    init {
+        recoverInterruptedWrites()
+        trim()
+    }
+
+    @Synchronized
+    fun get(partition: String): String? {
+        val file = entryFile(partition)
+        return try {
+            val stored = atomicReader(file) ?: return null
+            if (stored.size > maxEntryBytes + DIGEST_BYTES + 1) {
+                atomicRemover(file)
+                return null
+            }
+            val separator = stored.indexOf('\n'.code.toByte())
+            if (separator != DIGEST_BYTES) {
+                atomicRemover(file)
+                return null
+            }
+            val expectedDigest = String(stored, 0, separator, StandardCharsets.US_ASCII)
+            val payload = stored.copyOfRange(separator + 1, stored.size)
+            if (payload.size > maxEntryBytes || sha256(payload) != expectedDigest) {
+                atomicRemover(file)
+                return null
+            }
+
+            file.setLastModified(System.currentTimeMillis())
+            String(payload, StandardCharsets.UTF_8)
+        } catch (_: Exception) {
+            atomicRemover(file)
+            null
+        }
+    }
+
+    @Synchronized
+    fun set(
+        partition: String,
+        value: String,
+    ): Boolean {
+        val payload = value.toByteArray(StandardCharsets.UTF_8)
+        if (payload.size > maxEntryBytes) return false
+        if (!rootDirectory.exists() && !rootDirectory.mkdirs()) return false
+
+        val destination = entryFile(partition)
+        return try {
+            val stored =
+                sha256(payload).toByteArray(StandardCharsets.US_ASCII) +
+                    byteArrayOf('\n'.code.toByte()) +
+                    payload
+            if (!atomicWriter(destination, stored)) return false
+            destination.setLastModified(System.currentTimeMillis())
+            trim()
+            true
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+    @Synchronized
+    fun remove(partition: String): Boolean = atomicRemover(entryFile(partition))
+
+    private fun entryFile(partition: String): File =
+        File(rootDirectory, "${sha256(partition.toByteArray(StandardCharsets.UTF_8))}$ENTRY_SUFFIX")
+
+    private fun recoverInterruptedWrites() {
+        rootDirectory.listFiles()?.forEach { file ->
+            when {
+                file.name.endsWith("$ENTRY_SUFFIX.bak") -> {
+                    val destination = File(file.parentFile, file.name.removeSuffix(".bak"))
+                    if (atomicReader(destination) == null) atomicRemover(destination)
+                }
+
+                file.name.endsWith("$ENTRY_SUFFIX.new") -> {
+                    val destination = File(file.parentFile, file.name.removeSuffix(".new"))
+                    if (atomicReader(destination) == null) atomicRemover(destination)
+                }
+            }
+        }
+    }
+
+    private fun trim() {
+        val entries =
+            rootDirectory
+                .listFiles { file -> file.isFile && file.name.endsWith(ENTRY_SUFFIX) }
+                ?.sortedByDescending { it.lastModified() }
+                .orEmpty()
+        var retainedBytes = 0L
+        entries.forEachIndexed { index, file ->
+            retainedBytes += file.length()
+            if (index >= maxEntries || retainedBytes > maxTotalBytes) {
+                atomicRemover(file)
+            }
+        }
+    }
+
+    private fun sha256(value: ByteArray): String =
+        MessageDigest
+            .getInstance("SHA-256")
+            .digest(value)
+            .joinToString("") { byte -> "%02x".format(byte.toInt() and 0xff) }
+}

package/android/src/main/java/com/hotupdater/SignatureVerifier.kt

@@ -92,7 +92,7 @@ object SignatureVerifier {
     private const val TAG = "SignatureVerifier"
 
     /**
-     * Reads public key from Android string resources.
+     * Reads public key from AndroidManifest metadata.
      * @param context Application context
      * @return Public key PEM string or null if not configured
      */
@@ -101,7 +101,6 @@ object SignatureVerifier {
             NativeConfigUtils.getString(
                 context,
                 NativeConfigUtils.PUBLIC_KEY_META_DATA_KEY,
-                "hot_updater_public_key",
             )
 
         if (publicKeyPEM.isNullOrEmpty()) {

package/android/src/newarch/HotUpdater.kt

@@ -60,7 +60,7 @@ class HotUpdater {
                 manifestFileHash,
                 changedAssets,
                 channel,
-                progressCallback,
+                progressCallback = progressCallback,
             )
         }
 

package/android/src/newarch/HotUpdaterModule.kt

@@ -107,6 +107,27 @@ class HotUpdaterModule internal constructor(
         return parsedAssets
     }
 
+    private fun parseSelection(params: ReadableMap): PersistedSelection? {
+        if (!params.hasKey("selection") || params.isNull("selection")) return null
+        val selection = params.getMap("selection") ?: return null
+        return PersistedSelection(
+            kind = selection.getString("kind") ?: return null,
+            releaseId = selection.getString("releaseId"),
+            bundleId = selection.getString("bundleId") ?: return null,
+            catalogId = selection.getString("catalogId"),
+            scopeKey = selection.getString("scopeKey"),
+            generation =
+                if (selection.hasKey("generation") && !selection.isNull("generation")) {
+                    selection.getDouble("generation").toLong()
+                } else {
+                    null
+                },
+            catalogHash = selection.getString("catalogHash"),
+            channel = selection.getString("channel") ?: "",
+            selectionContextHash = selection.getString("selectionContextHash"),
+        )
+    }
+
     override fun reload(promise: Promise) {
         moduleScope.launch {
             try {
@@ -162,6 +183,7 @@ class HotUpdaterModule internal constructor(
                 val manifestFileHash = params.getString("manifestFileHash")
                 val changedAssets = parseChangedAssets(params)
                 val channel = params.getString("channel")
+                val selection = parseSelection(params)
 
                 val impl = getInstance()
 
@@ -173,6 +195,7 @@ class HotUpdaterModule internal constructor(
                     manifestFileHash,
                     changedAssets,
                     channel,
+                    selection,
                 ) { progress ->
                     // Post to Main thread for React Native event emission
                     Handler(Looper.getMainLooper()).post {
@@ -235,6 +258,86 @@ class HotUpdaterModule internal constructor(
         }
     }
 
+    override fun acceptReleaseCatalog(params: ReadableMap): Boolean {
+        val catalogId = params.getString("catalogId") ?: return false
+        val scopeKey = params.getString("scopeKey") ?: return false
+        val catalogHash = params.getString("catalogHash") ?: return false
+        val channel = params.getString("channel") ?: return false
+        val selectionContextHash = params.getString("selectionContextHash") ?: return false
+        return getInstance().acceptReleaseCatalog(
+            catalogId = catalogId,
+            scopeKey = scopeKey,
+            generation = params.getDouble("generation").toLong(),
+            catalogHash = catalogHash,
+            channel = channel,
+            selectionContextHash = selectionContextHash,
+        )
+    }
+
+    override fun getActiveUpdateState(): WritableNativeMap = getInstance().getActiveUpdateState().toWritableNativeMap()
+
+    override fun getReleaseCatalogCache(
+        partition: String,
+        promise: Promise,
+    ) {
+        moduleScope.launch(Dispatchers.IO) {
+            promise.resolve(getInstance().getReleaseCatalogCache(partition))
+        }
+    }
+
+    override fun setReleaseCatalogCache(
+        partition: String,
+        payload: String,
+        promise: Promise,
+    ) {
+        moduleScope.launch(Dispatchers.IO) {
+            promise.resolve(getInstance().setReleaseCatalogCache(partition, payload))
+        }
+    }
+
+    override fun removeReleaseCatalogCache(
+        partition: String,
+        promise: Promise,
+    ) {
+        moduleScope.launch(Dispatchers.IO) {
+            promise.resolve(getInstance().removeReleaseCatalogCache(partition))
+        }
+    }
+
+    override fun isReleaseSelectionCurrent(params: ReadableMap): Boolean {
+        val catalogId = params.getString("catalogId") ?: return false
+        val scopeKey = params.getString("scopeKey") ?: return false
+        val catalogHash = params.getString("catalogHash") ?: return false
+        val channel = params.getString("channel") ?: return false
+        val selectionContextHash = params.getString("selectionContextHash") ?: return false
+        return getInstance().isReleaseSelectionCurrent(
+            catalogId = catalogId,
+            scopeKey = scopeKey,
+            generation = params.getDouble("generation").toLong(),
+            catalogHash = catalogHash,
+            channel = channel,
+            selectionContextHash = selectionContextHash,
+        )
+    }
+
+    override fun commitReleaseSelection(
+        params: ReadableMap,
+        promise: Promise,
+    ) {
+        val selection = parseSelection(params)
+        if (selection == null) {
+            promise.reject("INVALID_SELECTION", "Invalid Release selection")
+            return
+        }
+        moduleScope.launch {
+            try {
+                promise.resolve(getInstance().commitReleaseSelection(selection))
+            } catch (error: Exception) {
+                promise.reject("UNKNOWN_ERROR", error.message, error)
+            }
+        }
+    }
+
     override fun getTypedExportedConstants(): Map<String, Any?> {
         val constants: MutableMap<String, Any?> = HashMap()
         constants["MIN_BUNDLE_ID"] = HotUpdater.getMinBundleId()
@@ -284,6 +387,19 @@ class HotUpdaterModule internal constructor(
 
     override fun getManifest(): WritableNativeMap = getInstance().getManifest().toWritableNativeMap()
 
+    override fun getInstallId(): String = getInstance().getInstallId()
+
+    override fun getUserId(): String? = getInstance().getUserId()
+
+    override fun getUsername(): String? = getInstance().getUsername()
+
+    override fun setUser(
+        userId: String?,
+        username: String?,
+    ) {
+        getInstance().setUser(userId, username)
+    }
+
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {
             try {

package/android/src/oldarch/HotUpdater.kt

@@ -59,7 +59,7 @@ class HotUpdater {
                 manifestFileHash,
                 changedAssets,
                 channel,
-                progressCallback,
+                progressCallback = progressCallback,
             )
         }
 

package/android/src/oldarch/HotUpdaterModule.kt

@@ -107,6 +107,28 @@ class HotUpdaterModule internal constructor(
         return parsedAssets
     }
 
+    private fun parseSelection(params: ReadableMap): PersistedSelection? {
+        if (!params.hasKey("selection") || params.isNull("selection")) return null
+        val selection = params.getMap("selection") ?: return null
+        val bundleId = selection.getString("bundleId") ?: return null
+        return PersistedSelection(
+            kind = selection.getString("kind") ?: return null,
+            releaseId = selection.getString("releaseId"),
+            bundleId = bundleId,
+            catalogId = selection.getString("catalogId"),
+            scopeKey = selection.getString("scopeKey"),
+            generation =
+                if (selection.hasKey("generation") && !selection.isNull("generation")) {
+                    selection.getDouble("generation").toLong()
+                } else {
+                    null
+                },
+            catalogHash = selection.getString("catalogHash"),
+            channel = selection.getString("channel") ?: "",
+            selectionContextHash = selection.getString("selectionContextHash"),
+        )
+    }
+
     @ReactMethod
     override fun reload(promise: Promise) {
         moduleScope.launch {
@@ -165,6 +187,7 @@ class HotUpdaterModule internal constructor(
                 val manifestFileHash = params.getString("manifestFileHash")
                 val changedAssets = parseChangedAssets(params)
                 val channel = params.getString("channel")
+                val selection = parseSelection(params)
 
                 val impl = getInstance()
 
@@ -176,6 +199,7 @@ class HotUpdaterModule internal constructor(
                     manifestFileHash,
                     changedAssets,
                     channel,
+                    selection,
                 ) { progress ->
                     // Post to Main thread for React Native event emission
                     Handler(Looper.getMainLooper()).post {
@@ -231,6 +255,93 @@ class HotUpdaterModule internal constructor(
         }
     }
 
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun acceptReleaseCatalog(params: ReadableMap): Boolean {
+        val catalogId = params.getString("catalogId") ?: return false
+        val scopeKey = params.getString("scopeKey") ?: return false
+        val catalogHash = params.getString("catalogHash") ?: return false
+        val channel = params.getString("channel") ?: return false
+        val selectionContextHash = params.getString("selectionContextHash") ?: return false
+        return getInstance().acceptReleaseCatalog(
+            catalogId = catalogId,
+            scopeKey = scopeKey,
+            generation = params.getDouble("generation").toLong(),
+            catalogHash = catalogHash,
+            channel = channel,
+            selectionContextHash = selectionContextHash,
+        )
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getActiveUpdateState(): String = org.json.JSONObject(getInstance().getActiveUpdateState()).toString()
+
+    @ReactMethod
+    override fun getReleaseCatalogCache(
+        partition: String,
+        promise: Promise,
+    ) {
+        moduleScope.launch(Dispatchers.IO) {
+            promise.resolve(getInstance().getReleaseCatalogCache(partition))
+        }
+    }
+
+    @ReactMethod
+    override fun setReleaseCatalogCache(
+        partition: String,
+        payload: String,
+        promise: Promise,
+    ) {
+        moduleScope.launch(Dispatchers.IO) {
+            promise.resolve(getInstance().setReleaseCatalogCache(partition, payload))
+        }
+    }
+
+    @ReactMethod
+    override fun removeReleaseCatalogCache(
+        partition: String,
+        promise: Promise,
+    ) {
+        moduleScope.launch(Dispatchers.IO) {
+            promise.resolve(getInstance().removeReleaseCatalogCache(partition))
+        }
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun isReleaseSelectionCurrent(params: ReadableMap): Boolean {
+        val catalogId = params.getString("catalogId") ?: return false
+        val scopeKey = params.getString("scopeKey") ?: return false
+        val catalogHash = params.getString("catalogHash") ?: return false
+        val channel = params.getString("channel") ?: return false
+        val selectionContextHash = params.getString("selectionContextHash") ?: return false
+        return getInstance().isReleaseSelectionCurrent(
+            catalogId = catalogId,
+            scopeKey = scopeKey,
+            generation = params.getDouble("generation").toLong(),
+            catalogHash = catalogHash,
+            channel = channel,
+            selectionContextHash = selectionContextHash,
+        )
+    }
+
+    @ReactMethod
+    override fun commitReleaseSelection(
+        params: ReadableMap,
+        promise: Promise,
+    ) {
+        val selection = parseSelection(params)
+        if (selection == null) {
+            promise.reject("INVALID_SELECTION", "Invalid Release selection")
+            return
+        }
+        moduleScope.launch {
+            try {
+                promise.resolve(getInstance().commitReleaseSelection(selection))
+            } catch (error: Exception) {
+                promise.reject("UNKNOWN_ERROR", error.message, error)
+            }
+        }
+    }
+
     @ReactMethod
     fun addListener(
         @Suppress("UNUSED_PARAMETER") eventName: String?,
@@ -299,6 +410,23 @@ class HotUpdaterModule internal constructor(
     @ReactMethod(isBlockingSynchronousMethod = true)
     override fun getCohort(): String = cohortService.getCohort()
 
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getInstallId(): String = getInstance().getInstallId()
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getUserId(): String? = getInstance().getUserId()
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getUsername(): String? = getInstance().getUsername()
+
+    @ReactMethod
+    override fun setUser(
+        userId: String?,
+        username: String?,
+    ) {
+        getInstance().setUser(userId, username)
+    }
+
     @ReactMethod
     override fun resetChannel(promise: Promise) {
         moduleScope.launch {

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -13,6 +13,33 @@ abstract class HotUpdaterSpec internal constructor(
         promise: Promise,
     )
 
+    abstract fun acceptReleaseCatalog(params: ReadableMap): Boolean
+
+    abstract fun getActiveUpdateState(): String
+
+    abstract fun getReleaseCatalogCache(
+        partition: String,
+        promise: Promise,
+    )
+
+    abstract fun setReleaseCatalogCache(
+        partition: String,
+        payload: String,
+        promise: Promise,
+    )
+
+    abstract fun removeReleaseCatalogCache(
+        partition: String,
+        promise: Promise,
+    )
+
+    abstract fun isReleaseSelectionCurrent(params: ReadableMap): Boolean
+
+    abstract fun commitReleaseSelection(
+        params: ReadableMap,
+        promise: Promise,
+    )
+
     abstract fun reload(promise: Promise)
 
     abstract fun reloadProcess(promise: Promise)
@@ -33,5 +60,16 @@ abstract class HotUpdaterSpec internal constructor(
 
     abstract fun getManifest(): String
 
+    abstract fun getInstallId(): String
+
+    abstract fun getUserId(): String?
+
+    abstract fun getUsername(): String?
+
+    abstract fun setUser(
+        userId: String?,
+        username: String?,
+    )
+
     abstract fun resetChannel(promise: Promise)
 }