@hot-updater/react-native 0.17.0 → 0.18.1

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

@@ -0,0 +1,98 @@
+package com.hotupdater
+
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+
+/**
+ * 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 progressCallback Callback for download progress updates
+     * @return Result indicating success or failure
+     */
+    suspend fun downloadFile(
+        fileUrl: URL,
+        destination: File,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult
+}
+
+/**
+ * Implementation of DownloadService using HttpURLConnection
+ */
+class HttpDownloadService : DownloadService {
+    override suspend fun downloadFile(
+        fileUrl: URL,
+        destination: File,
+        progressCallback: (Double) -> Unit,
+    ): DownloadResult =
+        withContext(Dispatchers.IO) {
+            val conn =
+                try {
+                    fileUrl.openConnection() as HttpURLConnection
+                } catch (e: Exception) {
+                    Log.d("DownloadService", "Failed to open connection: ${e.message}")
+                    return@withContext DownloadResult.Error(e)
+                }
+
+            try {
+                conn.connect()
+                val totalSize = conn.contentLength
+                if (totalSize <= 0) {
+                    Log.d("DownloadService", "Invalid content length: $totalSize")
+                    return@withContext DownloadResult.Error(Exception("Invalid content length: $totalSize"))
+                }
+
+                // Make sure parent directories exist
+                destination.parentFile?.mkdirs()
+
+                conn.inputStream.use { input ->
+                    destination.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)
+                    }
+                }
+                DownloadResult.Success(destination)
+            } catch (e: Exception) {
+                Log.d("DownloadService", "Failed to download data from URL: $fileUrl, Error: ${e.message}")
+                DownloadResult.Error(e)
+            } finally {
+                conn.disconnect()
+            }
+        }
+}

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

@@ -0,0 +1,69 @@
+package com.hotupdater
+
+import android.content.Context
+import android.content.SharedPreferences
+import java.io.File
+
+/**
+ * Interface for preference storage operations
+ */
+interface PreferencesService {
+    /**
+     * Gets a stored preference value
+     * @param key The key to retrieve
+     * @return The stored value or null if not found
+     */
+    fun getItem(key: String): String?
+
+    /**
+     * Sets a preference value
+     * @param key The key to store under
+     * @param value The value to store (or null to remove)
+     */
+    fun setItem(
+        key: String,
+        value: String?,
+    )
+}
+
+/**
+ * Implementation of PreferencesService using SharedPreferences
+ * Modified from original HotUpdaterPrefs to follow the service pattern
+ */
+class VersionedPreferencesService(
+    private val context: Context,
+    private val appVersion: String,
+) : PreferencesService {
+    private val prefs: SharedPreferences
+
+    init {
+        val prefsName = "HotUpdaterPrefs_$appVersion"
+
+        val sharedPrefsDir = File(context.applicationInfo.dataDir, "shared_prefs")
+        if (sharedPrefsDir.exists() && sharedPrefsDir.isDirectory) {
+            sharedPrefsDir.listFiles()?.forEach { file ->
+                if (file.name.startsWith("HotUpdaterPrefs_") && file.name != "$prefsName.xml") {
+                    file.delete()
+                }
+            }
+        }
+
+        prefs = context.getSharedPreferences(prefsName, Context.MODE_PRIVATE)
+    }
+
+    override fun getItem(key: String): String? = prefs.getString(key, null)
+
+    override fun setItem(
+        key: String,
+        value: String?,
+    ) {
+        prefs.edit().apply {
+            if (value == null) {
+                remove(key)
+            } else {
+                putString(key, value)
+            }
+            apply()
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+package com.hotupdater
+
+import android.util.Log
+import java.io.File
+import java.util.zip.ZipFile
+
+/**
+ * Interface for unzip operations
+ */
+interface UnzipService {
+    /**
+     * Extracts a zip file to a destination directory
+     * @param filePath Path to the zip file
+     * @param destinationPath Directory to extract contents to
+     * @return true if extraction was successful, false otherwise
+     */
+    fun extractZipFile(
+        filePath: String,
+        destinationPath: String,
+    ): Boolean
+}
+
+/**
+ * Implementation of UnzipService using standard Zip API
+ */
+class ZipFileUnzipService : UnzipService {
+    override fun extractZipFile(
+        filePath: String,
+        destinationPath: String,
+    ): 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("UnzipService", "Failed to unzip file: ${e.message}")
+            false
+        }
+}

package/android/src/newarch/HotUpdaterModule.kt

@@ -1,10 +1,12 @@
 package com.hotupdater
 
+import android.util.Log
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.lifecycleScope
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.launch
@@ -18,54 +20,49 @@ class HotUpdaterModule internal constructor(
 
     @ReactMethod
     override fun reload() {
-        HotUpdater.reload(mReactApplicationContext)
-    }
-
-    @ReactMethod
-    override fun getAppVersion(promise: Promise) {
-        promise.resolve(HotUpdater.getAppVersion(mReactApplicationContext))
-    }
-
-    @ReactMethod
-    override fun setChannel(
-        channel: String,
-        promise: Promise,
-    ) {
-        HotUpdater.setChannel(mReactApplicationContext, channel)
-        promise.resolve(null)
+        try {
+            HotUpdater.reload(mReactApplicationContext)
+        } catch (e: Exception) {
+            Log.d("HotUpdater", "Failed to reload", e)
+        }
     }
 
     @ReactMethod
     override fun updateBundle(
-        bundleId: String,
-        zipUrl: String?,
+        params: ReadableMap,
         promise: Promise,
     ) {
         // Use lifecycleScope when currentActivity is FragmentActivity
         (currentActivity as? FragmentActivity)?.lifecycleScope?.launch {
-            val isSuccess =
-                HotUpdater.updateBundle(
-                    mReactApplicationContext,
-                    bundleId,
-                    zipUrl,
-                ) { progress ->
-                    val params =
-                        WritableNativeMap().apply {
-                            putDouble("progress", progress)
-                        }
+            try {
+                val bundleId = params.getString("bundleId")!!
+                val fileUrl = params.getString("fileUrl")
+                val isSuccess =
+                    HotUpdater.updateBundle(
+                        mReactApplicationContext,
+                        bundleId,
+                        fileUrl,
+                    ) { progress ->
+                        val progressParams =
+                            WritableNativeMap().apply {
+                                putDouble("progress", progress)
+                            }
 
-                    this@HotUpdaterModule
-                        .mReactApplicationContext
-                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                        .emit("onProgress", params)
-                }
-            promise.resolve(isSuccess)
+                        this@HotUpdaterModule
+                            .mReactApplicationContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                            .emit("onProgress", progressParams)
+                    }
+                promise.resolve(isSuccess)
+            } catch (e: Exception) {
+                promise.reject("updateBundle", e)
+            }
         }
     }
 
     override fun getTypedExportedConstants(): Map<String, Any?> {
         val constants: MutableMap<String, Any?> = HashMap()
-        constants["MIN_BUNDLE_ID"] = HotUpdater.getMinBundleId()
+        constants["MIN_BUNDLE_ID"] = HotUpdater.getMinBundleId(mReactApplicationContext)
         constants["APP_VERSION"] = HotUpdater.getAppVersion(mReactApplicationContext)
         constants["CHANNEL"] = HotUpdater.getChannel(mReactApplicationContext)
         return constants

package/android/src/oldarch/HotUpdaterModule.kt

@@ -1,10 +1,12 @@
 package com.hotupdater
 
+import android.util.Log
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.lifecycleScope
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import kotlinx.coroutines.launch
@@ -18,48 +20,44 @@ class HotUpdaterModule internal constructor(
 
     @ReactMethod
     override fun reload() {
-        HotUpdater.reload(mReactApplicationContext)
-    }
-
-    @ReactMethod
-    override fun getAppVersion(promise: Promise) {
-        promise.resolve(HotUpdater.getAppVersion(mReactApplicationContext))
-    }
-
-    @ReactMethod
-    override fun setChannel(
-        channel: String,
-        promise: Promise,
-    ) {
-        HotUpdater.setChannel(mReactApplicationContext, channel)
-        promise.resolve(null)
+        try {
+            HotUpdater.reload(mReactApplicationContext)
+        } catch (e: Exception) {
+            Log.d("HotUpdater", "Failed to reload", e)
+        }
     }
 
     @ReactMethod
     override fun updateBundle(
-        bundleId: String,
-        zipUrl: String?,
+        params: ReadableMap,
         promise: Promise,
     ) {
         // Use lifecycleScope when currentActivity is FragmentActivity
         (currentActivity as? FragmentActivity)?.lifecycleScope?.launch {
-            val isSuccess =
-                HotUpdater.updateBundle(
-                    mReactApplicationContext,
-                    bundleId,
-                    zipUrl,
-                ) { progress ->
-                    val params =
-                        WritableNativeMap().apply {
-                            putDouble("progress", progress)
-                        }
+            try {
+                val bundleId = params.getString("bundleId")!!
+                val fileUrl = params.getString("fileUrl")
+
+                val isSuccess =
+                    HotUpdater.updateBundle(
+                        mReactApplicationContext,
+                        bundleId,
+                        fileUrl,
+                    ) { progress ->
+                        val progressParams =
+                            WritableNativeMap().apply {
+                                putDouble("progress", progress)
+                            }
 
-                    this@HotUpdaterModule
-                        .mReactApplicationContext
-                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                        .emit("onProgress", params)
-                }
-            promise.resolve(isSuccess)
+                        this@HotUpdaterModule
+                            .mReactApplicationContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                            .emit("onProgress", progressParams)
+                    }
+                promise.resolve(isSuccess)
+            } catch (e: Exception) {
+                promise.reject("updateBundle", e)
+            }
         }
     }
 
@@ -79,7 +77,7 @@ class HotUpdaterModule internal constructor(
 
     override fun getConstants(): Map<String, Any?> {
         val constants: MutableMap<String, Any?> = HashMap()
-        constants["MIN_BUNDLE_ID"] = HotUpdater.getMinBundleId()
+        constants["MIN_BUNDLE_ID"] = HotUpdater.getMinBundleId(mReactApplicationContext)
         constants["APP_VERSION"] = HotUpdater.getAppVersion(mReactApplicationContext)
         constants["CHANNEL"] = HotUpdater.getChannel(mReactApplicationContext)
         return constants

package/android/src/oldarch/HotUpdaterSpec.kt

@@ -3,22 +3,15 @@ package com.hotupdater
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableMap
 
 abstract class HotUpdaterSpec internal constructor(
     context: ReactApplicationContext,
 ) : ReactContextBaseJavaModule(context) {
     abstract fun updateBundle(
-        bundleId: String,
-        zipUrl: String?,
+        params: ReadableMap,
         promise: Promise,
     )
 
     abstract fun reload()
-
-    abstract fun getAppVersion(promise: Promise)
-
-    abstract fun setChannel(
-        channel: String,
-        promise: Promise,
-    )
 }