@hot-updater/react-native 0.17.0 → 0.18.1

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

@@ -2,23 +2,16 @@ package com.hotupdater
 
 import android.app.Activity
 import android.content.Context
-import android.os.Handler
-import android.os.Looper
-import android.util.Log
 import android.view.View
-import com.facebook.react.ReactApplication
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ReactShadowNode
 import com.facebook.react.uimanager.ViewManager
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import java.io.File
-import java.net.HttpURLConnection
-import java.net.URL
-import java.util.zip.ZipFile
 
+/**
+ * Main React Native package for HotUpdater
+ */
 class HotUpdater : ReactPackage {
     override fun createViewManagers(context: ReactApplicationContext): MutableList<ViewManager<View, ReactShadowNode<*>>> = mutableListOf()
 
@@ -26,309 +19,73 @@ class HotUpdater : ReactPackage {
         listOf(HotUpdaterModule(context)).toMutableList()
 
     companion object {
-        fun getAppVersion(context: Context): String? {
-            val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
-            return packageInfo.versionName
-        }
-
-        @Volatile
-        private var prefsInstance: HotUpdaterPrefs? = null
-
-        @Volatile
-        private var cachedAppVersion: String? = null
-
-        private fun getPrefs(context: Context): HotUpdaterPrefs {
-            val appContext = context.applicationContext
-            val currentAppVersion = getAppVersion(appContext) ?: "unknown"
-            synchronized(this) {
-                if (prefsInstance == null || cachedAppVersion != currentAppVersion) {
-                    prefsInstance = HotUpdaterPrefs(appContext, currentAppVersion)
-                    cachedAppVersion = currentAppVersion
-                }
-                return prefsInstance!!
-            }
-        }
-
-        private fun setBundleURL(
+        /**
+         * 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()
+
+        /**
+         * 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()
+
+        /**
+         * Gets the path to the bundle file
+         * @param context Application context
+         * @return The path to the bundle file
+         */
+        fun getJSBundleFile(context: Context): String = HotUpdaterFactory.getInstance(context).getJSBundleFile()
+
+        /**
+         * Updates the bundle from the specified URL
+         * @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 progressCallback Callback for download progress updates
+         * @return true if the update was successful
+         */
+        suspend fun updateBundle(
             context: Context,
-            bundleURL: String?,
-        ) {
-            val updaterPrefs = getPrefs(context)
-            updaterPrefs.setItem("HotUpdaterBundleURL", bundleURL)
-
-            if (bundleURL == null) {
-                return
-            }
-
-            val reactIntegrationManager = ReactIntegrationManager(context)
-            val activity: Activity? = getCurrentActivity(context)
-            val reactApplication: ReactApplication =
-                reactIntegrationManager.getReactApplication(activity?.application)
-            val newBundleURL = getJSBundleFile(context)
-            reactIntegrationManager.setJSBundle(reactApplication, newBundleURL)
-        }
-
-        private fun extractZipFileAtPath(
-            filePath: String,
-            destinationPath: String,
+            bundleId: String,
+            fileUrl: String?,
+            progressCallback: (Double) -> Unit,
         ): Boolean =
-            try {
-                ZipFile(filePath).use { zip ->
-                    zip.entries().asSequence().forEach { entry ->
-                        val file = File(destinationPath, entry.name)
-                        if (entry.isDirectory) {
-                            file.mkdirs()
-                        } else {
-                            file.parentFile?.mkdirs()
-                            zip.getInputStream(entry).use { input ->
-                                file.outputStream().use { output -> input.copyTo(output) }
-                            }
-                        }
-                    }
-                }
-                true
-            } catch (e: Exception) {
-                Log.d("HotUpdater", "Failed to unzip file: ${e.message}")
-                false
-            }
+            HotUpdaterFactory.getInstance(context).updateBundle(
+                bundleId,
+                fileUrl,
+                progressCallback,
+            )
+
+        /**
+         * Reloads the React Native application
+         * @param context Application context
+         */
+        fun reload(context: Context) {
+            val currentActivity = getCurrentActivity(context)
+            HotUpdaterFactory.getInstance(context).reload(currentActivity)
+        }
 
+        /**
+         * Gets the current activity from ReactApplicationContext
+         * @param context Context that might be a ReactApplicationContext
+         * @return The current activity or null
+         */
         private fun getCurrentActivity(context: Context): Activity? =
             if (context is ReactApplicationContext) {
                 context.currentActivity
             } else {
                 null
             }
-
-        fun reload(context: Context) {
-            val reactIntegrationManager = ReactIntegrationManager(context)
-            val activity: Activity? = getCurrentActivity(context)
-            val reactApplication: ReactApplication =
-                reactIntegrationManager.getReactApplication(activity?.application)
-            val bundleURL = getJSBundleFile(context)
-            reactIntegrationManager.setJSBundle(reactApplication, bundleURL)
-            Handler(Looper.getMainLooper()).post {
-                reactIntegrationManager.reload(reactApplication)
-            }
-        }
-
-        fun getJSBundleFile(context: Context): String {
-            val updaterPrefs = getPrefs(context)
-            val urlString = updaterPrefs.getItem("HotUpdaterBundleURL")
-            if (urlString.isNullOrEmpty()) {
-                return "assets://index.android.bundle"
-            }
-
-            val file = File(urlString)
-            if (!file.exists()) {
-                updaterPrefs.setItem("HotUpdaterBundleURL", null)
-                return "assets://index.android.bundle"
-            }
-            return urlString
-        }
-
-        fun setChannel(
-            context: Context,
-            channel: String,
-        ) {
-            val updaterPrefs = getPrefs(context)
-            updaterPrefs.setItem("HotUpdaterChannel", channel)
-        }
-
-        fun getChannel(context: Context): String? {
-            val updaterPrefs = getPrefs(context)
-            return updaterPrefs.getItem("HotUpdaterChannel")
-        }
-
-        suspend fun updateBundle(
-            context: Context,
-            bundleId: String,
-            zipUrl: String?,
-            progressCallback: ((Double) -> Unit),
-        ): Boolean {
-            Log.d("HotUpdater", "updateBundle bundleId $bundleId zipUrl $zipUrl")
-            if (zipUrl.isNullOrEmpty()) {
-                setBundleURL(context, null)
-                return true
-            }
-
-            val baseDir = context.getExternalFilesDir(null)
-            val bundleStoreDir = File(baseDir, "bundle-store")
-            if (!bundleStoreDir.exists()) {
-                bundleStoreDir.mkdirs()
-            }
-
-            val finalBundleDir = File(bundleStoreDir, bundleId)
-            if (finalBundleDir.exists()) {
-                Log.d("HotUpdater", "Bundle for bundleId $bundleId already exists. Using cached bundle.")
-                val existingIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
-                if (existingIndexFile != null) {
-                    finalBundleDir.setLastModified(System.currentTimeMillis())
-                    setBundleURL(context, existingIndexFile.absolutePath)
-                    cleanupOldBundles(bundleStoreDir)
-                    return true
-                } else {
-                    finalBundleDir.deleteRecursively()
-                }
-            }
-
-            val tempDir = File(baseDir, "bundle-temp")
-            if (tempDir.exists()) {
-                tempDir.deleteRecursively()
-            }
-            tempDir.mkdirs()
-
-            val tempZipFile = File(tempDir, "bundle.zip")
-            val extractedDir = File(tempDir, "extracted")
-            extractedDir.mkdirs()
-
-            val isSuccess =
-                withContext(Dispatchers.IO) {
-                    val downloadUrl = URL(zipUrl)
-                    val conn =
-                        try {
-                            downloadUrl.openConnection() as HttpURLConnection
-                        } catch (e: Exception) {
-                            Log.d("HotUpdater", "Failed to open connection: ${e.message}")
-                            tempDir.deleteRecursively()
-                            return@withContext false
-                        }
-
-                    try {
-                        conn.connect()
-                        val totalSize = conn.contentLength
-                        if (totalSize <= 0) {
-                            Log.d("HotUpdater", "Invalid content length: $totalSize")
-                            tempDir.deleteRecursively()
-                            return@withContext false
-                        }
-                        conn.inputStream.use { input ->
-                            tempZipFile.outputStream().use { output ->
-                                val buffer = ByteArray(8 * 1024)
-                                var bytesRead: Int
-                                var totalRead = 0L
-                                var lastProgressTime = System.currentTimeMillis()
-
-                                while (input.read(buffer).also { bytesRead = it } != -1) {
-                                    output.write(buffer, 0, bytesRead)
-                                    totalRead += bytesRead
-                                    val currentTime = System.currentTimeMillis()
-                                    if (currentTime - lastProgressTime >= 100) {
-                                        val progress = totalRead.toDouble() / totalSize
-                                        progressCallback.invoke(progress)
-                                        lastProgressTime = currentTime
-                                    }
-                                }
-                                progressCallback.invoke(1.0)
-                            }
-                        }
-                    } catch (e: Exception) {
-                        Log.d("HotUpdater", "Failed to download data from URL: $zipUrl, Error: ${e.message}")
-                        tempDir.deleteRecursively()
-                        return@withContext false
-                    } finally {
-                        conn.disconnect()
-                    }
-
-                    if (!extractZipFileAtPath(tempZipFile.absolutePath, extractedDir.absolutePath)) {
-                        Log.d("HotUpdater", "Failed to extract zip file.")
-                        tempDir.deleteRecursively()
-                        return@withContext false
-                    }
-                    true
-                }
-
-            if (!isSuccess) {
-                tempDir.deleteRecursively()
-                return false
-            }
-
-            val indexFileExtracted = extractedDir.walk().find { it.name == "index.android.bundle" }
-            if (indexFileExtracted == null) {
-                Log.d("HotUpdater", "index.android.bundle not found in extracted files.")
-                tempDir.deleteRecursively()
-                return false
-            }
-
-            if (finalBundleDir.exists()) {
-                finalBundleDir.deleteRecursively()
-            }
-            if (!extractedDir.renameTo(finalBundleDir)) {
-                extractedDir.copyRecursively(finalBundleDir, overwrite = true)
-                extractedDir.deleteRecursively()
-            }
-
-            val finalIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
-            if (finalIndexFile == null) {
-                Log.d("HotUpdater", "index.android.bundle not found in final directory.")
-                tempDir.deleteRecursively()
-                return false
-            }
-
-            finalBundleDir.setLastModified(System.currentTimeMillis())
-            val bundlePath = finalIndexFile.absolutePath
-            Log.d("HotUpdater", "Setting bundle URL: $bundlePath")
-            setBundleURL(context, bundlePath)
-            cleanupOldBundles(bundleStoreDir)
-            tempDir.deleteRecursively()
-
-            Log.d("HotUpdater", "Downloaded and extracted file successfully.")
-            return true
-        }
-
-        private fun cleanupOldBundles(bundleStoreDir: File) {
-            val bundles = bundleStoreDir.listFiles { file -> file.isDirectory }?.toList() ?: return
-            val sortedBundles = bundles.sortedByDescending { it.lastModified() }
-            if (sortedBundles.size > 1) {
-                sortedBundles.drop(1).forEach { oldBundle ->
-                    Log.d("HotUpdater", "Removing old bundle: ${oldBundle.name}")
-                    oldBundle.deleteRecursively()
-                }
-            }
-        }
-
-        fun getMinBundleId(): 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"
-            }
     }
 }

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

@@ -0,0 +1,49 @@
+package com.hotupdater
+
+import android.content.Context
+
+/**
+ * Factory for creating HotUpdaterImpl instances with proper dependency injection
+ */
+object HotUpdaterFactory {
+    @Volatile
+    private var instance: HotUpdaterImpl? = null
+
+    /**
+     * Gets the singleton instance of HotUpdaterImpl
+     * @param context Application context
+     * @return HotUpdaterImpl instance
+     */
+    fun getInstance(context: Context): HotUpdaterImpl =
+        instance ?: synchronized(this) {
+            instance ?: createHotUpdaterImpl(context).also { instance = it }
+        }
+
+    /**
+     * Creates a new HotUpdaterImpl instance with all dependencies
+     * @param context Application context
+     * @return New HotUpdaterImpl instance
+     */
+    private fun createHotUpdaterImpl(context: Context): HotUpdaterImpl {
+        val appContext = context.applicationContext
+        val appVersion = HotUpdaterImpl.getAppVersion(appContext) ?: "unknown"
+
+        // Create services
+        val fileSystem = FileManagerService(appContext)
+        val preferences = VersionedPreferencesService(appContext, appVersion)
+        val downloadService = HttpDownloadService()
+        val unzipService = ZipFileUnzipService()
+
+        // Create bundle storage with dependencies
+        val bundleStorage =
+            BundleFileStorageService(
+                fileSystem,
+                downloadService,
+                unzipService,
+                preferences,
+            )
+
+        // Create and return the implementation
+        return HotUpdaterImpl(appContext, bundleStorage, preferences)
+    }
+}

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

@@ -0,0 +1,176 @@
+package com.hotupdater
+
+import android.app.Activity
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+
+/**
+ * Core implementation class for HotUpdater functionality
+ */
+class HotUpdaterImpl(
+    private val context: Context,
+    private val bundleStorage: BundleStorageService,
+    private val preferences: PreferencesService,
+) {
+    /**
+     * 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
+        }
+
+    companion object {
+        private const val DEFAULT_CHANNEL = "production"
+
+        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
+            }
+    }
+
+    /**
+     * Generates a bundle ID based on build timestamp
+     * @return The minimum bundle ID string
+     */
+    fun getMinBundleId(): 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 update channel
+     * @return The channel name or null if not set
+     */
+    fun getChannel(): String {
+        val id = context.resources.getIdentifier("hot_updater_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 progressCallback Callback for download progress updates
+     * @return true if the update was successful
+     */
+    suspend fun updateBundle(
+        bundleId: String,
+        fileUrl: String?,
+        progressCallback: (Double) -> Unit,
+    ): Boolean = bundleStorage.updateBundle(bundleId, fileUrl, progressCallback)
+
+    /**
+     * Reloads the React Native application
+     * @param activity Current activity (optional)
+     */
+    fun reload(activity: Activity? = null) {
+        val reactIntegrationManager = ReactIntegrationManager(context)
+        val application = activity?.application ?: return
+
+        try {
+            val reactApplication = reactIntegrationManager.getReactApplication(application)
+            val bundleURL = getJSBundleFile()
+
+            reactIntegrationManager.setJSBundle(reactApplication, bundleURL)
+
+            Handler(Looper.getMainLooper()).post {
+                reactIntegrationManager.reload(reactApplication)
+            }
+        } catch (e: Exception) {
+            Log.e("HotUpdaterImpl", "Failed to reload application", e)
+        }
+    }
+
+    /**
+     * Gets the current activity from ReactApplicationContext
+     * @param context Context that might be a ReactApplicationContext
+     * @return The current activity or null
+     */
+    @Suppress("UNUSED_PARAMETER")
+    fun getCurrentActivity(context: Context): Activity? {
+        // This would need to be implemented differently or moved
+        // since it requires ReactApplicationContext which introduces circular dependencies
+        return null
+    }
+}