pulse-updates 1.0.0

package/android/src/main/java/app/pulse/updates/PulseReactHostFactory.kt

@@ -0,0 +1,116 @@
+package app.pulse.updates
+
+import android.content.Context
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactPackage
+import com.facebook.react.ReactPackageTurboModuleManagerDelegate
+import com.facebook.react.bridge.JSBundleLoader
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.defaults.DefaultComponentsRegistry
+import com.facebook.react.defaults.DefaultTurboModuleManagerDelegate
+import com.facebook.react.fabric.ComponentFactory
+import com.facebook.react.runtime.BindingsInstaller
+import com.facebook.react.runtime.JSRuntimeFactory
+import com.facebook.react.runtime.ReactHostDelegate
+import com.facebook.react.runtime.ReactHostImpl
+import com.facebook.react.runtime.hermes.HermesInstance
+import java.lang.ref.WeakReference
+
+/**
+ * Custom ReactHostDelegate that supports dynamic bundle reloading.
+ *
+ * Unlike DefaultReactHostDelegate which caches the bundle loader at construction time,
+ * this delegate re-queries PulseController every time jsBundleLoader is accessed.
+ * This allows reload() to pick up the new bundle path after an OTA update.
+ */
+@OptIn(UnstableReactNativeAPI::class)
+private class PulseReactHostDelegate(
+    private val weakContext: WeakReference<Context>,
+    override val jsMainModulePath: String,
+    override val reactPackages: List<ReactPackage>,
+    override val jsRuntimeFactory: JSRuntimeFactory = HermesInstance(),
+    override val bindingsInstaller: BindingsInstaller? = null,
+    override val turboModuleManagerDelegateBuilder: ReactPackageTurboModuleManagerDelegate.Builder = DefaultTurboModuleManagerDelegate.Builder(),
+    private val exceptionHandler: (Exception) -> Unit = { throw it }
+) : ReactHostDelegate {
+
+    /**
+     * Override jsBundleLoader to dynamically query PulseController.
+     * This is called every time React Native needs the bundle, including on reload.
+     */
+    override val jsBundleLoader: JSBundleLoader
+        get() {
+            val context = weakContext.get()
+                ?: throw IllegalStateException("Context is no longer available")
+
+            val bundleFile = PulseUpdatesModule.getBundleFile(context)
+
+            return if (bundleFile != null) {
+                pulseLog("PulseReactHostDelegate", "jsBundleLoader: ${bundleFile.absolutePath}")
+                JSBundleLoader.createFileLoader(bundleFile.absolutePath)
+            } else {
+                pulseLog("PulseReactHostDelegate", "jsBundleLoader: using default asset bundle")
+                JSBundleLoader.createAssetLoader(context, "assets://index.android.bundle", true)
+            }
+        }
+
+    override fun handleInstanceException(error: Exception) = exceptionHandler(error)
+}
+
+/**
+ * Factory for creating a ReactHost that supports dynamic bundle reloading.
+ *
+ * Usage in MainApplication:
+ * ```kotlin
+ * override val reactHost: ReactHost
+ *     get() = PulseReactHostFactory.createReactHost(
+ *         applicationContext,
+ *         packages = reactNativeHost.packages, // or getPackages()
+ *         jsMainModuleName = "index",
+ *         useDevSupport = BuildConfig.DEBUG
+ *     )
+ * ```
+ */
+object PulseReactHostFactory {
+
+    @Volatile
+    private var reactHost: ReactHost? = null
+
+    @OptIn(UnstableReactNativeAPI::class)
+    @JvmStatic
+    fun createReactHost(
+        context: Context,
+        packages: List<ReactPackage>,
+        jsMainModuleName: String = "index",
+        useDevSupport: Boolean = false
+    ): ReactHost {
+        if (reactHost == null) {
+            synchronized(this) {
+                if (reactHost == null) {
+                    val weakContext = WeakReference(context.applicationContext)
+
+                    pulseLog("PulseReactHostFactory", "Creating ReactHost with ${packages.size} packages, jsMainModuleName=$jsMainModuleName")
+
+                    val delegate = PulseReactHostDelegate(
+                        weakContext = weakContext,
+                        jsMainModulePath = jsMainModuleName,
+                        reactPackages = packages
+                    )
+
+                    val componentFactory = ComponentFactory()
+                    DefaultComponentsRegistry.register(componentFactory)
+
+                    reactHost = ReactHostImpl(
+                        context.applicationContext,
+                        delegate,
+                        componentFactory,
+                        true, // allowPackagerServerAccess
+                        useDevSupport
+                    )
+                }
+            }
+        }
+        return reactHost!!
+    }
+}

package/android/src/main/java/app/pulse/updates/PulseUpdatesModule.kt

@@ -0,0 +1,314 @@
+package app.pulse.updates
+
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * PulseUpdates React Native Module
+ * Bridges PulseController to React Native
+ */
+class PulseUpdatesModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        private const val TAG = "PulseUpdates"
+        const val NAME = "PulseUpdates"
+
+        /**
+         * Get the bundle file path for React Native initialization
+         * This is called before JS starts, so we need to set up context first
+         */
+        fun getBundleFile(context: android.content.Context): java.io.File? {
+            val controller = PulseController.getInstance()
+            if (!controller.isStarted) {
+                // Initialize context before starting (needed for database, embedded manifest, etc.)
+                controller.initializeContext(context)
+                controller.initializeWithoutStarting()
+            }
+            return controller.getBundleFile()
+        }
+    }
+
+    override fun getName(): String = NAME
+
+    override fun getConstants(): MutableMap<String, Any>? {
+        return buildState().toHashMap() as? MutableMap<String, Any>
+    }
+
+    // MARK: - Configuration
+
+    @ReactMethod
+    fun configure(
+        enabled: Boolean,
+        updateUrl: String,
+        runtimeVersion: String,
+        checkOnLaunch: String,
+        launchWaitMs: Int,
+        channel: String?,
+        signingKeyId: String?,
+        signingPublicKey: String?
+    ) {
+        val config = PulseUpdatesConfig(
+            enabled = enabled,
+            updateUrl = updateUrl,
+            runtimeVersion = runtimeVersion.ifEmpty { nativeRuntimeVersion() },
+            checkOnLaunch = checkOnLaunch,
+            launchWaitMs = launchWaitMs,
+            channel = channel,
+            signingKeyId = signingKeyId,
+            signingPublicKey = signingPublicKey
+        )
+
+        PulseController.getInstance().configure(reactContext.applicationContext, config)
+        PulseController.getInstance().start()
+
+        pulseLog(TAG, "Configured enabled=$enabled url=$updateUrl runtime=${config.runtimeVersion}")
+    }
+
+    // MARK: - Get State
+
+    @ReactMethod
+    fun getStateAsync(promise: Promise) {
+        promise.resolve(buildState())
+    }
+
+    private fun buildState(): WritableMap {
+        val controller = PulseController.getInstance()
+        val state = Arguments.createMap()
+
+        // Match expo-updates constants structure
+        state.putBoolean("isEnabled", controller.config?.enabled ?: false)
+        state.putBoolean("isEmbeddedLaunch", controller.isEmbeddedLaunch)
+        // expo-updates calls this isUsingEmbeddedAssets
+        state.putBoolean("isUsingEmbeddedAssets", controller.isEmbeddedLaunch)
+        state.putString("runtimeVersion", controller.config?.runtimeVersion ?: nativeRuntimeVersion())
+
+        controller.launchedUpdate?.updateId?.let {
+            state.putString("updateId", it)
+        } ?: state.putNull("updateId")
+
+        state.putString("channel", controller.config?.channel)
+
+        // Return manifest JSON string for metadata (build number, etc.)
+        controller.launchedManifestJson?.let {
+            state.putString("manifestString", it)
+        } ?: state.putNull("manifestString")
+
+        controller.launchedUpdate?.commitTime?.let {
+            state.putDouble("commitTime", it.toDouble())
+        } ?: state.putNull("commitTime")
+
+        // Local assets map for expo-asset compatibility
+        // Key: asset key from manifest, Value: local file:// URL
+        val localAssetsMap = Arguments.createMap()
+        controller.localAssets.forEach { (key, value) ->
+            localAssetsMap.putString(key, value)
+        }
+        state.putMap("localAssets", localAssetsMap)
+
+        return state
+    }
+
+    // MARK: - Check for Update
+
+    @ReactMethod
+    fun checkForUpdateAsync(promise: Promise) {
+        PulseController.getInstance().checkForUpdate { result ->
+            result.fold(
+                onSuccess = { checkResult ->
+                    val response = Arguments.createMap()
+                    response.putBoolean("isAvailable", checkResult.isAvailable)
+
+                    checkResult.manifest?.let { manifest ->
+                        try {
+                            val json = org.json.JSONObject().apply {
+                                put("updateId", manifest.updateId)
+                                put("runtimeVersion", manifest.runtimeVersion)
+                                put("createdAt", manifest.createdAt)
+                            }
+                            response.putString("manifestString", json.toString())
+                        } catch (e: Exception) {
+                            // Ignore serialization errors
+                        }
+                    }
+
+                    if (checkResult.isRollback) {
+                        response.putBoolean("isRollback", true)
+                        response.putString("failedReason", checkResult.failedReason ?: "Unknown")
+                    }
+
+                    promise.resolve(response)
+                },
+                onFailure = { error ->
+                    promise.reject("E_CHECK_UPDATE", error.message, error)
+                }
+            )
+        }
+    }
+
+    // MARK: - Fetch Update
+
+    @ReactMethod
+    fun fetchUpdateAsync(promise: Promise) {
+        PulseController.getInstance().fetchUpdate { result ->
+            result.fold(
+                onSuccess = { fetchResult ->
+                    val response = Arguments.createMap()
+                    response.putBoolean("isNew", fetchResult.isNew)
+
+                    fetchResult.manifest?.let { manifest ->
+                        try {
+                            val json = org.json.JSONObject().apply {
+                                put("updateId", manifest.updateId)
+                                put("runtimeVersion", manifest.runtimeVersion)
+                                put("createdAt", manifest.createdAt)
+                            }
+                            response.putString("manifestString", json.toString())
+                        } catch (e: Exception) {
+                            // Ignore serialization errors
+                        }
+                    }
+
+                    promise.resolve(response)
+                },
+                onFailure = { error ->
+                    promise.reject("E_FETCH_UPDATE", error.message, error)
+                }
+            )
+        }
+    }
+
+    // MARK: - Reload
+
+    @ReactMethod
+    fun reloadAsync(promise: Promise) {
+        // Re-select the best update before reloading
+        PulseController.getInstance().reload { success ->
+            val newBundlePath = PulseController.getInstance().launchAssetFile?.absolutePath
+            pulseLog(TAG, "reloadAsync: controller reload success=$success launchAssetFile=$newBundlePath")
+
+            UiThreadUtil.runOnUiThread {
+                try {
+                    val application = reactContext.currentActivity?.application
+                        ?: reactContext.applicationContext as? android.app.Application
+
+                    val reactApplication = application as? com.facebook.react.ReactApplication
+                    if (reactApplication == null) {
+                        pulseLogError(TAG, "reloadAsync: ReactApplication is null")
+                        promise.reject("E_RELOAD", "Could not get ReactApplication", null)
+                        return@runOnUiThread
+                    }
+
+                    // Try new architecture first (ReactHost) - like expo-updates does
+                    try {
+                        val reactHost = reactApplication.javaClass.getMethod("getReactHost").invoke(reactApplication)
+                        if (reactHost != null) {
+                            pulseLog(TAG, "reloadAsync: using ReactHost.reload()")
+
+                            // Check lifecycle state and resume if needed (like expo does)
+                            val currentActivity = reactContext.currentActivity
+                            try {
+                                val lifecycleState = reactHost.javaClass.getMethod("getLifecycleState").invoke(reactHost)
+                                val resumedState = Class.forName("com.facebook.react.common.LifecycleState")
+                                    .getField("RESUMED").get(null)
+                                if (lifecycleState != resumedState && currentActivity != null) {
+                                    reactHost.javaClass.getMethod("onHostResume", android.app.Activity::class.java)
+                                        .invoke(reactHost, currentActivity)
+                                }
+                            } catch (e: Exception) {
+                                pulseLogWarn(TAG, "reloadAsync: could not check/resume lifecycle: ${e.message}")
+                            }
+
+                            reactHost.javaClass.getMethod("reload", String::class.java)
+                                .invoke(reactHost, "PulseUpdates reload")
+                            promise.resolve(null)
+                            return@runOnUiThread
+                        }
+                    } catch (e: Exception) {
+                        pulseLog(TAG, "reloadAsync: ReactHost not available: ${e.message}")
+                    }
+
+                    // Fall back to old architecture (ReactNativeHost)
+                    val reactNativeHost = reactApplication.reactNativeHost
+                    if (reactNativeHost != null) {
+                        pulseLog(TAG, "reloadAsync: using ReactNativeHost.recreateReactContextInBackground()")
+
+                        // Update the bundle loader via reflection (needed for bridge mode)
+                        if (newBundlePath != null) {
+                            try {
+                                val instanceManager = reactNativeHost.reactInstanceManager
+                                if (instanceManager != null) {
+                                    val jsBundleLoaderField = instanceManager.javaClass.getDeclaredField("mBundleLoader")
+                                    jsBundleLoaderField.isAccessible = true
+                                    jsBundleLoaderField[instanceManager] = com.facebook.react.bridge.JSBundleLoader.createFileLoader(newBundlePath)
+                                    pulseLog(TAG, "reloadAsync: Updated mBundleLoader via reflection")
+                                }
+                            } catch (e: Exception) {
+                                pulseLogWarn(TAG, "reloadAsync: Could not update mBundleLoader: ${e.message}")
+                            }
+                        }
+
+                        reactNativeHost.reactInstanceManager?.recreateReactContextInBackground()
+                        promise.resolve(null)
+                    } else {
+                        pulseLogError(TAG, "reloadAsync: ReactNativeHost is null")
+                        promise.reject("E_RELOAD", "ReactNativeHost is null", null)
+                    }
+                } catch (e: Exception) {
+                    pulseLogError(TAG, "reloadAsync error: ${e.message}")
+                    e.printStackTrace()
+                    promise.reject("E_RELOAD", e.message, e)
+                }
+            }
+        }
+    }
+
+    // MARK: - Health
+
+    @ReactMethod
+    fun markAppReady(promise: Promise) {
+        PulseController.getInstance().markAppReady()
+        promise.resolve(null)
+    }
+
+    @ReactMethod
+    fun reportLaunchFailure(reason: String, promise: Promise) {
+        PulseController.getInstance().reportLaunchFailure(reason)
+        promise.resolve(null)
+    }
+
+    // MARK: - Event Emitter Support
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for RN event emitter
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for RN event emitter
+    }
+
+    private fun sendEvent(eventName: String, params: WritableMap?) {
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    // MARK: - Helpers
+
+    private fun nativeRuntimeVersion(): String {
+        return try {
+            val packageInfo = reactContext.packageManager.getPackageInfo(reactContext.packageName, 0)
+            packageInfo.versionName ?: "unknown"
+        } catch (e: Exception) {
+            "unknown"
+        }
+    }
+}
+
+private object UiThreadUtil {
+    fun runOnUiThread(runnable: Runnable) {
+        android.os.Handler(android.os.Looper.getMainLooper()).post(runnable)
+    }
+}

package/android/src/main/java/app/pulse/updates/PulseUpdatesPackage.kt

@@ -0,0 +1,16 @@
+package app.pulse.updates
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PulseUpdatesPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(PulseUpdatesModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}