react-native-instantpay-code-push 1.1.0

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

@@ -0,0 +1,329 @@
+package com.instantpaycodepush
+
+import android.app.Activity
+import android.content.Context
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+
+/**
+ * Core implementation class for HotUpdater functionality
+ */
+class IpayCodePushImpl {
+    private val context: Context
+    private val bundleStorage: BundleStorageService
+    private val preferences: PreferencesService
+
+    /**
+     * Primary constructor with dependency injection (for testing)
+     */
+    constructor(
+        context: Context,
+        bundleStorage: BundleStorageService,
+        preferences: PreferencesService,
+    ) {
+        this.context = context.applicationContext
+        this.bundleStorage = bundleStorage
+        this.preferences = preferences
+    }
+
+    /**
+     * Convenience constructor for simple usage
+     */
+    constructor(context: Context) : this(
+        context = context,
+        bundleStorage = createBundleStorage(context),
+        preferences = createPreferences(context),
+    )
+
+    companion object {
+        private const val CLASS_TAG = "*IpayCodePushImpl"
+        private const val DEFAULT_CHANNEL = "production"
+
+        /**
+         * Create BundleStorageService with all dependencies
+         */
+        private fun createBundleStorage(context: Context): BundleStorageService {
+            val appContext = context.applicationContext
+            val fileSystem = FileManagerService(appContext)
+            val preferences = createPreferences(appContext)
+            val downloadService = OkHttpDownloadService()
+            val decompressService = DecompressService()
+            val isolationKey = getIsolationKey(appContext)
+
+            return BundleFileStorageService(
+                appContext,
+                fileSystem,
+                downloadService,
+                decompressService,
+                preferences,
+                isolationKey,
+            )
+        }
+
+        /**
+         * Create PreferencesService with isolation key
+         */
+        private fun createPreferences(context: Context): PreferencesService {
+            val appContext = context.applicationContext
+            val isolationKey = getIsolationKey(appContext)
+            return VersionedPreferencesService(appContext, isolationKey)
+        }
+
+        /**
+         * Gets the complete isolation key for preferences storage
+         * @param context Application context
+         * @return The isolation key in format: IpayCodePushPrefs_{fingerprintOrVersion}_{channel}
+         */
+        private fun getIsolationKey(context: Context): String {
+            // Get fingerprint hash directly from resources
+            val fingerprintId = context.resources.getIdentifier("ipay_code_push_fingerprint_hash", "string", context.packageName)
+            val fingerprintHash =
+                if (fingerprintId != 0) {
+                    context.getString(fingerprintId).takeIf { it.isNotEmpty() }
+                } else {
+                    null
+                }
+
+            // Get app version and channel
+            val appVersion = getAppVersion(context) ?: "unknown"
+            val appChannel = getChannel(context)
+
+            // Include both fingerprint hash and app version for complete isolation
+            val baseKey =
+                if (!fingerprintHash.isNullOrEmpty()) {
+                    "${fingerprintHash}_$appVersion"
+                } else {
+                    appVersion
+                }
+
+            return "IpayCodePushPrefs_${baseKey}_$appChannel"
+        }
+
+        fun getAppVersion(context: Context): String? =
+            try {
+                val packageInfo =
+                    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+                        context.packageManager.getPackageInfo(
+                            context.packageName,
+                            android.content.pm.PackageManager.PackageInfoFlags
+                                .of(0),
+                        )
+                    } else {
+                        @Suppress("DEPRECATION")
+                        context.packageManager.getPackageInfo(context.packageName, 0)
+                    }
+                packageInfo.versionName
+            } catch (e: Exception) {
+                null
+            }
+
+        fun getChannel(context: Context): String {
+            val id = context.resources.getIdentifier("ipay_code_push_channel", "string", context.packageName)
+            return if (id != 0) {
+                context.getString(id).takeIf { it.isNotEmpty() } ?: DEFAULT_CHANNEL
+            } else {
+                DEFAULT_CHANNEL
+            }
+        }
+
+        /**
+         * Get minimum bundle ID string
+         * @return The minimum bundle ID string
+         */
+        fun getMinBundleId(): String {
+            if (BuildConfig.DEBUG) {
+                return "00000000-0000-0000-0000-000000000000"
+            }
+
+            return BuildConfig.MIN_BUNDLE_ID.takeIf { it != "null" } ?: generateMinBundleIdFromBuildTimestamp()
+        }
+
+        /**
+         * Generates a bundle ID based on build timestamp
+         * @return The generated minimum bundle ID string
+         */
+        private fun generateMinBundleIdFromBuildTimestamp(): String =
+            try {
+                val buildTimestampMs = BuildConfig.BUILD_TIMESTAMP
+                val bytes =
+                    ByteArray(16).apply {
+                        this[0] = ((buildTimestampMs shr 40) and 0xFF).toByte()
+                        this[1] = ((buildTimestampMs shr 32) and 0xFF).toByte()
+                        this[2] = ((buildTimestampMs shr 24) and 0xFF).toByte()
+                        this[3] = ((buildTimestampMs shr 16) and 0xFF).toByte()
+                        this[4] = ((buildTimestampMs shr 8) and 0xFF).toByte()
+                        this[5] = (buildTimestampMs and 0xFF).toByte()
+                        this[6] = 0x70.toByte()
+                        this[7] = 0x00.toByte()
+                        this[8] = 0x80.toByte()
+                        this[9] = 0x00.toByte()
+                        this[10] = 0x00.toByte()
+                        this[11] = 0x00.toByte()
+                        this[12] = 0x00.toByte()
+                        this[13] = 0x00.toByte()
+                        this[14] = 0x00.toByte()
+                        this[15] = 0x00.toByte()
+                    }
+                String.format(
+                    "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                    bytes[0].toInt() and 0xFF,
+                    bytes[1].toInt() and 0xFF,
+                    bytes[2].toInt() and 0xFF,
+                    bytes[3].toInt() and 0xFF,
+                    bytes[4].toInt() and 0xFF,
+                    bytes[5].toInt() and 0xFF,
+                    bytes[6].toInt() and 0xFF,
+                    bytes[7].toInt() and 0xFF,
+                    bytes[8].toInt() and 0xFF,
+                    bytes[9].toInt() and 0xFF,
+                    bytes[10].toInt() and 0xFF,
+                    bytes[11].toInt() and 0xFF,
+                    bytes[12].toInt() and 0xFF,
+                    bytes[13].toInt() and 0xFF,
+                    bytes[14].toInt() and 0xFF,
+                    bytes[15].toInt() and 0xFF,
+                )
+            } catch (e: Exception) {
+                "00000000-0000-0000-0000-000000000000"
+            }
+
+        /**
+         * Gets the current fingerprint hash
+         * @param context Application context
+         * @return The fingerprint hash or null if not set
+         */
+        fun getFingerprintHash(context: Context): String? {
+            val id = context.resources.getIdentifier("ipay_code_push_fingerprint_hash", "string", context.packageName)
+            return if (id != 0) {
+                context.getString(id).takeIf { it.isNotEmpty() }
+            } else {
+                null
+            }
+        }
+    }
+
+    /**
+     * Gets the app version
+     * @param context Application context
+     * @return App version name or null if not available
+     */
+    fun getAppVersion(): String? =
+        try {
+            val packageInfo =
+                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+                    context.packageManager.getPackageInfo(
+                        context.packageName,
+                        android.content.pm.PackageManager.PackageInfoFlags
+                            .of(0),
+                    )
+                } else {
+                    @Suppress("DEPRECATION")
+                    context.packageManager.getPackageInfo(context.packageName, 0)
+                }
+            packageInfo.versionName
+        } catch (e: Exception) {
+            null
+        }
+
+    /**
+     * Gets the current fingerprint hash
+     * @return The fingerprint hash or null if not set
+     */
+    fun getFingerprintHash(): String? {
+        val id = context.resources.getIdentifier("ipay_code_push_fingerprint_hash", "string", context.packageName)
+        return if (id != 0) {
+            context.getString(id).takeIf { it.isNotEmpty() }
+        } else {
+            null
+        }
+    }
+
+    /**
+     * Gets the current update channel
+     * @return The channel name or null if not set
+     */
+    fun getChannel(): String {
+        val id = context.resources.getIdentifier("ipay_code_push_channel", "string", context.packageName)
+        return if (id != 0) {
+            context.getString(id).takeIf { it.isNotEmpty() } ?: DEFAULT_CHANNEL
+        } else {
+            DEFAULT_CHANNEL
+        }
+    }
+
+    /**
+     * Gets the path to the bundle file
+     * @return The path to the bundle file
+     */
+    fun getJSBundleFile(): String = bundleStorage.getBundleURL()
+
+    /**
+     * Updates the bundle from the specified URL
+     * @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
+     * @throws IpayCodePushException if the update fails
+     */
+    suspend fun updateBundle(
+        bundleId: String,
+        fileUrl: String?,
+        fileHash: String?,
+        progressCallback: (Double) -> Unit,
+    ) {
+        bundleStorage.updateBundle(bundleId, fileUrl, fileHash, progressCallback)
+    }
+
+    /**
+     * Reloads the React Native application
+     * @param activity Current activity (optional)
+     */
+    suspend fun reload(activity: Activity? = null) {
+        val reactIntegrationManager = ReactIntegrationManager(context)
+        val application = activity?.application ?: return
+
+        try {
+            val reactApplication = reactIntegrationManager.getReactApplication(application)
+            val bundleURL = getJSBundleFile()
+
+            // Perform reload (suspends until safe to reload on new arch)
+            withContext(Dispatchers.Main) {
+                reactIntegrationManager.setJSBundle(reactApplication, bundleURL)
+                reactIntegrationManager.reload(reactApplication)
+            }
+        } catch (e: Exception) {
+            CommonHelper.logPrint(CLASS_TAG, "Failed to reload application $e")
+            Log.e(CLASS_TAG, "Failed to reload application", e)
+        }
+    }
+
+    /**
+     * Notifies the system that the app has successfully started with the given bundle.
+     * If the bundle matches the staging bundle, it promotes to stable.
+     * @param bundleId The ID of the currently running bundle
+     * @return Map containing status and optional crashedBundleId
+     */
+    fun notifyAppReady(bundleId: String): Map<String, Any?> = bundleStorage.notifyAppReady(bundleId)
+
+    /**
+     * Gets the crashed bundle history.
+     * @return List of crashed bundle IDs
+     */
+    fun getCrashHistory(): List<String> = bundleStorage.getCrashHistory().bundles.map { it.bundleId }
+
+    /**
+     * Clears the crashed bundle history.
+     * @return true if clearing was successful
+     */
+    fun clearCrashHistory(): Boolean = bundleStorage.clearCrashHistory()
+
+    /**
+     * Gets the base URL for the current active bundle directory.
+     * Returns the file:// URL to the bundle directory with trailing slash.
+     * This is used for Expo DOM components to construct full asset paths.
+     * @return Base URL string (e.g., "file:///data/.../bundle-store/abc123/") or empty string
+     */
+    fun getBaseURL(): String = bundleStorage.getBaseURL()
+}

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

@@ -0,0 +1,283 @@
+package com.instantpaycodepush
+
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withContext
+
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.ResponseBody
+
+import okio.Buffer
+import okio.BufferedSource
+import okio.ForwardingSource
+import okio.Source
+import okio.buffer
+
+import java.io.File
+import java.io.IOException
+import java.net.SocketTimeoutException
+import java.net.URL
+import java.net.UnknownHostException
+import java.util.concurrent.TimeUnit
+
+/**
+ * Exception for incomplete downloads with size information
+ */
+class IncompleteDownloadException(
+    val expectedSize: Long,
+    val actualSize: Long,
+) : IOException("Download incomplete: received $actualSize bytes, expected $expectedSize bytes")
+
+
+/**
+ * Result wrapper for download operations
+ */
+sealed class DownloadResult {
+    data class Success(
+        val file: File,
+    ) : DownloadResult()
+
+    data class Error(
+        val exception: Exception,
+    ) : DownloadResult()
+}
+
+/**
+ * Interface for download operations
+ */
+interface DownloadService {
+    /**
+     * Downloads a file from a URL
+     * @param fileUrl The URL to download from
+     * @param destination The local file to save to
+     * @param fileSizeCallback Optional callback called when file size is known
+     * @param progressCallback Callback for download progress updates
+     * @return Result indicating success or failure
+     */
+    suspend fun downloadFile(
+        fileUrl: URL,
+        destination: File,
+        fileSizeCallback: ((Long) -> Unit)? = null,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult
+}
+
+/**
+ * Progress tracking wrapper for OkHttp ResponseBody
+ */
+private class ProgressResponseBody(
+    private val responseBody: ResponseBody,
+    private val progressCallback: (Double) -> Unit,
+) : ResponseBody() {
+    private var bufferedSource: BufferedSource? = null
+
+    override fun contentType() = responseBody.contentType()
+
+    override fun contentLength() = responseBody.contentLength()
+
+    override fun source(): BufferedSource {
+        if (bufferedSource == null) {
+            bufferedSource = source(responseBody.source()).buffer()
+        }
+        return bufferedSource!!
+    }
+
+    private fun source(source: Source): Source =
+        object : ForwardingSource(source) {
+            var totalBytesRead = 0L
+            var lastProgressTime = System.currentTimeMillis()
+
+            override fun read(
+                sink: Buffer,
+                byteCount: Long,
+            ): Long {
+                val bytesRead = super.read(sink, byteCount)
+                totalBytesRead += if (bytesRead != -1L) bytesRead else 0
+                val currentTime = System.currentTimeMillis()
+
+                if (currentTime - lastProgressTime >= 100) {
+                    val progress = totalBytesRead.toDouble() / contentLength()
+                    progressCallback.invoke(progress)
+                    lastProgressTime = currentTime
+                }
+                return bytesRead
+            }
+        }
+}
+
+/**
+ * OkHttp-based implementation of DownloadService with resume support
+ */
+class OkHttpDownloadService : DownloadService {
+
+    companion object {
+        private const val CLASS_TAG = "*OkHttpDownloadService"
+        private const val MAX_RETRIES = 3
+        private const val INITIAL_RETRY_DELAY_MS = 1000L
+        private const val TIMEOUT_SECONDS = 30L
+    }
+
+    private val client =
+        OkHttpClient
+            .Builder()
+            .connectTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .readTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .writeTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            .build()
+
+    override suspend fun downloadFile(
+        fileUrl: URL,
+        destination: File,
+        fileSizeCallback: ((Long) -> Unit)?,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult =
+        withContext(Dispatchers.IO) {
+            var attempt = 0
+            var lastException: Exception? = null
+
+            while (attempt < MAX_RETRIES) {
+                try {
+                    return@withContext attemptDownload(
+                        fileUrl,
+                        destination,
+                        fileSizeCallback,
+                        progressCallback,
+                    )
+                } catch (e: Exception) {
+                    lastException = e
+                    attempt++
+
+                    if (attempt < MAX_RETRIES && isRetryableException(e)) {
+                        val delayMs = INITIAL_RETRY_DELAY_MS * (1 shl (attempt - 1))
+                        CommonHelper.logPrint(
+                            CLASS_TAG,
+                            "Download failed (attempt $attempt/$MAX_RETRIES): ${e.message}. Retrying in ${delayMs}ms...",
+                        )
+                        delay(delayMs)
+                    } else {
+                        CommonHelper.logPrint(CLASS_TAG, "Download failed: ${e.message}")
+                        break
+                    }
+                }
+            }
+
+            DownloadResult.Error(lastException ?: Exception("Download failed after $MAX_RETRIES attempts"))
+        }
+
+    private suspend fun attemptDownload(
+        fileUrl: URL,
+        destination: File,
+        fileSizeCallback: ((Long) -> Unit)?,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult =
+        withContext(Dispatchers.IO) {
+            // Make sure parent directories exist
+            destination.parentFile?.mkdirs()
+
+            // Delete any existing partial file to start fresh
+            if (destination.exists()) {
+                CommonHelper.logPrint(CLASS_TAG, "Deleting existing file, starting fresh download")
+                destination.delete()
+            }
+
+            val request = Request.Builder().url(fileUrl).build()
+            val response: Response
+
+            try {
+                response = client.newCall(request).execute()
+            } catch (e: Exception) {
+                CommonHelper.logPrint(CLASS_TAG, "Failed to execute request: ${e.message}")
+                return@withContext DownloadResult.Error(e)
+            }
+
+            if (!response.isSuccessful) {
+                val errorMsg = "HTTP error ${response.code}: ${response.message}"
+                CommonHelper.logPrint(CLASS_TAG, errorMsg)
+                response.close()
+                return@withContext DownloadResult.Error(Exception(errorMsg))
+            }
+
+            val body = response.body
+            if (body == null) {
+                response.close()
+                return@withContext DownloadResult.Error(Exception("Response body is null"))
+            }
+
+            // Get total file size
+            val totalSize = body.contentLength()
+
+            if (totalSize > 0) {
+                // Notify file size to caller for disk space check
+                fileSizeCallback?.invoke(totalSize)
+                CommonHelper.logPrint(CLASS_TAG, "Starting download: $totalSize bytes")
+            } else {
+                CommonHelper.logPrint(CLASS_TAG, "Content-Length not available ($totalSize), proceeding without disk space check")
+            }
+
+            try {
+                // Wrap response body with progress tracking
+                val progressBody =
+                    ProgressResponseBody(body) { progress ->
+                        progressCallback.invoke(progress)
+                    }
+
+                // Write to file
+                progressBody.source().use { source ->
+                    destination.outputStream().use { output ->
+                        val buffer = ByteArray(8 * 1024)
+                        var bytesRead: Int
+
+                        while (source.read(buffer).also { bytesRead = it } != -1) {
+                            output.write(buffer, 0, bytesRead)
+                        }
+                    }
+                }
+
+                response.close()
+
+                // Verify file size
+                val finalSize = destination.length()
+                if (finalSize != totalSize) {
+                    CommonHelper.logPrint(CLASS_TAG, "Download incomplete: $finalSize / $totalSize bytes")
+
+                    // Delete incomplete file
+                    destination.delete()
+                    return@withContext DownloadResult.Error(
+                        IncompleteDownloadException(
+                            expectedSize = totalSize,
+                            actualSize = finalSize,
+                        ),
+                    )
+                }
+
+                CommonHelper.logPrint(CLASS_TAG, "Download completed successfully: $finalSize bytes")
+                progressCallback.invoke(1.0)
+                DownloadResult.Success(destination)
+            } catch (e: Exception) {
+                response.close()
+                CommonHelper.logPrint(CLASS_TAG, "Failed to download data: ${e.message}")
+
+                // Delete incomplete file
+                if (destination.exists()) {
+                    destination.delete()
+                }
+                DownloadResult.Error(e)
+            }
+        }
+
+    /**
+     * Check if exception is retryable
+     */
+    private fun isRetryableException(e: Exception): Boolean =
+        when (e) {
+            is SocketTimeoutException,
+            is UnknownHostException,
+            is IOException,
+                -> true
+
+            else -> false
+        }
+}