@hot-updater/react-native 0.16.7-0 → 0.18.0

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
+    }
+}

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/newarch/ReactIntegrationManager.kt

@@ -3,7 +3,9 @@ package com.hotupdater
 import android.content.Context
 import android.util.Log
 import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
 import com.facebook.react.common.LifecycleState
+import java.lang.reflect.Field
 
 class ReactIntegrationManager(
     context: Context,
@@ -25,8 +27,22 @@ class ReactIntegrationManager(
             jsBundleLoaderField.isAccessible = true
             jsBundleLoaderField.set(reactHostDelegate, getJSBundlerLoader(bundleURL))
         } catch (e: Exception) {
+            try {
+                val instanceManager = application.reactNativeHost.reactInstanceManager
+                val bundleLoader: JSBundleLoader? = this.getJSBundlerLoader(bundleURL)
+                val bundleLoaderField: Field =
+                    instanceManager::class.java.getDeclaredField("mBundleLoader")
+                bundleLoaderField.isAccessible = true
+
+                if (bundleLoader != null) {
+                    bundleLoaderField.set(instanceManager, bundleLoader)
+                } else {
+                    bundleLoaderField.set(instanceManager, null)
+                }
+            } catch (e: Exception) {
+                Log.d("HotUpdater", "Failed to setJSBundle (fallback): ${e.message}")
+            }
             Log.d("HotUpdater", "Failed to setJSBundle: ${e.message}")
-            throw IllegalAccessException("Could not setJSBundle")
         }
     }
 
@@ -57,12 +73,10 @@ class ReactIntegrationManager(
                     }
                 } catch (e: Exception) {
                     Log.d("HotUpdater", "Failed to reload: ${e.message}")
-                    throw e
                 }
             }
         } catch (e: Exception) {
             Log.d("HotUpdater", "Failed to reload: ${e.message}")
-            throw e
         }
     }
 }

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,
-    )
 }

package/android/src/oldarch/ReactIntegrationManager.kt

@@ -27,7 +27,6 @@ class ReactIntegrationManager(
             }
         } catch (e: Exception) {
             Log.d("HotUpdater", "Failed to setJSBundle: ${e.message}")
-            throw IllegalAccessException("Could not setJSBundle")
         }
     }
 
@@ -49,7 +48,6 @@ class ReactIntegrationManager(
             }
         } catch (e: Exception) {
             Log.d("HotUpdater", "Failed to reload: ${e.message}")
-            throw e
         }
     }
 }