react-native-instantpay-code-push 1.1.0

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

@@ -0,0 +1,249 @@
+package com.instantpaycodepush
+
+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 isolationKey: String? = null,
+    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 CLASS_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),
+                isolationKey =
+                    if (json.has("isolationKey") && !json.isNull("isolationKey")) {
+                        json.getString("isolationKey").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
+                stableBundleId =
+                    if (json.has("stableBundleId") && !json.isNull("stableBundleId")) {
+                        json.getString("stableBundleId").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
+                stagingBundleId =
+                    if (json.has("stagingBundleId") && !json.isNull("stagingBundleId")) {
+                        json.getString("stagingBundleId").takeIf { it.isNotEmpty() }
+                    } else {
+                        null
+                    },
+                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,
+            expectedIsolationKey: String,
+        ): BundleMetadata? {
+            return try {
+
+                if (!file.exists()) {
+                    CommonHelper.logPrint(CLASS_TAG, "Metadata file does not exist: ${file.absolutePath}")
+                    return null
+                }
+
+                val jsonString = file.readText()
+                val json = JSONObject(jsonString)
+                val metadata = fromJson(json)
+
+                // Validate isolation key
+                val metadataKey = metadata.isolationKey
+                if (metadataKey != null) {
+                    if (metadataKey != expectedIsolationKey) {
+                        CommonHelper.logPrint(CLASS_TAG, "Isolation key mismatch: expected=$expectedIsolationKey, got=$metadataKey")
+                        return null
+                    }
+                } else {
+                    CommonHelper.logPrint(CLASS_TAG, "Missing isolation key in metadata, treating as invalid")
+                    return null
+                }
+
+                metadata
+            } catch (e: Exception) {
+                CommonHelper.logPrint(CLASS_TAG, "Failed to load metadata from file $e")
+                Log.e(CLASS_TAG, "Failed to load metadata from file", e)
+                null
+            }
+
+        }
+    }
+
+    fun toJson(): JSONObject =
+        JSONObject().apply {
+            put("schema", schema)
+            put("isolationKey", isolationKey ?: JSONObject.NULL)
+            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))
+            CommonHelper.logPrint(CLASS_TAG, "Saved metadata to file: ${file.absolutePath}")
+            true
+        } catch (e: Exception) {
+            CommonHelper.logPrint(CLASS_TAG, "Failed to save metadata to file: $e")
+            Log.e(CLASS_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 CLSSS_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()) {
+                    CommonHelper.logPrint(CLSSS_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) {
+                CommonHelper.logPrint(CLSSS_TAG, "Failed to load crashed history from file: $e")
+                Log.e(CLSSS_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))
+            CommonHelper.logPrint(CLSSS_TAG, "Saved crashed history to file: ${file.absolutePath}")
+            true
+        } catch (e: Exception) {
+            CommonHelper.logPrint(CLSSS_TAG, "Failed to save crashed history to file: $e")
+            Log.e(CLSSS_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/instantpaycodepush/CommonHelper.kt

@@ -0,0 +1,39 @@
+package com.instantpaycodepush
+
+import android.util.Log
+
+object CommonHelper {
+
+    const val MAIN_LOG_TAG = "*IpayCodePush -> "
+
+    const val WARNING_LOG = "WARNING_LOG"
+
+    const val ERROR_LOG = "ERROR_LOG"
+
+    fun logPrint(classTag:String, value: String?) {
+        if (value == null) {
+            return
+        }
+
+        val fullTagName = "$MAIN_LOG_TAG $classTag"
+
+        Log.i(fullTagName, value)
+    }
+
+    fun logPrint(type:String,classTag:String, value: String?) {
+        if (value == null) {
+            return
+        }
+
+        val fullTagName = "$MAIN_LOG_TAG $classTag"
+
+        if(type == "WARNING_LOG"){
+            Log.i(fullTagName, value)
+        } else if(type == "ERROR_LOG") {
+            Log.e(fullTagName, value)
+        }
+        else{
+            Log.i(fullTagName, value)
+        }
+    }
+}

package/android/src/main/java/com/instantpaycodepush/DecompressService.kt

@@ -0,0 +1,85 @@
+package com.instantpaycodepush
+
+import android.util.Log
+import java.io.File
+
+/**
+ * Unified decompression service that uses Strategy pattern to handle multiple compression formats.
+ * Automatically detects format by trying each strategy's validation and delegates to appropriate decompression strategy.
+ */
+class DecompressService {
+
+    companion object {
+        private const val CLASS_TAG = "*DecompressService"
+    }
+
+    // Array of available strategies in order of detection priority
+    // Order matters: Try ZIP first (clear magic bytes), then TAR.GZ (GZIP magic bytes), then TAR.BR (fallback)
+    private val strategies =
+        listOf(
+            ZipDecompressionStrategy(),
+            //TarGzDecompressionStrategy(),
+            //TarBrDecompressionStrategy(),
+        )
+
+    /**
+     * Extracts a compressed file to the destination directory.
+     * Automatically detects compression format by trying each strategy's validation.
+     * @param filePath Path to the compressed file
+     * @param destinationPath Path to the destination directory
+     * @param progressCallback Callback for progress updates (0.0 - 1.0)
+     * @return true if extraction was successful, false otherwise
+     */
+
+    fun extractZipFile(
+        filePath: String,
+        destinationPath: String,
+        progressCallback: (Double) -> Unit,
+    ): Boolean {
+        // Collect file information for better error messages
+        val file = File(filePath)
+        val fileName = file.name
+        val fileSize = if (file.exists()) file.length() else 0L
+
+        // Try each strategy's validation
+        for (strategy in strategies) {
+            if (strategy.isValid(filePath)) {
+                CommonHelper.logPrint(CLASS_TAG, "Using strategy for $fileName")
+                return strategy.decompress(filePath, destinationPath, progressCallback)
+            }
+        }
+
+        // No valid strategy found - provide detailed error message
+        val errorMessage =
+            """
+            Failed to decompress file: $fileName ($fileSize bytes)
+
+            Tried strategies: ZIP (magic bytes 0x504B0304), TAR.GZ (magic bytes 0x1F8B), TAR.BR (file extension)
+
+            Supported formats:
+            - ZIP archives (.zip)
+            - GZIP compressed TAR archives (.tar.gz)
+            - Brotli compressed TAR archives (.tar.br)
+
+            Please verify the file is not corrupted and matches one of the supported formats.
+            """.trimIndent()
+
+        Log.e(CLASS_TAG, errorMessage)
+        return false
+    }
+
+    /**
+     * Validates if a file is a valid compressed archive.
+     * @param filePath Path to the file to validate
+     * @return true if the file is a valid compressed archive
+     */
+    fun isValidZipFile(filePath: String): Boolean {
+        for (strategy in strategies) {
+            if (strategy.isValid(filePath)) {
+                return true
+            }
+        }
+        CommonHelper.logPrint(CLASS_TAG, "No valid strategy found for file: $filePath")
+        return false
+    }
+}

package/android/src/main/java/com/instantpaycodepush/DecompressionStrategy.kt

@@ -0,0 +1,24 @@
+package com.instantpaycodepush
+
+interface DecompressionStrategy {
+
+    /**
+     * Validates if a file can be decompressed by this strategy
+     * @param filePath Path to the file to validate
+     * @return true if the file is valid for this strategy
+     */
+    fun isValid(filePath: String): Boolean
+
+    /**
+     * Decompresses a file to the destination directory
+     * @param filePath Path to the compressed file
+     * @param destinationPath Path to the destination directory
+     * @param progressCallback Callback for progress updates (0.0 - 1.0)
+     * @return true if decompression was successful, false otherwise
+     */
+    fun decompress(
+        filePath: String,
+        destinationPath: String,
+        progressCallback: (Double) -> Unit,
+    ): Boolean
+}

package/android/src/main/java/com/instantpaycodepush/FileManagerService.kt

@@ -0,0 +1,105 @@
+package com.instantpaycodepush
+
+import android.content.Context
+import java.io.File
+
+/**
+ * Interface for file system operations
+ */
+interface FileSystemService {
+    /**
+     * Checks if a file exists at the given path
+     */
+    fun fileExists(path: String): Boolean
+
+    /**
+     * Creates directory at the given path, including any necessary parent directories
+     */
+    fun createDirectory(path: String): Boolean
+
+    /**
+     * Removes a file or directory at the given path
+     */
+    fun removeItem(path: String): Boolean
+
+    /**
+     * Moves a file or directory from source path to destination path
+     */
+    fun moveItem(
+        sourcePath: String,
+        destinationPath: String,
+    ): Boolean
+
+    /**
+     * Copies a file or directory from source path to destination path
+     */
+    fun copyItem(
+        sourcePath: String,
+        destinationPath: String,
+    ): Boolean
+
+    /**
+     * Lists the contents of a directory
+     */
+    fun contentsOfDirectory(path: String): List<String>
+
+    /**
+     * Gets the external files directory for the application
+     */
+    fun getExternalFilesDir(): File?
+}
+
+/**
+ * Implementation of FileSystemService using standard File API
+ */
+class FileManagerService(
+    private val context: Context,
+) : FileSystemService {
+
+    override fun fileExists(path: String): Boolean = File(path).exists()
+
+    override fun createDirectory(path: String): Boolean = File(path).mkdirs()
+
+    override fun removeItem(path: String): Boolean = File(path).deleteRecursively()
+
+    override fun moveItem(
+        sourcePath: String,
+        destinationPath: String,
+    ): Boolean {
+        val source = File(sourcePath)
+        val destination = File(destinationPath)
+
+        return try {
+            if (destination.exists()) {
+                destination.deleteRecursively()
+            }
+            source.renameTo(destination)
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    override fun copyItem(
+        sourcePath: String,
+        destinationPath: String,
+    ): Boolean {
+        val source = File(sourcePath)
+        val destination = File(destinationPath)
+
+        return try {
+            if (destination.exists()) {
+                destination.deleteRecursively()
+            }
+            source.copyRecursively(target = destination, overwrite = true)
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    override fun contentsOfDirectory(path: String): List<String> {
+        val directory = File(path)
+        return directory.listFiles()?.map { it.name } ?: listOf()
+    }
+
+    override fun getExternalFilesDir(): File? = context.getExternalFilesDir(null)
+}

package/android/src/main/java/com/instantpaycodepush/HashUtils.kt

@@ -0,0 +1,50 @@
+package com.instantpaycodepush
+
+import android.util.Log
+import java.io.File
+import java.security.MessageDigest
+
+/**
+ * Utility class for file hash operations
+ */
+object HashUtils {
+
+    private const val CLASS_TAG = "*HashUtils"
+
+    /**
+     * Calculates SHA256 hash of a file
+     * @param file The file to hash
+     * @return Hex string of the hash (lowercase)
+     */
+    fun calculateSHA256(file: File): String {
+        val digest = MessageDigest.getInstance("SHA-256")
+        file.inputStream().use { input ->
+            val buffer = ByteArray(8192)
+            var bytesRead: Int
+            while (input.read(buffer).also { bytesRead = it } != -1) {
+                digest.update(buffer, 0, bytesRead)
+            }
+        }
+        return digest.digest().joinToString("") { "%02x".format(it) }
+    }
+
+    /**
+     * Verifies file hash
+     * @param file File to verify
+     * @param expectedHash Expected SHA256 hash (hex string, case-insensitive)
+     * @return true if hash matches
+     */
+    fun verifyHash(
+        file: File,
+        expectedHash: String,
+    ): Boolean {
+        val actualHash = calculateSHA256(file)
+        val matches = actualHash.equals(expectedHash, ignoreCase = true)
+
+        if (!matches) {
+            CommonHelper.logPrint(CLASS_TAG, "Hash mismatch - Expected: $expectedHash, Actual: $actualHash")
+        }
+
+        return matches
+    }
+}