@hot-updater/react-native 0.17.0 → 0.18.0

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

@@ -0,0 +1,104 @@
+package com.hotupdater
+
+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/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)
+    }
+}