@hot-updater/react-native 0.1.4 → 0.1.5

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

@@ -5,286 +5,197 @@ import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
-import com.facebook.react.ReactInstanceManager
-import com.facebook.react.ReactNativeHost
-import com.facebook.react.bridge.JSBundleLoader
-import com.facebook.react.bridge.LifecycleEventListener
+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 java.io.File
-import java.lang.reflect.Field
+import java.net.HttpURLConnection
 import java.net.URL
 import java.util.zip.ZipFile
 
-class HotUpdater internal constructor(context: Context, reactNativeHost: ReactNativeHost) {
-    private val mContext: Context = context
-    private val mReactNativeHost: ReactNativeHost = reactNativeHost
+class HotUpdater : ReactPackage {
+    override fun createViewManagers(context: ReactApplicationContext): MutableList<ViewManager<View, ReactShadowNode<*>>> = mutableListOf()
 
-    companion object {
-        private var mCurrentInstance: HotUpdater? = null
-
-        fun init(context: Context, reactNativeHost: ReactNativeHost): HotUpdater {
-            Log.d("HotUpdater", "Initializing HotUpdater")
-
-            return mCurrentInstance
-                    ?: synchronized(this) {
-                        mCurrentInstance
-                                ?: HotUpdater(context, reactNativeHost).also {
-                                    mCurrentInstance = it
-                                }
-                    }
-        }
-
-        fun getAppVersion(): String? {
-            return mCurrentInstance?.getAppVersion()
-        }
-
-        fun initializeOnAppUpdate() {
-            mCurrentInstance?.initializeOnAppUpdate()
-        }
-
-        fun reload() {
-            mCurrentInstance?.reload()
-        }
-
-        fun getJSBundleFile(): String? {
-            Log.d("HotUpdater", "Getting JS bundle file ${mCurrentInstance?.getBundleURL()}")
-            return mCurrentInstance?.getBundleURL()
-        }
-
-        fun getBundleVersion(): Double? {
-            return mCurrentInstance?.getBundleVersion()
-        }
-
-        fun updateBundle(prefix: String, url: String?): Boolean? {
-            return mCurrentInstance?.updateBundle(prefix, url)
-        }
-    }
-
-    private val documentsDir: String
-        get() = mContext.getExternalFilesDir(null)?.absolutePath ?: mContext.filesDir.absolutePath
-
-    private fun convertFileSystemPathFromBasePath(basePath: String): String {
-        val separator = if (basePath.startsWith("/")) "" else "/"
-        return "$documentsDir$separator$basePath"
-    }
+    override fun createNativeModules(context: ReactApplicationContext): MutableList<NativeModule> =
+        listOf(HotUpdaterModule(context)).toMutableList()
 
-    private fun stripPrefixFromPath(prefix: String, path: String): String {
-        return if (path.startsWith("/$prefix/")) {
-            path.replaceFirst("/$prefix/", "")
-        } else {
-            path
-        }
-    }
+    companion object {
+        private fun convertFileSystemPathFromBasePath(
+            context: Context,
+            basePath: String,
+        ): String {
+            val documentsDir = context.getExternalFilesDir(null)?.absolutePath ?: context.filesDir.absolutePath
+            val separator = if (basePath.startsWith("/")) "" else "/"
+
+            return "$documentsDir$separator$basePath"
+        }
+
+        private fun stripPrefixFromPath(
+            prefix: String,
+            path: String,
+        ): String =
+            if (path.startsWith("/$prefix/")) {
+                path.replaceFirst("/$prefix/", "")
+            } else {
+                path
+            }
 
-    private fun loadBundleLegacy() {
-        val currentActivity: Activity? =
-                mReactNativeHost.reactInstanceManager.currentReactContext?.currentActivity
-        if (currentActivity == null) {
-            return
+        fun getAppVersion(context: Context): String? {
+            val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+            return packageInfo.versionName
         }
 
-        currentActivity.runOnUiThread { currentActivity.recreate() }
-    }
-    private var mLifecycleEventListener: LifecycleEventListener? = null
-
-    private fun clearLifecycleEventListener() {
-        if (mLifecycleEventListener != null) {
-            mReactNativeHost.reactInstanceManager.currentReactContext?.removeLifecycleEventListener(
-                    mLifecycleEventListener
-            )
-            mLifecycleEventListener = null
+        private fun setBundleURL(
+            context: Context,
+            bundleURL: String?,
+        ) {
+            val sharedPreferences =
+                context.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
+            with(sharedPreferences.edit()) {
+                putString("HotUpdaterBundleURL", bundleURL)
+                apply()
+            }
         }
-    }
-
-    private fun setJSBundle(instanceManager: ReactInstanceManager, latestJSBundleFile: String?) {
-
-        try {
-            var latestJSBundleLoader: JSBundleLoader? = null
 
-            if (latestJSBundleFile != null && latestJSBundleFile.lowercase().startsWith("assets://")
-            ) {
-                latestJSBundleLoader =
-                        JSBundleLoader.createAssetLoader(
-                                instanceManager.currentReactContext,
-                                latestJSBundleFile,
-                                false
-                        )
-            } else if (latestJSBundleFile != null) {
-                latestJSBundleLoader = JSBundleLoader.createFileLoader(latestJSBundleFile)
+        private fun extractZipFileAtPath(
+            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("HotUpdater", "Failed to unzip file: ${e.message}")
+                false
             }
-            val bundleLoaderField: Field =
-                    instanceManager::class.java.getDeclaredField("mBundleLoader")
-            bundleLoaderField.isAccessible = true
 
-            if (latestJSBundleLoader != null) {
-                bundleLoaderField.set(instanceManager, latestJSBundleLoader)
+        private fun getCurrentActivity(context: Context): Activity? =
+            if (context is ReactApplicationContext) {
+                context.currentActivity
             } else {
-                bundleLoaderField.set(instanceManager, null)
+                null
             }
-        } catch (e: Exception) {
-            throw IllegalAccessException("Could not setJSBundle")
-        }
-    }
-
-    fun initializeOnAppUpdate() {
-        val sharedPreferences =
-                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
 
-        val currentVersion = getAppVersion()
-        val savedVersion = sharedPreferences.getString("HotUpdaterAppVersion", null)
+        fun reload(context: Context) {
+            val activity: Activity? = getCurrentActivity(context)
+            val reactIntegrationManager = ReactIntegrationManager(context)
 
-        if (currentVersion != savedVersion) {
-            val editor = sharedPreferences.edit()
-            editor.remove("HotUpdaterBundleURL")
-            editor.remove("HotUpdaterBundleVersion")
-            editor.putString("HotUpdaterAppVersion", currentVersion)
-            editor.apply()
-        }
-    }
+            val reactApplication: ReactApplication = reactIntegrationManager.getReactApplication(activity?.application)
+            val bundleURL = getJSBundleFile(context)
 
-    fun reload() {
-        Log.d("HotUpdater", "HotUpdater requested a reload ${getBundleURL()}")
+            reactIntegrationManager.setJSBundle(reactApplication, bundleURL)
 
-        setJSBundle(mReactNativeHost.reactInstanceManager, getBundleURL())
-
-        clearLifecycleEventListener()
-        try {
             Handler(Looper.getMainLooper()).post {
-                try {
-                    mReactNativeHost.reactInstanceManager.recreateReactContextInBackground()
-                } catch (t: Throwable) {
-                    loadBundleLegacy()
-                }
+                reactIntegrationManager.reload(reactApplication)
             }
-        } catch (t: Throwable) {
-            loadBundleLegacy()
         }
-    }
 
-    fun getAppVersion(): String {
-        val packageInfo = mContext.packageManager.getPackageInfo(mContext.packageName, 0)
-        return packageInfo.versionName
-    }
-
-    fun getBundleURL(): String {
-        val sharedPreferences =
-                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
-        val urlString = sharedPreferences.getString("HotUpdaterBundleURL", null)
-        if (urlString.isNullOrEmpty()) {
-            return "assets://index.android.bundle"
-        }
+        public fun getJSBundleFile(context: Context): String {
+            val sharedPreferences =
+                context.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
+            val urlString = sharedPreferences.getString("HotUpdaterBundleURL", null)
+            if (urlString.isNullOrEmpty()) {
+                return "assets://index.android.bundle"
+            }
 
-        return urlString
-    }
+            val file = File(urlString)
+            if (!file.exists()) {
+                setBundleURL(context, null)
+                return "assets://index.android.bundle"
+            }
 
-    private fun setBundleURL(bundleURL: String?) {
-        val sharedPreferences =
-                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
-        with(sharedPreferences.edit()) {
-            putString("HotUpdaterBundleURL", bundleURL)
-            apply()
-        }
-    }
-    private fun setBundleVersion(bundleVersion: String?) {
-        val sharedPreferences =
-                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
-        with(sharedPreferences.edit()) {
-            putString("HotUpdaterBundleVersion", bundleVersion)
-            apply()
+            return urlString
         }
-    }
 
-    fun getBundleVersion(): Double? {
-        val sharedPreferences =
-                mContext.getSharedPreferences("HotUpdaterPrefs", Context.MODE_PRIVATE)
-        val bundleVersion = sharedPreferences.getString("HotUpdaterBundleVersion", null)
-        Log.d("HotUpdater", "Bundle version: $bundleVersion")
-        return if (bundleVersion != null && bundleVersion.isNotEmpty()) {
-            try {
-                bundleVersion.toDouble()
-            } catch (e: Exception) {
-                -1.0
+        fun updateBundle(
+            context: Context,
+            bundleId: String,
+            zipUrl: String,
+            progressCallback: ((Double) -> Unit),
+        ): Boolean {
+            Log.d("HotUpdater", "updateBundle bundleId $bundleId zipUrl $zipUrl")
+            if (zipUrl.isEmpty()) {
+                setBundleURL(context, null)
+                return true
             }
-        } else {
-            -1.0
-        }
-    }
 
-    private fun extractZipFileAtPath(filePath: String, destinationPath: String): Boolean {
-        return 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
-        }
-    }
+            val downloadUrl = URL(zipUrl)
 
-    fun updateBundle(prefix: String, url: String?): Boolean {
-        if (url == null) {
-            setBundleURL(null)
-            setBundleVersion(null)
-            return true
-        }
+            val basePath = stripPrefixFromPath(bundleId, downloadUrl.path)
+            val path = convertFileSystemPathFromBasePath(context, basePath)
 
-        val downloadUrl = URL(url)
-
-        val basePath = stripPrefixFromPath(prefix, downloadUrl.path)
-        val path = convertFileSystemPathFromBasePath(basePath)
+            var connection: HttpURLConnection? = null
+            try {
+                connection = downloadUrl.openConnection() as HttpURLConnection
+                connection.connect()
 
-        val data =
-                try {
-                    downloadUrl.readBytes()
-                } catch (e: Exception) {
-                    Log.d("HotUpdater", "Failed to download data from URL: $url")
+                val totalSize = connection.contentLength
+                if (totalSize <= 0) {
+                    Log.d("HotUpdater", "Invalid content length: $totalSize")
                     return false
                 }
 
-        val file = File(path)
-        try {
-            file.parentFile?.mkdirs()
-            file.writeBytes(data)
-        } catch (e: Exception) {
-            Log.d("HotUpdater", "Failed to save data: ${e.message}")
-            return false
-        }
+                val file = File(path)
+                file.parentFile?.mkdirs()
 
-        val extractedPath = file.parentFile?.path
-        if (extractedPath == null) {
-            return false
-        }
+                connection.inputStream.use { input ->
+                    file.outputStream().use { output ->
+                        val buffer = ByteArray(8 * 1024)
+                        var bytesRead: Int
+                        var totalRead = 0L
 
-        if (!extractZipFileAtPath(path, extractedPath)) {
-            Log.d("HotUpdater", "Failed to extract zip file.")
-            return false
-        }
+                        while (input.read(buffer).also { bytesRead = it } != -1) {
+                            output.write(buffer, 0, bytesRead)
+                            totalRead += bytesRead
+                            val progress = (totalRead.toDouble() / totalSize)
+                            progressCallback.invoke(progress)
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                Log.d("HotUpdater", "Failed to download data from URL: $zipUrl, Error: ${e.message}")
+                return false
+            } finally {
+                connection?.disconnect()
+            }
 
-        val extractedDirectory = File(extractedPath)
-        val indexFile = extractedDirectory.walk().find { it.name == "index.android.bundle" }
+            val extractedPath = File(path).parentFile?.path ?: return false
 
-        if (indexFile != null) {
-            val bundlePath = indexFile.path
-            Log.d("HotUpdater", "Setting bundle URL: $bundlePath")
-            setBundleURL(bundlePath)
-        } else {
-            Log.d("HotUpdater", "index.android.bundle not found.")
-            return false
-        }
+            if (!extractZipFileAtPath(path, extractedPath)) {
+                Log.d("HotUpdater", "Failed to extract zip file.")
+                return false
+            }
 
-        setBundleVersion(prefix)
-        Log.d("HotUpdater", "Downloaded and extracted file successfully.")
+            val extractedDirectory = File(extractedPath)
+            val indexFile = extractedDirectory.walk().find { it.name == "index.android.bundle" }
 
-        return true
+            if (indexFile != null) {
+                val bundlePath = indexFile.path
+                Log.d("HotUpdater", "Setting bundle URL: $bundlePath")
+                setBundleURL(context, bundlePath)
+            } else {
+                Log.d("HotUpdater", "index.android.bundle not found.")
+                return false
+            }
+
+            Log.d("HotUpdater", "Downloaded and extracted file successfully.")
+            return true
+        }
     }
 }

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

@@ -1,45 +1,57 @@
 package com.hotupdater
 
-import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
-
-class HotUpdaterModule internal constructor(context: ReactApplicationContext) :
-    HotUpdaterSpec(context) {
-
-  private val mReactApplicationContext: ReactApplicationContext = context
-
-  override fun getName(): String {
-    return NAME
-  }
-
-  @ReactMethod
-  override fun initializeOnAppUpdate() {
-    HotUpdater.initializeOnAppUpdate()
-  }
-
-  @ReactMethod
-  override fun reload() {
-    HotUpdater.reload()
-  }
-
-  @ReactMethod
-  override fun getAppVersion(callback: Callback) {
-    callback.invoke(HotUpdater.getAppVersion())
-  }
-
-  @ReactMethod
-  override fun getBundleVersion(callback: Callback) {
-    callback.invoke(HotUpdater.getBundleVersion())
-  }
-
-  @ReactMethod
-  override fun updateBundle(prefix: String, url: String?, callback: Callback) {
-    val result = HotUpdater.updateBundle(prefix, url)
-    callback.invoke(result)
-  }
-
-  companion object {
-    const val NAME = "HotUpdater"
-  }
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class HotUpdaterModule internal constructor(
+    context: ReactApplicationContext,
+) : HotUpdaterSpec(context) {
+    private val mReactApplicationContext: ReactApplicationContext = context
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    override fun reload() {
+        HotUpdater.reload(mReactApplicationContext)
+    }
+
+    @ReactMethod
+    override fun getAppVersion(promise: Promise) {
+        promise.resolve(HotUpdater.getAppVersion(mReactApplicationContext))
+    }
+
+    @ReactMethod
+    override fun updateBundle(
+        bundleId: String,
+        zipUrl: String,
+        promise: Promise,
+    ) {
+        val isSuccess =
+            HotUpdater.updateBundle(mReactApplicationContext, bundleId, zipUrl) { progress ->
+                val params =
+                    WritableNativeMap().apply {
+                        putDouble("progress", progress)
+                    }
+
+                this.mReactApplicationContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit("onProgress", params)
+            }
+        promise.resolve(isSuccess)
+    }
+
+    override fun addListener(eventName: String?) {
+        // No-op
+    }
+
+    override fun removeListeners(count: Double) {
+        // No-op
+    }
+
+    companion object {
+        const val NAME = "HotUpdater"
+    }
 }

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

@@ -8,29 +8,30 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 import java.util.HashMap
 
 class HotUpdaterPackage : TurboReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == HotUpdaterModule.NAME) {
-      HotUpdaterModule(reactContext)
-    } else {
-      null
-    }
-  }
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? =
+        if (name == HotUpdaterModule.NAME) {
+            HotUpdaterModule(reactContext)
+        } else {
+            null
+        }
 
-  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-    return ReactModuleInfoProvider {
-      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-      moduleInfos[HotUpdaterModule.NAME] =
-          ReactModuleInfo(
-              HotUpdaterModule.NAME,
-              HotUpdaterModule.NAME,
-              false, // canOverrideExistingModule
-              false, // needsEagerInit
-              true, // hasConstants
-              false, // isCxxModule
-              isTurboModule // isTurboModule
-          )
-      moduleInfos
-    }
-  }
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+        ReactModuleInfoProvider {
+            val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+            val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            moduleInfos[HotUpdaterModule.NAME] =
+                ReactModuleInfo(
+                    HotUpdaterModule.NAME,
+                    HotUpdaterModule.NAME,
+                    false, // canOverrideExistingModule
+                    false, // needsEagerInit
+                    true, // hasConstants
+                    false, // isCxxModule
+                    isTurboModule, // isTurboModule
+                )
+            moduleInfos
+        }
 }

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

@@ -0,0 +1,34 @@
+package com.hotupdater
+
+import android.app.Application
+import android.content.Context
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSBundleLoader
+
+open class ReactIntegrationManagerBase(
+    private val context: Context,
+) {
+    fun getJSBundlerLoader(bundleFileUrl: String): JSBundleLoader? {
+        val bundleLoader: JSBundleLoader?
+
+        if (bundleFileUrl.lowercase().startsWith("assets://")) {
+            bundleLoader =
+                JSBundleLoader.createAssetLoader(
+                    context,
+                    bundleFileUrl,
+                    true,
+                )
+        } else {
+            bundleLoader = JSBundleLoader.createFileLoader(bundleFileUrl)
+        }
+        return bundleLoader
+    }
+
+    public fun getReactApplication(application: Application?): ReactApplication {
+        if (application is ReactApplication) {
+            return application
+        } else {
+            throw IllegalArgumentException("Application does not implement ReactApplication")
+        }
+    }
+}

package/android/src/newarch/HotUpdaterSpec.kt

@@ -2,5 +2,6 @@ package com.hotupdater
 
 import com.facebook.react.bridge.ReactApplicationContext
 
-abstract class HotUpdaterSpec internal constructor(context: ReactApplicationContext) :
-        NativeHotUpdaterSpec(context) {}
+abstract class HotUpdaterSpec internal constructor(
+    context: ReactApplicationContext,
+) : NativeHotUpdaterSpec(context)