@hot-updater/react-native 0.23.1 → 0.24.0

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

@@ -0,0 +1,204 @@
+package com.hotupdater
+
+import android.util.Log
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * Bundle metadata for managing stable/staging bundles and verification state
+ */
+data class BundleMetadata(
+    val schema: String = SCHEMA_VERSION,
+    val stableBundleId: String? = null,
+    val stagingBundleId: String? = null,
+    val verificationPending: Boolean = false,
+    val verificationAttemptedAt: Long? = null,
+    val stagingExecutionCount: Int? = null,
+    val updatedAt: Long = System.currentTimeMillis(),
+) {
+    companion object {
+        private const val TAG = "BundleMetadata"
+        const val SCHEMA_VERSION = "metadata-v1"
+        const val METADATA_FILENAME = "metadata.json"
+
+        fun fromJson(json: JSONObject): BundleMetadata =
+            BundleMetadata(
+                schema = json.optString("schema", SCHEMA_VERSION),
+                stableBundleId = json.optString("stableBundleId", null)?.takeIf { it.isNotEmpty() },
+                stagingBundleId = json.optString("stagingBundleId", null)?.takeIf { it.isNotEmpty() },
+                verificationPending = json.optBoolean("verificationPending", false),
+                verificationAttemptedAt =
+                    if (json.has("verificationAttemptedAt") && !json.isNull("verificationAttemptedAt")) {
+                        json.getLong("verificationAttemptedAt")
+                    } else {
+                        null
+                    },
+                stagingExecutionCount =
+                    if (json.has("stagingExecutionCount") && !json.isNull("stagingExecutionCount")) {
+                        json.getInt("stagingExecutionCount")
+                    } else {
+                        null
+                    },
+                updatedAt = json.optLong("updatedAt", System.currentTimeMillis()),
+            )
+
+        fun loadFromFile(file: File): BundleMetadata? {
+            return try {
+                if (!file.exists()) {
+                    Log.d(TAG, "Metadata file does not exist: ${file.absolutePath}")
+                    return null
+                }
+                val jsonString = file.readText()
+                val json = JSONObject(jsonString)
+                fromJson(json)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load metadata from file", e)
+                null
+            }
+        }
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("schema", schema)
+            put("stableBundleId", stableBundleId ?: JSONObject.NULL)
+            put("stagingBundleId", stagingBundleId ?: JSONObject.NULL)
+            put("verificationPending", verificationPending)
+            put("verificationAttemptedAt", verificationAttemptedAt ?: JSONObject.NULL)
+            put("stagingExecutionCount", stagingExecutionCount ?: JSONObject.NULL)
+            put("updatedAt", updatedAt)
+        }
+
+    fun saveToFile(file: File): Boolean =
+        try {
+            file.parentFile?.mkdirs()
+            file.writeText(toJson().toString(2))
+            Log.d(TAG, "Saved metadata to file: ${file.absolutePath}")
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to save metadata to file", e)
+            false
+        }
+}
+
+/**
+ * Entry for a crashed bundle in history
+ */
+data class CrashedBundleEntry(
+    val bundleId: String,
+    val crashedAt: Long,
+    val crashCount: Int = 1,
+) {
+    companion object {
+        fun fromJson(json: JSONObject): CrashedBundleEntry =
+            CrashedBundleEntry(
+                bundleId = json.getString("bundleId"),
+                crashedAt = json.getLong("crashedAt"),
+                crashCount = json.optInt("crashCount", 1),
+            )
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("bundleId", bundleId)
+            put("crashedAt", crashedAt)
+            put("crashCount", crashCount)
+        }
+}
+
+/**
+ * History of crashed bundles
+ */
+data class CrashedHistory(
+    val bundles: MutableList<CrashedBundleEntry> = mutableListOf(),
+    val maxHistorySize: Int = DEFAULT_MAX_HISTORY_SIZE,
+) {
+    companion object {
+        private const val TAG = "CrashedHistory"
+        const val DEFAULT_MAX_HISTORY_SIZE = 10
+        const val CRASHED_HISTORY_FILENAME = "crashed-history.json"
+
+        fun fromJson(json: JSONObject): CrashedHistory {
+            val bundlesArray = json.optJSONArray("bundles") ?: JSONArray()
+            val bundles = mutableListOf<CrashedBundleEntry>()
+            for (i in 0 until bundlesArray.length()) {
+                bundles.add(CrashedBundleEntry.fromJson(bundlesArray.getJSONObject(i)))
+            }
+            return CrashedHistory(
+                bundles = bundles,
+                maxHistorySize = json.optInt("maxHistorySize", DEFAULT_MAX_HISTORY_SIZE),
+            )
+        }
+
+        fun loadFromFile(file: File): CrashedHistory {
+            return try {
+                if (!file.exists()) {
+                    Log.d(TAG, "Crashed history file does not exist, returning empty history")
+                    return CrashedHistory()
+                }
+                val jsonString = file.readText()
+                val json = JSONObject(jsonString)
+                fromJson(json)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load crashed history from file", e)
+                CrashedHistory()
+            }
+        }
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            val bundlesArray = JSONArray()
+            bundles.forEach { bundlesArray.put(it.toJson()) }
+            put("bundles", bundlesArray)
+            put("maxHistorySize", maxHistorySize)
+        }
+
+    fun saveToFile(file: File): Boolean =
+        try {
+            file.parentFile?.mkdirs()
+            file.writeText(toJson().toString(2))
+            Log.d(TAG, "Saved crashed history to file: ${file.absolutePath}")
+            true
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to save crashed history to file", e)
+            false
+        }
+
+    fun contains(bundleId: String): Boolean = bundles.any { it.bundleId == bundleId }
+
+    fun addEntry(bundleId: String) {
+        val existingIndex = bundles.indexOfFirst { it.bundleId == bundleId }
+        if (existingIndex >= 0) {
+            // Update existing entry
+            val existing = bundles[existingIndex]
+            bundles[existingIndex] =
+                existing.copy(
+                    crashedAt = System.currentTimeMillis(),
+                    crashCount = existing.crashCount + 1,
+                )
+        } else {
+            // Add new entry
+            bundles.add(
+                CrashedBundleEntry(
+                    bundleId = bundleId,
+                    crashedAt = System.currentTimeMillis(),
+                    crashCount = 1,
+                ),
+            )
+        }
+
+        // Trim to max size (keep most recent)
+        if (bundles.size > maxHistorySize) {
+            bundles.sortBy { it.crashedAt }
+            while (bundles.size > maxHistorySize) {
+                bundles.removeAt(0)
+            }
+        }
+    }
+
+    fun clear() {
+        bundles.clear()
+    }
+}

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

@@ -6,52 +6,41 @@ import com.facebook.react.bridge.ReactApplicationContext
 
 /**
  * Main React Native package for HotUpdater
+ * Provides static utility methods and a default singleton instance
  */
 class HotUpdater {
     companion object {
-        /**
-         * Gets the app version
-         * @param context Application context
-         * @return App version name or null if not available
-         */
-        fun getAppVersion(context: Context): String? = HotUpdaterFactory.getInstance(context).getAppVersion()
-
-        /**
-         * Generates a bundle ID based on build timestamp
-         * @param context Application context
-         * @return The minimum bundle ID string
-         */
-        fun getMinBundleId(context: Context): String = HotUpdaterFactory.getInstance(context).getMinBundleId()
+        @Volatile
+        private var instance: HotUpdaterImpl? = null
 
         /**
-         * Gets the current fingerprint hash
+         * Gets or creates the singleton instance
+         * Thread-safe double-checked locking
          * @param context Application context
-         * @return The fingerprint hash or null if not set
+         * @return The singleton HotUpdaterImpl instance
          */
-        fun getFingerprintHash(context: Context): String? = HotUpdaterFactory.getInstance(context).getFingerprintHash()
-
-        /**
-         * Gets the current update channel
-         * @param context Application context
-         * @return The channel name or null if not set
-         */
-        fun getChannel(context: Context): String? = HotUpdaterFactory.getInstance(context).getChannel()
+        fun getInstance(context: Context): HotUpdaterImpl =
+            instance ?: synchronized(this) {
+                instance ?: HotUpdaterImpl(context.applicationContext).also {
+                    instance = it
+                }
+            }
 
         /**
-         * Gets the path to the bundle file
+         * Gets the JS bundle file path using the default singleton instance
          * @param context Application context
          * @return The path to the bundle file
          */
-        fun getJSBundleFile(context: Context): String = HotUpdaterFactory.getInstance(context).getJSBundleFile()
+        fun getJSBundleFile(context: Context): String = getInstance(context).getJSBundleFile()
 
         /**
-         * Updates the bundle from the specified URL
+         * Updates the bundle using the default singleton instance
          * @param context Application context
          * @param bundleId ID of the bundle to update
          * @param fileUrl URL of the bundle file to download (or null to reset)
          * @param fileHash Combined hash string for verification (sig:<signature> or <hex_hash>)
          * @param progressCallback Callback for download progress updates
-         * @return true if the update was successful
+         * @throws HotUpdaterException if the update fails
          */
         suspend fun updateBundle(
             context: Context,
@@ -59,23 +48,46 @@ class HotUpdater {
             fileUrl: String?,
             fileHash: String?,
             progressCallback: (Double) -> Unit,
-        ): Boolean =
-            HotUpdaterFactory.getInstance(context).updateBundle(
-                bundleId,
-                fileUrl,
-                fileHash,
-                progressCallback,
-            )
+        ) {
+            getInstance(context).updateBundle(bundleId, fileUrl, fileHash, progressCallback)
+        }
 
         /**
-         * Reloads the React Native application
+         * Reloads the React Native application using the default singleton instance
          * @param context Application context
          */
         suspend fun reload(context: Context) {
             val currentActivity = getCurrentActivity(context)
-            HotUpdaterFactory.getInstance(context).reload(currentActivity)
+            getInstance(context).reload(currentActivity)
         }
 
+        /**
+         * Gets the app version - delegates to HotUpdaterImpl static method
+         * @param context Application context
+         * @return App version name or null if not available
+         */
+        fun getAppVersion(context: Context): String? = HotUpdaterImpl.getAppVersion(context)
+
+        /**
+         * Gets the minimum bundle ID - delegates to HotUpdaterImpl static method
+         * @return The minimum bundle ID string
+         */
+        fun getMinBundleId(): String = HotUpdaterImpl.getMinBundleId()
+
+        /**
+         * Gets the current fingerprint hash - delegates to HotUpdaterImpl static method
+         * @param context Application context
+         * @return The fingerprint hash or null if not set
+         */
+        fun getFingerprintHash(context: Context): String? = HotUpdaterImpl.getFingerprintHash(context)
+
+        /**
+         * Gets the current update channel - delegates to HotUpdaterImpl static method
+         * @param context Application context
+         * @return The channel name or null if not set
+         */
+        fun getChannel(context: Context): String = HotUpdaterImpl.getChannel(context)
+
         /**
          * Gets the current activity from ReactApplicationContext
          * @param context Context that might be a ReactApplicationContext

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

@@ -0,0 +1,134 @@
+package com.hotupdater
+
+/**
+ * Exception class for Hot Updater errors
+ * Matches error codes defined in packages/react-native/src/errors.ts
+ */
+class HotUpdaterException(
+    val code: String,
+    message: String,
+    cause: Throwable? = null,
+) : Exception(message, cause) {
+    companion object {
+        // Parameter validation errors
+        fun missingBundleId() =
+            HotUpdaterException(
+                "MISSING_BUNDLE_ID",
+                "Missing or empty 'bundleId'",
+            )
+
+        fun invalidFileUrl() =
+            HotUpdaterException(
+                "INVALID_FILE_URL",
+                "Invalid 'fileUrl' provided",
+            )
+
+        // Bundle storage errors
+        fun directoryCreationFailed() =
+            HotUpdaterException(
+                "DIRECTORY_CREATION_FAILED",
+                "Failed to create bundle directory",
+            )
+
+        fun downloadFailed(cause: Throwable? = null) =
+            HotUpdaterException(
+                "DOWNLOAD_FAILED",
+                "Failed to download bundle",
+                cause,
+            )
+
+        fun incompleteDownload(
+            expectedSize: Long,
+            actualSize: Long,
+        ) = HotUpdaterException(
+            "INCOMPLETE_DOWNLOAD",
+            "Download incomplete: received $actualSize bytes, expected $expectedSize bytes",
+        )
+
+        fun extractionFormatError(cause: Throwable? = null) =
+            HotUpdaterException(
+                "EXTRACTION_FORMAT_ERROR",
+                "Invalid or corrupted bundle archive format",
+                cause,
+            )
+
+        fun invalidBundle() =
+            HotUpdaterException(
+                "INVALID_BUNDLE",
+                "Bundle missing required platform files (index.ios.bundle or index.android.bundle)",
+            )
+
+        fun insufficientDiskSpace(
+            required: Long,
+            available: Long,
+        ) = HotUpdaterException(
+            "INSUFFICIENT_DISK_SPACE",
+            "Insufficient disk space: need $required bytes, available $available bytes",
+        )
+
+        fun signatureVerificationFailed(cause: Throwable? = null) =
+            HotUpdaterException(
+                "SIGNATURE_VERIFICATION_FAILED",
+                "Bundle signature verification failed",
+                cause,
+            )
+
+        fun moveOperationFailed() =
+            HotUpdaterException(
+                "MOVE_OPERATION_FAILED",
+                "Failed to move bundle files",
+            )
+
+        fun bundleInCrashedHistory(bundleId: String) =
+            HotUpdaterException(
+                "BUNDLE_IN_CRASHED_HISTORY",
+                "Bundle '$bundleId' is in crashed history and cannot be applied",
+            )
+
+        // Signature verification errors
+        fun publicKeyNotConfigured() =
+            HotUpdaterException(
+                "PUBLIC_KEY_NOT_CONFIGURED",
+                "Public key not configured for signature verification",
+            )
+
+        fun invalidPublicKeyFormat() =
+            HotUpdaterException(
+                "INVALID_PUBLIC_KEY_FORMAT",
+                "Invalid public key format",
+            )
+
+        fun fileHashMismatch() =
+            HotUpdaterException(
+                "FILE_HASH_MISMATCH",
+                "File hash verification failed",
+            )
+
+        fun fileReadFailed() =
+            HotUpdaterException(
+                "FILE_READ_FAILED",
+                "Failed to read file for verification",
+            )
+
+        fun unsignedNotAllowed() =
+            HotUpdaterException(
+                "UNSIGNED_NOT_ALLOWED",
+                "Unsigned bundles are not allowed",
+            )
+
+        fun securityFrameworkError(cause: Throwable? = null) =
+            HotUpdaterException(
+                "SECURITY_FRAMEWORK_ERROR",
+                "Security framework error occurred",
+                cause,
+            )
+
+        // Internal errors
+        fun unknownError(cause: Throwable? = null) =
+            HotUpdaterException(
+                "UNKNOWN_ERROR",
+                "An unknown error occurred",
+                cause,
+            )
+    }
+}