@scalebun/react-native 1.0.1 → 1.0.2

package/android/src/main/java/com/scalebun/rn/engage/ScaleBunEngagePackage.kt

@@ -1,22 +1,22 @@
-package com.scalebun.rn.engage
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-/**
- * ReactPackage for ScaleBunEngageModule (push-token acquisition).
- *
- * Retained for manual/standalone registration; the aggregate ScaleBunPackage is
- * the autolinked entry point and already returns ScaleBunEngageModule, so this package
- * is NOT autolinked (no double registration).
- */
-class ScaleBunEngagePackage : ReactPackage {
-
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
-        listOf(ScaleBunEngageModule(reactContext))
-
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
-        emptyList()
-}
+package com.scalebun.rn.engage
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * ReactPackage for ScaleBunEngageModule (push-token acquisition).
+ *
+ * Retained for manual/standalone registration; the aggregate ScaleBunPackage is
+ * the autolinked entry point and already returns ScaleBunEngageModule, so this package
+ * is NOT autolinked (no double registration).
+ */
+class ScaleBunEngagePackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(ScaleBunEngageModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

package/android/src/main/java/com/scalebun/rn/engage/ScaleBunNotificationPresenter.kt

@@ -1,110 +1,110 @@
-package com.scalebun.rn.engage
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.os.Build
-
-/**
- * ScaleBun native notification presenter — framework-only (NO Notifee, NO new
- * compile dependency). This is the SDK's native-first display layer: it owns
- * channel creation and foreground display using only `android.app.*` APIs, so the
- * same logic can be reused by a future bundled `FirebaseMessagingService`, a native
- * Android SDK, or mirrored by a Flutter wrapper.
- *
- * Delivery is unchanged: background/tray notifications are still rendered by the OS
- * from the FCM `notification` payload via the host's messaging service. This presenter
- * only DISPLAYS while the app is foreground (where the OS suppresses the tray), driven
- * by the JS adapter calling through the bridge.
- */
-object ScaleBunNotificationPresenter {
-
-    /** Intent extra: marks an activity launch as originating from a ScaleBunB notification. */
-    const val EXTRA_SCALEBUN_FLAG = "scalebun_from_notification"
-
-    /** Intent extra: JSON string of the notification `data` map, for deep-link routing. */
-    const val EXTRA_SCALEBUN_DATA = "scalebun_notification_data"
-
-    /**
-     * Create (or update) the notification channel natively. Required on API 26+;
-     * a no-op on older releases (channels did not exist). Idempotent — safe to call
-     * on every push enable.
-     */
-    fun ensureChannel(
-        context: Context,
-        channelId: String,
-        channelName: String,
-        importance: Int,
-        description: String?,
-    ) {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
-        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
-            ?: return
-        val channel = NotificationChannel(channelId, channelName, importance)
-        if (!description.isNullOrEmpty()) channel.description = description
-        manager.createNotificationChannel(channel)
-    }
-
-    /**
-     * Display a notification natively. Tapping it relaunches the host app's launcher
-     * activity with the ScaleBunB extras attached, so `ScaleBunEngageModule` can surface an
-     * "opened" event (foreground/background) or seed the initial notification (cold start).
-     *
-     * Uses the host app's own icon (`applicationInfo.icon`) as the small icon — no asset
-     * bundled by the SDK, no dependency on the host declaring `default_notification_icon`.
-     */
-    fun show(
-        context: Context,
-        channelId: String,
-        title: String?,
-        body: String?,
-        dataJson: String?,
-        notificationId: Int,
-    ) {
-        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
-            ?: return
-
-        val launchIntent = context.packageManager
-            .getLaunchIntentForPackage(context.packageName)
-            ?.apply {
-                addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                putExtra(EXTRA_SCALEBUN_FLAG, true)
-                if (!dataJson.isNullOrEmpty()) putExtra(EXTRA_SCALEBUN_DATA, dataJson)
-            }
-
-        val pendingFlags =
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-            } else {
-                PendingIntent.FLAG_UPDATE_CURRENT
-            }
-
-        val contentIntent: PendingIntent? = launchIntent?.let {
-            PendingIntent.getActivity(context, notificationId, it, pendingFlags)
-        }
-
-        val smallIcon = context.applicationInfo.icon
-
-        val builder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            Notification.Builder(context, channelId)
-        } else {
-            @Suppress("DEPRECATION")
-            Notification.Builder(context)
-        }
-
-        builder
-            .setSmallIcon(smallIcon)
-            .setContentTitle(title ?: "")
-            .setContentText(body ?: "")
-            .setAutoCancel(true)
-        if (!body.isNullOrEmpty()) {
-            builder.style = Notification.BigTextStyle().bigText(body)
-        }
-        if (contentIntent != null) builder.setContentIntent(contentIntent)
-
-        manager.notify(notificationId, builder.build())
-    }
-}
+package com.scalebun.rn.engage
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+
+/**
+ * ScaleBun native notification presenter — framework-only (NO Notifee, NO new
+ * compile dependency). This is the SDK's native-first display layer: it owns
+ * channel creation and foreground display using only `android.app.*` APIs, so the
+ * same logic can be reused by a future bundled `FirebaseMessagingService`, a native
+ * Android SDK, or mirrored by a Flutter wrapper.
+ *
+ * Delivery is unchanged: background/tray notifications are still rendered by the OS
+ * from the FCM `notification` payload via the host's messaging service. This presenter
+ * only DISPLAYS while the app is foreground (where the OS suppresses the tray), driven
+ * by the JS adapter calling through the bridge.
+ */
+object ScaleBunNotificationPresenter {
+
+    /** Intent extra: marks an activity launch as originating from a ScaleBunB notification. */
+    const val EXTRA_SCALEBUN_FLAG = "scalebun_from_notification"
+
+    /** Intent extra: JSON string of the notification `data` map, for deep-link routing. */
+    const val EXTRA_SCALEBUN_DATA = "scalebun_notification_data"
+
+    /**
+     * Create (or update) the notification channel natively. Required on API 26+;
+     * a no-op on older releases (channels did not exist). Idempotent — safe to call
+     * on every push enable.
+     */
+    fun ensureChannel(
+        context: Context,
+        channelId: String,
+        channelName: String,
+        importance: Int,
+        description: String?,
+    ) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
+            ?: return
+        val channel = NotificationChannel(channelId, channelName, importance)
+        if (!description.isNullOrEmpty()) channel.description = description
+        manager.createNotificationChannel(channel)
+    }
+
+    /**
+     * Display a notification natively. Tapping it relaunches the host app's launcher
+     * activity with the ScaleBunB extras attached, so `ScaleBunEngageModule` can surface an
+     * "opened" event (foreground/background) or seed the initial notification (cold start).
+     *
+     * Uses the host app's own icon (`applicationInfo.icon`) as the small icon — no asset
+     * bundled by the SDK, no dependency on the host declaring `default_notification_icon`.
+     */
+    fun show(
+        context: Context,
+        channelId: String,
+        title: String?,
+        body: String?,
+        dataJson: String?,
+        notificationId: Int,
+    ) {
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as? NotificationManager
+            ?: return
+
+        val launchIntent = context.packageManager
+            .getLaunchIntentForPackage(context.packageName)
+            ?.apply {
+                addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+                putExtra(EXTRA_SCALEBUN_FLAG, true)
+                if (!dataJson.isNullOrEmpty()) putExtra(EXTRA_SCALEBUN_DATA, dataJson)
+            }
+
+        val pendingFlags =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            } else {
+                PendingIntent.FLAG_UPDATE_CURRENT
+            }
+
+        val contentIntent: PendingIntent? = launchIntent?.let {
+            PendingIntent.getActivity(context, notificationId, it, pendingFlags)
+        }
+
+        val smallIcon = context.applicationInfo.icon
+
+        val builder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            Notification.Builder(context, channelId)
+        } else {
+            @Suppress("DEPRECATION")
+            Notification.Builder(context)
+        }
+
+        builder
+            .setSmallIcon(smallIcon)
+            .setContentTitle(title ?: "")
+            .setContentText(body ?: "")
+            .setAutoCancel(true)
+        if (!body.isNullOrEmpty()) {
+            builder.style = Notification.BigTextStyle().bigText(body)
+        }
+        if (contentIntent != null) builder.setContentIntent(contentIntent)
+
+        manager.notify(notificationId, builder.build())
+    }
+}

package/android/src/main/java/com/scalebun/rn/ota/ScaleBunOtaModule.kt

@@ -1,136 +1,136 @@
-package com.scalebun.rn.ota
-
-import android.content.Context
-import android.content.pm.ApplicationInfo
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactMethod
-import org.json.JSONObject
-import java.io.File
-
-/**
- * React Native bridge for OTA bundle management (`ScaleBunOta`).
- *
- * Sprint 2: real slot management via [SlotManager]. All filesystem operations
- * are delegated to SlotManager (pure Kotlin, no RN dependency, testable).
- *
- * The static [getJSBundleFile] method is called from the host app's
- * MainApplication.getJSBundleFile() to resolve the active OTA bundle at launch.
- *
- * Architecture-compatible: extends [ScaleBunOtaSpec], which is the codegen
- * TurboModule base on New Arch (`src/newarch`) and a classic NativeModule
- * base on Old Arch (`src/oldarch`).
- */
-class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
-    ScaleBunOtaSpec(reactContext) {
-
-    companion object {
-        const val NAME = "ScaleBunOta"
-
-        /**
-         * Static entry point for MainApplication.getJSBundleFile().
-         *
-         * Called BEFORE React Native initializes JS — this is where the boot
-         * guard runs and the active bundle path is resolved.
-         *
-         * Returns null in DEBUG builds (Metro always wins) or when no OTA
-         * bundle is installed.
-         *
-         * Usage in MainApplication.kt:
-         * ```kotlin
-         * override fun getJSBundleFile(): String? {
-         *     return ScaleBunOtaModule.getJSBundleFile(this)
-         *         ?: super.getJSBundleFile()
-         * }
-         * ```
-         */
-        @JvmStatic
-        fun getJSBundleFile(context: Context): String? {
-            // CRITICAL: never interfere with DEBUG builds
-            if (isDebugBuild(context)) return null
-
-            val slotManager = SlotManager(context.filesDir)
-
-            // Run boot guard check BEFORE JS loads
-            slotManager.checkBootGuard()
-
-            val bundleFile = slotManager.currentBundlePath()
-            return bundleFile?.absolutePath
-        }
-
-        private fun isDebugBuild(context: Context): Boolean {
-            return (context.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0
-        }
-    }
-
-    private val slotManager by lazy { SlotManager(reactApplicationContext.filesDir) }
-
-    override fun getName(): String = NAME
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getActiveBundle(): String? {
-        if (isDebugBuild(reactApplicationContext)) return null
-        return slotManager.currentBundlePath()?.absolutePath
-    }
-
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getSlotState(): String {
-        return slotManager.slotState().toString()
-    }
-
-    @ReactMethod
-    override fun stageBundle(sourcePath: String, sha256: String, promise: Promise) {
-        try {
-            val sourceFile = File(sourcePath)
-            if (!sourceFile.exists()) {
-                promise.resolve(false)
-                return
-            }
-
-            // Build meta.json from source file info
-            val meta = JSONObject()
-            meta.put("sha256", sha256)
-            meta.put("installedAt", System.currentTimeMillis())
-
-            val success = slotManager.stage(sourceFile, sha256, meta)
-            promise.resolve(success)
-        } catch (e: Exception) {
-            promise.reject("STAGE_ERROR", e.message, e)
-        }
-    }
-
-    @ReactMethod
-    override fun stagePatch(patchUrl: String, patchSha256: String, expectedSha256: String, promise: Promise) {
-        // Delta/patch updates (native bspatch) are not implemented yet. The TS spec
-        // declares stagePatch, so the codegen New-Arch base makes it an abstract
-        // member this class MUST override — otherwise @scalebun/react-native fails
-        // to compile on Android. Resolve false so OtaOrchestrator falls back to
-        // full-bundle staging (which is the only supported path today).
-        promise.resolve(false)
-    }
-
-    @ReactMethod
-    override fun applyUpdate(promise: Promise) {
-        try {
-            val success = slotManager.apply()
-            promise.resolve(success)
-        } catch (e: Exception) {
-            promise.reject("APPLY_ERROR", e.message, e)
-        }
-    }
-
-    @ReactMethod
-    override fun markHealthy() {
-        slotManager.markHealthy()
-    }
-
-    @ReactMethod
-    override fun revertToPrevious(promise: Promise) {
-        try {
-            val success = slotManager.revert()
-            promise.resolve(success)
-        } catch (e: Exception) {
-            promise.reject("REVERT_ERROR", e.message, e)
-        }
-    }
-}
+package com.scalebun.rn.ota
+
+import android.content.Context
+import android.content.pm.ApplicationInfo
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import org.json.JSONObject
+import java.io.File
+
+/**
+ * React Native bridge for OTA bundle management (`ScaleBunOta`).
+ *
+ * Sprint 2: real slot management via [SlotManager]. All filesystem operations
+ * are delegated to SlotManager (pure Kotlin, no RN dependency, testable).
+ *
+ * The static [getJSBundleFile] method is called from the host app's
+ * MainApplication.getJSBundleFile() to resolve the active OTA bundle at launch.
+ *
+ * Architecture-compatible: extends [ScaleBunOtaSpec], which is the codegen
+ * TurboModule base on New Arch (`src/newarch`) and a classic NativeModule
+ * base on Old Arch (`src/oldarch`).
+ */
+class ScaleBunOtaModule(reactContext: ReactApplicationContext) :
+    ScaleBunOtaSpec(reactContext) {
+
+    companion object {
+        const val NAME = "ScaleBunOta"
+
+        /**
+         * Static entry point for MainApplication.getJSBundleFile().
+         *
+         * Called BEFORE React Native initializes JS — this is where the boot
+         * guard runs and the active bundle path is resolved.
+         *
+         * Returns null in DEBUG builds (Metro always wins) or when no OTA
+         * bundle is installed.
+         *
+         * Usage in MainApplication.kt:
+         * ```kotlin
+         * override fun getJSBundleFile(): String? {
+         *     return ScaleBunOtaModule.getJSBundleFile(this)
+         *         ?: super.getJSBundleFile()
+         * }
+         * ```
+         */
+        @JvmStatic
+        fun getJSBundleFile(context: Context): String? {
+            // CRITICAL: never interfere with DEBUG builds
+            if (isDebugBuild(context)) return null
+
+            val slotManager = SlotManager(context.filesDir)
+
+            // Run boot guard check BEFORE JS loads
+            slotManager.checkBootGuard()
+
+            val bundleFile = slotManager.currentBundlePath()
+            return bundleFile?.absolutePath
+        }
+
+        private fun isDebugBuild(context: Context): Boolean {
+            return (context.applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE) != 0
+        }
+    }
+
+    private val slotManager by lazy { SlotManager(reactApplicationContext.filesDir) }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getActiveBundle(): String? {
+        if (isDebugBuild(reactApplicationContext)) return null
+        return slotManager.currentBundlePath()?.absolutePath
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    override fun getSlotState(): String {
+        return slotManager.slotState().toString()
+    }
+
+    @ReactMethod
+    override fun stageBundle(sourcePath: String, sha256: String, promise: Promise) {
+        try {
+            val sourceFile = File(sourcePath)
+            if (!sourceFile.exists()) {
+                promise.resolve(false)
+                return
+            }
+
+            // Build meta.json from source file info
+            val meta = JSONObject()
+            meta.put("sha256", sha256)
+            meta.put("installedAt", System.currentTimeMillis())
+
+            val success = slotManager.stage(sourceFile, sha256, meta)
+            promise.resolve(success)
+        } catch (e: Exception) {
+            promise.reject("STAGE_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    override fun stagePatch(patchUrl: String, patchSha256: String, expectedSha256: String, promise: Promise) {
+        // Delta/patch updates (native bspatch) are not implemented yet. The TS spec
+        // declares stagePatch, so the codegen New-Arch base makes it an abstract
+        // member this class MUST override — otherwise @scalebun/react-native fails
+        // to compile on Android. Resolve false so OtaOrchestrator falls back to
+        // full-bundle staging (which is the only supported path today).
+        promise.resolve(false)
+    }
+
+    @ReactMethod
+    override fun applyUpdate(promise: Promise) {
+        try {
+            val success = slotManager.apply()
+            promise.resolve(success)
+        } catch (e: Exception) {
+            promise.reject("APPLY_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    override fun markHealthy() {
+        slotManager.markHealthy()
+    }
+
+    @ReactMethod
+    override fun revertToPrevious(promise: Promise) {
+        try {
+            val success = slotManager.revert()
+            promise.resolve(success)
+        } catch (e: Exception) {
+            promise.reject("REVERT_ERROR", e.message, e)
+        }
+    }
+}