@nebula-rn/host 0.0.1

package/android/src/main/java/com/hectorzhuang/nebula/NebulaConfig.kt

@@ -0,0 +1,324 @@
+package com.hectorzhuang.nebula
+
+import android.app.Application
+import java.io.File
+import java.io.FileOutputStream
+import java.net.URI
+import java.net.URL
+import java.net.URLConnection
+import java.util.zip.ZipInputStream
+import java.util.concurrent.ConcurrentHashMap
+
+object NebulaConfig {
+    private const val PREFS_NAME = "nebula.config"
+    private const val SERVER_BASE_URL_KEY = "_serverBaseURL"
+    private val installedApps = ConcurrentHashMap<String, NebulaInstalledApp>()
+    private lateinit var application: Application
+
+    var serverBaseURL: String?
+        get() = application.getSharedPreferences(PREFS_NAME, 0).getString(SERVER_BASE_URL_KEY, null)
+        set(value) {
+            val prefs = application.getSharedPreferences(PREFS_NAME, 0)
+            val normalized = normalizeServerBaseURL(value)
+            if (normalized == null) {
+                prefs.edit().remove(SERVER_BASE_URL_KEY).apply()
+            } else {
+                prefs.edit().putString(SERVER_BASE_URL_KEY, normalized).apply()
+            }
+        }
+
+    fun initialize(app: Application) {
+        application = app
+        restoreInstalledApps()
+    }
+
+    fun sandboxDir(appId: String): File {
+        val dir = File(application.filesDir, "nebula/$appId")
+        if (!dir.exists()) {
+            dir.mkdirs()
+        }
+        return dir
+    }
+
+    fun bundleFile(appId: String): File = File(sandboxDir(appId), "index.android.bundle")
+
+    fun installApp(
+        appId: String,
+        bundleURL: String,
+        connectToURLMetroServer: Boolean = false,
+    ): NebulaInstalledApp {
+        val sandboxDir = sandboxDir(appId)
+        val bundleFile = bundleFile(appId)
+        downloadToFile(bundleURL, bundleFile)
+        var manifest: NebulaManifest? = null
+        deriveManifestUrl(bundleURL)?.let { manifestURL ->
+            runCatching {
+                downloadToFile(manifestURL, File(sandboxDir, "app.json"))
+                manifest = NebulaManifestManager.loadManifest(appId, sandboxDir)
+            }
+        }
+
+        val installed =
+            NebulaInstalledApp(
+                appId = appId,
+                mode = if (connectToURLMetroServer) "development" else "production",
+                bundlePath = bundleFile.absolutePath,
+                sourceUrl = bundleURL,
+                version = if (connectToURLMetroServer) null else manifest?.version,
+                updateStrategy =
+                    if (connectToURLMetroServer) {
+                        "manual"
+                    } else {
+                        manifest?.updateStrategy ?: "manual"
+                    },
+            )
+        installedApps[appId] = installed
+        persistInstalledApp(installed)
+        return installed
+    }
+
+    fun installApp(
+        appId: String,
+        bundleURL: String,
+        manifestURL: String,
+        assetsURL: String,
+        connectToURLMetroServer: Boolean = false,
+    ): NebulaInstalledApp {
+        val sandboxDir = sandboxDir(appId)
+        val bundleFile = bundleFile(appId)
+        downloadToFile(bundleURL, bundleFile)
+        downloadToFile(manifestURL, File(sandboxDir, "app.json"))
+        if (!connectToURLMetroServer) {
+            downloadAndExtractAssets(assetsURL, sandboxDir)
+        }
+        val manifest = NebulaManifestManager.loadManifest(appId, sandboxDir)
+        val installed =
+            NebulaInstalledApp(
+                appId = appId,
+                mode = if (connectToURLMetroServer) "development" else "production",
+                bundlePath = bundleFile.absolutePath,
+                sourceUrl = bundleURL,
+                version = if (connectToURLMetroServer) null else manifest?.version,
+                updateStrategy =
+                    if (connectToURLMetroServer) {
+                        "manual"
+                    } else {
+                        manifest?.updateStrategy ?: "manual"
+                    },
+            )
+        installedApps[appId] = installed
+        persistInstalledApp(installed)
+        return installed
+    }
+
+    fun getInstalledApp(appId: String): NebulaInstalledApp? = installedApps[appId]
+
+    fun isDevelopmentMode(installedApp: NebulaInstalledApp): Boolean {
+        return installedApp.mode.equals("development", ignoreCase = true)
+    }
+
+    fun getDevServerHost(installedApp: NebulaInstalledApp): String? {
+        if (!isDevelopmentMode(installedApp)) {
+            return null
+        }
+
+        val uri = runCatching { URI(installedApp.sourceUrl) }.getOrNull() ?: return null
+        val host = uri.host ?: return null
+        val port = uri.port
+        return if (port > 0) "$host:$port" else host
+    }
+
+    fun getDevModulePath(installedApp: NebulaInstalledApp): String? {
+        if (!isDevelopmentMode(installedApp)) {
+            return null
+        }
+
+        val uri = runCatching { URI(installedApp.sourceUrl) }.getOrNull() ?: return null
+        val path = uri.path?.trim().orEmpty()
+        if (path.isEmpty()) {
+            return null
+        }
+
+        val trimmedPath = path.trimStart('/')
+        return if (trimmedPath.endsWith(".bundle")) {
+            trimmedPath.removeSuffix(".bundle")
+        } else {
+            trimmedPath
+        }
+    }
+
+    fun installedAppIds(): List<String> = installedApps.keys.sorted()
+
+    fun clearApp(appId: String) {
+        installedApps.remove(appId)
+        application.getSharedPreferences(PREFS_NAME, 0).edit().remove(appId).apply()
+        NebulaManifestManager.removeManifest(appId)
+        sandboxDir(appId).deleteRecursively()
+    }
+
+    private fun persistInstalledApp(installedApp: NebulaInstalledApp) {
+        val json =
+            """
+      {"appId":"${installedApp.appId}","mode":"${installedApp.mode}","bundlePath":"${installedApp.bundlePath}","sourceUrl":"${installedApp.sourceUrl}","version":${installedApp.version?.let { "\"$it\"" } ?: "null"},"updateStrategy":"${installedApp.updateStrategy}"}
+      """.trimIndent()
+        application.getSharedPreferences(PREFS_NAME, 0).edit().putString(installedApp.appId, json)
+            .apply()
+    }
+
+    private fun restoreInstalledApps() {
+        val prefs = application.getSharedPreferences(PREFS_NAME, 0).all
+        prefs.forEach { (key, value) ->
+            if (key == SERVER_BASE_URL_KEY) {
+                return@forEach
+            }
+            val raw = value as? String ?: return@forEach
+            runCatching {
+                val json = org.json.JSONObject(raw)
+                installedApps[key] =
+                    NebulaInstalledApp(
+                        appId = json.optString("appId", key),
+                        mode = json.optString("mode", "production"),
+                        bundlePath = json.optString("bundlePath"),
+                        sourceUrl = json.optString("sourceUrl"),
+                        version = json.optString("version", null),
+                        updateStrategy = json.optString("updateStrategy", "manual"),
+                    )
+                NebulaManifestManager.loadManifest(key, sandboxDir(key))
+            }
+        }
+    }
+
+    private fun deriveManifestUrl(bundleURL: String): String? {
+        return runCatching {
+            val uri = URI(bundleURL)
+            val path = uri.path ?: return null
+            val parentPath = path.substringBeforeLast('/', "")
+            if (parentPath.isEmpty()) {
+                return null
+            }
+            URI(
+                uri.scheme,
+                uri.authority,
+                "$parentPath/app.json",
+                null,
+                null,
+            ).toString()
+        }.getOrNull()
+    }
+
+    fun resolveRemoteUrl(rawURL: String): String {
+        val trimmedURL = rawURL.trim()
+        if (trimmedURL.isEmpty() || trimmedURL.startsWith("file://")) {
+            return rawURL
+        }
+
+        val base = serverBaseURL ?: return trimmedURL
+        val baseUri = runCatching { URI(base) }.getOrNull() ?: return trimmedURL
+
+        if (trimmedURL.startsWith("/")) {
+            return URI(baseUri.scheme, baseUri.authority, trimmedURL, null, null).toString()
+        }
+
+        val remoteUri = runCatching { URI(trimmedURL) }.getOrNull()
+        if (remoteUri?.scheme?.lowercase() in listOf("http", "https")) {
+            if (shouldReplaceRemoteHost(remoteUri?.host)) {
+                return URI(
+                    baseUri.scheme,
+                    baseUri.authority,
+                    remoteUri?.path,
+                    remoteUri?.query,
+                    remoteUri?.fragment,
+                ).toString()
+            }
+            return trimmedURL
+        }
+
+        val normalizedBasePath = baseUri.path?.trim('/').orEmpty()
+        val normalizedRelativePath = trimmedURL.trim('/')
+        val mergedPath =
+            listOf(normalizedBasePath, normalizedRelativePath).filter { it.isNotEmpty() }
+                .joinToString("/")
+        return URI(baseUri.scheme, baseUri.authority, "/$mergedPath", null, null).toString()
+    }
+
+    private fun downloadToFile(source: String, destination: File) {
+        destination.parentFile?.mkdirs()
+        val connection = openConnection(source)
+        connection.getInputStream().use { input ->
+            FileOutputStream(destination).use { output ->
+                input.copyTo(output)
+            }
+        }
+    }
+
+    private fun openConnection(source: String): URLConnection {
+        return if (source.startsWith("file://")) {
+            URI(source).toURL().openConnection()
+        } else if (source.startsWith("/")) {
+            File(source).toURI().toURL().openConnection()
+        } else {
+            URL(source).openConnection().apply {
+                connectTimeout = 15000
+                readTimeout = 15000
+            }
+        }
+    }
+
+    fun normalizeServerBaseURL(rawURL: String?): String? {
+        val trimmedURL = rawURL?.trim().orEmpty()
+        if (trimmedURL.isEmpty()) {
+            return null
+        }
+
+        val uri = runCatching { URI(trimmedURL) }.getOrNull() ?: return null
+        val scheme = uri.scheme?.lowercase() ?: return null
+        if (scheme != "http" && scheme != "https") {
+            return null
+        }
+        val host = uri.host ?: return null
+        val normalizedPath = uri.path?.trimEnd('/').orEmpty()
+        return URI(
+            scheme,
+            uri.userInfo,
+            host,
+            uri.port,
+            normalizedPath,
+            null,
+            null,
+        ).toString()
+    }
+
+    private fun shouldReplaceRemoteHost(host: String?): Boolean {
+        val normalizedHost = host?.lowercase() ?: return false
+        return normalizedHost == "localhost" || normalizedHost == "127.0.0.1" || normalizedHost == "0.0.0.0"
+    }
+
+    private fun downloadAndExtractAssets(assetsURL: String, sandboxDir: File) {
+        val zipFile = File(sandboxDir, "assets.zip")
+        try {
+            downloadToFile(assetsURL, zipFile)
+            extractZipFile(zipFile, sandboxDir)
+        } finally {
+            zipFile.delete()
+        }
+    }
+
+    private fun extractZipFile(zipFile: File, destinationDir: File) {
+        ZipInputStream(zipFile.inputStream().buffered()).use { zipStream ->
+            var entry = zipStream.nextEntry
+            while (entry != null) {
+                val entryFile = File(destinationDir, entry.name)
+                if (entry.isDirectory) {
+                    entryFile.mkdirs()
+                } else {
+                    entryFile.parentFile?.mkdirs()
+                    FileOutputStream(entryFile).use { output ->
+                        zipStream.copyTo(output)
+                    }
+                }
+                zipStream.closeEntry()
+                entry = zipStream.nextEntry
+            }
+        }
+    }
+}

package/android/src/main/java/com/hectorzhuang/nebula/NebulaEventHub.kt

@@ -0,0 +1,49 @@
+package com.hectorzhuang.nebula
+
+import java.lang.ref.WeakReference
+import java.util.UUID
+import java.util.concurrent.CopyOnWriteArrayList
+
+data class NebulaBridgeMessage(
+  val direction: String,
+  val appId: String,
+  val message: Map<String, Any?>,
+  val sourceEmitterId: String,
+  val timestamp: Double,
+)
+
+data class NebulaPageLifecycleEvent(
+  val appId: String,
+  val instanceId: String,
+  val routePath: String,
+  val type: String,
+)
+
+object NebulaEventHub {
+  private val moduleRefs = CopyOnWriteArrayList<WeakReference<NebulaNativeModule>>()
+
+  fun nextEmitterId(): String = UUID.randomUUID().toString()
+
+  fun register(module: NebulaNativeModule) {
+    cleanup()
+    moduleRefs.add(WeakReference(module))
+  }
+
+  fun unregister(module: NebulaNativeModule) {
+    moduleRefs.removeAll { it.get() == null || it.get() === module }
+  }
+
+  fun publishBridgeMessage(message: NebulaBridgeMessage) {
+    cleanup()
+    moduleRefs.forEach { it.get()?.handleBridgeMessage(message) }
+  }
+
+  fun publishPageLifecycle(event: NebulaPageLifecycleEvent) {
+    cleanup()
+    moduleRefs.forEach { it.get()?.handlePageLifecycle(event) }
+  }
+
+  private fun cleanup() {
+    moduleRefs.removeAll { it.get() == null }
+  }
+}

package/android/src/main/java/com/hectorzhuang/nebula/NebulaHost.kt

@@ -0,0 +1,145 @@
+package com.hectorzhuang.nebula
+
+import android.app.Activity
+import android.app.Application
+import android.content.pm.ApplicationInfo
+import android.os.Bundle
+import android.preference.PreferenceManager
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactPackage
+import java.net.URL
+import java.util.concurrent.Executors
+import org.json.JSONObject
+
+interface NebulaHostDelegate {
+  fun isDebugBuild(): Boolean = false
+
+  fun createMiniAppPackages(application: Application): List<ReactPackage> = emptyList()
+}
+
+object NebulaHost {
+  private lateinit var application: Application
+  private var delegate: NebulaHostDelegate? = null
+  @Volatile private var topActivity: Activity? = null
+  @Volatile private var hostModalActivity: Activity? = null
+  private val ioExecutor = Executors.newSingleThreadExecutor()
+
+  fun initialize(app: Application, delegate: NebulaHostDelegate? = null) {
+    application = app
+    this.delegate = delegate
+    NebulaConfig.initialize(app)
+    NebulaAppManager.initialize(app, delegate)
+    app.registerActivityLifecycleCallbacks(
+      object : Application.ActivityLifecycleCallbacks {
+        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) = Unit
+        override fun onActivityStarted(activity: Activity) = Unit
+        override fun onActivityResumed(activity: Activity) {
+          topActivity = activity
+        }
+        override fun onActivityPaused(activity: Activity) = Unit
+        override fun onActivityStopped(activity: Activity) = Unit
+        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) = Unit
+        override fun onActivityDestroyed(activity: Activity) {
+          if (topActivity === activity) {
+            topActivity = null
+          }
+        }
+      },
+    )
+  }
+
+  fun currentActivity(): Activity? = topActivity
+
+  fun presentedHostModalActivity(): Activity? = hostModalActivity
+
+  fun setPresentedHostModalActivity(activity: Activity?) {
+    hostModalActivity = activity
+  }
+
+  fun isDebugBuild(): Boolean =
+    delegate?.isDebugBuild()
+      ?: ((application.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0)
+
+  fun createMiniAppPackages(): List<ReactPackage> = delegate?.createMiniAppPackages(application) ?: emptyList()
+
+  fun resolveHostReactHost(app: Application = application): ReactHost {
+    return when (app) {
+      is ReactApplication -> app.reactHost ?: error("ReactApplication.reactHost is null")
+      else -> error("Application does not implement ReactApplication")
+    }
+  }
+
+  fun installApp(
+    appId: String,
+    bundleURL: String,
+    connectToURLMetroServer: Boolean = false,
+  ): NebulaInstalledApp {
+    val installedApp = NebulaConfig.installApp(appId, bundleURL, connectToURLMetroServer)
+    NebulaAppManager.invalidate(appId)
+    return installedApp
+  }
+
+  fun preloadApp(appId: String) {
+    NebulaAppManager.preload(appId)
+  }
+
+  fun closeApp(appId: String) {
+    NebulaRouter.closeApp(appId).getOrThrow()
+  }
+
+  fun uninstallApp(appId: String) {
+    NebulaAppManager.invalidate(appId)
+    NebulaConfig.clearApp(appId)
+  }
+
+  fun openApp(activity: Activity, appId: String, initialProps: Map<String, Any?> = emptyMap()) {
+    val routePath =
+      NebulaManifestManager.getManifest(appId)?.entryPagePath
+        ?: NebulaManifestManager.loadManifest(appId, NebulaConfig.sandboxDir(appId))?.entryPagePath
+        ?: "/"
+    NebulaRouter.openApp(activity, appId, routePath, initialProps)
+  }
+
+  fun installedApps(): List<String> = NebulaConfig.installedAppIds()
+
+  fun handleIncomingUrl(activity: Activity, url: android.net.Uri?): Boolean {
+    if (url == null) {
+      return false
+    }
+    val isReviewInstallLink =
+      (url.host == "review" && url.path.orEmpty().startsWith("/install/")) ||
+      (url.host == "miniapp" && url.path.orEmpty().startsWith("/install/")) ||
+      url.path.orEmpty().startsWith("/review/install/")
+    if (!isReviewInstallLink) {
+      return false
+    }
+
+    val installUrl = url.getQueryParameter("installUrl") ?: return false
+    ioExecutor.execute {
+      runCatching {
+        val resolvedInstallUrl = NebulaConfig.resolveRemoteUrl(installUrl)
+        val payload = JSONObject(URL(resolvedInstallUrl).readText())
+        val appId = payload.getString("appId")
+        val bundles = payload.optJSONObject("bundles")
+        val rawBundleUrl =
+          bundles?.optString("android")?.takeIf { it.isNotBlank() }
+            ?: payload.optString("bundleUrl").takeIf { it.isNotBlank() }
+            ?: error("Missing Android bundle URL in review install payload")
+        val bundleUrl = NebulaConfig.resolveRemoteUrl(rawBundleUrl)
+        val manifestUrl = NebulaConfig.resolveRemoteUrl(payload.getString("manifestUrl"))
+        val assetsUrl =
+            payload.optJSONObject("assetsUrl")?.optString("android")?.takeIf { it.isNotBlank() }
+            ?: error("Missing Android assets URL in review install payload")
+        val resolvedAssetsUrl = NebulaConfig.resolveRemoteUrl(assetsUrl)
+        NebulaConfig.installApp(appId, bundleUrl, manifestUrl, resolvedAssetsUrl, false)
+        activity.runOnUiThread {
+          openApp(activity, appId)
+        }
+      }.onFailure { error ->
+        error.printStackTrace()
+      }
+    }
+    return true
+  }
+}

package/android/src/main/java/com/hectorzhuang/nebula/NebulaHostModalActivity.kt

@@ -0,0 +1,178 @@
+package com.hectorzhuang.nebula
+
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Bundle
+import android.view.View
+import android.widget.FrameLayout
+import androidx.appcompat.app.AppCompatActivity
+import com.facebook.react.ReactHost
+import com.facebook.react.interfaces.fabric.ReactSurface
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import org.json.JSONObject
+
+class NebulaHostModalActivity :
+  AppCompatActivity(),
+  DefaultHardwareBackBtnHandler,
+  PermissionAwareActivity {
+  companion object {
+    private const val EXTRA_MODULE_NAME = "nebula.modal.module_name"
+    private const val EXTRA_INITIAL_PROPS = "nebula.modal.initial_props"
+
+    fun createIntent(
+      context: Context,
+      moduleName: String,
+      initialProps: Map<String, Any?>,
+    ): Intent {
+      return Intent(context, NebulaHostModalActivity::class.java).apply {
+        putExtra(EXTRA_MODULE_NAME, moduleName)
+        putExtra(EXTRA_INITIAL_PROPS, JSONObject(initialProps).toString())
+      }
+    }
+  }
+
+  private lateinit var rootHost: FrameLayout
+  private var reactSurface: ReactSurface? = null
+  private var permissionListener: PermissionListener? = null
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    val moduleName = intent.getStringExtra(EXTRA_MODULE_NAME) ?: error("Missing moduleName")
+    val initialProps = parseJsonMap(intent.getStringExtra(EXTRA_INITIAL_PROPS)).toBundle()
+
+    rootHost = FrameLayout(this).apply {
+      id = View.generateViewId()
+      layoutParams =
+        FrameLayout.LayoutParams(
+          FrameLayout.LayoutParams.MATCH_PARENT,
+          FrameLayout.LayoutParams.MATCH_PARENT,
+        )
+      setBackgroundColor(android.graphics.Color.TRANSPARENT)
+    }
+
+    setContentView(rootHost)
+
+    reactSurface = resolveReactHost().createSurface(this, moduleName, initialProps)
+    reactSurface?.start()
+    reactSurface?.view?.let { view ->
+      rootHost.addView(
+        view,
+        FrameLayout.LayoutParams(
+          FrameLayout.LayoutParams.MATCH_PARENT,
+          FrameLayout.LayoutParams.MATCH_PARENT,
+        ),
+      )
+    }
+
+    NebulaHost.setPresentedHostModalActivity(this)
+  }
+
+  override fun onResume() {
+    super.onResume()
+    resolveReactHost().onHostResume(this, this)
+  }
+
+  override fun onPause() {
+    resolveReactHost().onHostPause(this)
+    super.onPause()
+  }
+
+  override fun onDestroy() {
+    reactSurface?.stop()
+    reactSurface?.clear()
+    reactSurface = null
+    resolveReactHost().onHostDestroy(this)
+    if (NebulaHost.presentedHostModalActivity() === this) {
+      NebulaHost.setPresentedHostModalActivity(null)
+    }
+    super.onDestroy()
+  }
+
+  override fun invokeDefaultOnBackPressed() {
+    super.onBackPressed()
+  }
+
+  override fun checkPermission(permission: String, pid: Int, uid: Int): Int {
+    return super.checkPermission(permission, pid, uid)
+  }
+
+  override fun checkSelfPermission(permission: String): Int {
+    return if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+      super.checkSelfPermission(permission)
+    } else {
+      PackageManager.PERMISSION_GRANTED
+    }
+  }
+
+  override fun shouldShowRequestPermissionRationale(permission: String): Boolean {
+    return if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+      super.shouldShowRequestPermissionRationale(permission)
+    } else {
+      false
+    }
+  }
+
+  override fun requestPermissions(
+    permissions: Array<String>,
+    requestCode: Int,
+    listener: PermissionListener?,
+  ) {
+    permissionListener = listener
+    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
+      super.requestPermissions(permissions, requestCode)
+    }
+  }
+
+  override fun onRequestPermissionsResult(
+    requestCode: Int,
+    permissions: Array<String>,
+    grantResults: IntArray,
+  ) {
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    val shouldClear =
+      permissionListener?.onRequestPermissionsResult(
+        requestCode,
+        permissions,
+        grantResults,
+      ) ?: false
+    if (shouldClear) {
+      permissionListener = null
+    }
+  }
+
+  private fun resolveReactHost(): ReactHost {
+    return NebulaHost.resolveHostReactHost(application)
+  }
+
+  private fun parseJsonMap(raw: String?): Map<String, Any?> {
+    if (raw.isNullOrBlank()) {
+      return emptyMap()
+    }
+    return NebulaManifestManager.jsonObjectToMap(JSONObject(raw))
+  }
+}
+
+private fun Map<String, Any?>.toBundle(): Bundle {
+  val bundle = Bundle()
+  forEach { (key, value) ->
+    when (value) {
+      null -> bundle.putString(key, null)
+      is String -> bundle.putString(key, value)
+      is Int -> bundle.putInt(key, value)
+      is Double -> bundle.putDouble(key, value)
+      is Boolean -> bundle.putBoolean(key, value)
+      is Float -> bundle.putFloat(key, value)
+      is Long -> bundle.putLong(key, value)
+      is Map<*, *> -> {
+        @Suppress("UNCHECKED_CAST")
+        bundle.putBundle(key, (value as Map<String, Any?>).toBundle())
+      }
+      else -> bundle.putString(key, value.toString())
+    }
+  }
+  return bundle
+}