@sigx/lynx-notifications 0.4.0 → 0.4.2

package/README.md

@@ -1,6 +1,11 @@
 # @sigx/lynx-notifications
 
-Local push notifications for sigx-lynx. `UNUserNotificationCenter` on iOS, `NotificationManager` + `AlarmManager` on Android. **Local-only** — push notifications via APNs/FCM are not in this module.
+Local **and remote** push notifications for sigx-lynx.
+
+- iOS: `UNUserNotificationCenter` for scheduling and the foreground/tap delegate, APNs for remote push.
+- Android: `NotificationManager` + `AlarmManager` for scheduling, Firebase Cloud Messaging for remote push.
+
+Transport-agnostic on the server side: you pair this with any APNs/FCM-fronting service — Azure Notification Hubs, Firebase Admin, OneSignal, Braze, AWS SNS, or direct APNs/FCM — by forwarding the device token to your backend.
 
 ## Install
 
@@ -8,12 +13,37 @@ Local push notifications for sigx-lynx. `UNUserNotificationCenter` on iOS, `Noti
 pnpm add @sigx/lynx-notifications
 ```
 
-`sigx prebuild` auto-discovers the package, links the native module, and adds `android.permission.POST_NOTIFICATIONS` (Android 13+). iOS notification permission is requested at runtime via `requestPermission()`.
+`sigx prebuild` auto-discovers the package, links the native module, adds `android.permission.POST_NOTIFICATIONS` (Android 13+), registers the FCM service in `AndroidManifest.xml`, adds `UIBackgroundModes: remote-notification` to iOS `Info.plist`, and wires the APNs callbacks through the generated `AppDelegate` dispatcher.
 
 > **Android pairs with `@sigx/lynx-permissions`** — needed for the runtime permission prompt on Android 13+.
 
+### One-time manual setup for remote push
+
+Two things are **not** handled by `sigx prebuild` and must be configured per-app:
+
+**iOS — APNs entitlement.** Push won't work without the `aps-environment` entitlement plus a paid Apple Developer account with the Push Notifications capability enabled for your bundle id.
+
+1. In Xcode → Signing & Capabilities → `+ Capability` → Push Notifications.
+2. That creates `<AppName>/<AppName>.entitlements` containing `aps-environment = development`. Xcode also sets `CODE_SIGN_ENTITLEMENTS` automatically.
+
+**Android — Firebase project + `google-services.json`.**
+
+1. Create a Firebase project at console.firebase.google.com, add an Android app with your `applicationId`.
+2. Download `google-services.json` and place it at `android/app/google-services.json`.
+3. Add the Google Services Gradle plugin (modern plugins DSL — the sigx-lynx Android template doesn't use the legacy `buildscript { classpath … }` block):
+    - In `android/build.gradle.kts` (root), add to the top-level `plugins { … }`:
+        ```kotlin
+        id("com.google.gms.google-services") version "4.4.2" apply false
+        ```
+    - In `android/app/build.gradle.kts`, add to its `plugins { … }`:
+        ```kotlin
+        id("com.google.gms.google-services")
+        ```
+
 ## Usage
 
+### Local notifications (unchanged)
+
 ```ts
 import { Notifications } from '@sigx/lynx-notifications';
 
@@ -23,48 +53,90 @@ if (status === 'granted') {
         { title: 'Reminder', body: 'Check your tasks', data: { taskId: '42' } },
         { delay: 60 },     // seconds
     );
-    // Cancel later by id:
-    // await Notifications.cancel(id);
 }
+```
 
-// Daily reminder
-await Notifications.schedule(
-    { title: 'Daily check-in', body: 'How are you feeling today?' },
-    { delay: 60 * 60 * 24, repeat: 'day' },
-);
+### Remote push (Azure Notification Hubs, FCM, etc.)
 
-await Notifications.cancelAll();
+```ts
+import { Notifications } from '@sigx/lynx-notifications';
+
+// 1. Get permission.
+const { status } = await Notifications.requestPermission();
+if (status !== 'granted') return;
+
+// 2. Subscribe to events BEFORE registering — on iOS the token arrives
+//    asynchronously through the AppDelegate hook, so a late subscriber
+//    would miss it. (The native side caches the last token and replays
+//    it on subscribe, but subscribing first is the cleaner pattern.)
+const unsubToken = Notifications.addTokenListener(async ({ token, platform }) => {
+    // Forward to your backend; backend registers with Azure Notification Hubs:
+    //   await fetch('/api/register-device', { method: 'POST', body: JSON.stringify({ token, platform }) });
+});
+
+const unsubMsg = Notifications.addPushListener((msg) => {
+    console.log('foreground push', msg);
+});
+
+const unsubTap = Notifications.addNotificationResponseListener(({ notificationId, data }) => {
+    // User tapped a notification — route them somewhere.
+    // Works for remote AND local notifications.
+});
+
+// 3. Trigger registration.
+const result = await Notifications.registerForPushNotifications();
+//  iOS: { dispatched: true }   — token arrives via addTokenListener
+//  Android: { token, platform: 'fcm' } directly
+
+// 4. Cold-start handler: if the app was launched by a notification tap.
+const initial = await Notifications.getInitialNotification();
+if (initial) {
+    // route based on initial.data
+}
+
+// 5. Badge management (iOS only meaningfully — Android passes count=0 to clear).
+await Notifications.setBadgeCount(0);
 ```
 
 ## API
 
-| Method                                                                  | Notes                                                                                              |
-| ----------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| `schedule(content: NotificationContent, options?: ScheduleOptions): Promise<string>` | Returns the notification id (use it for `cancel()`).                                  |
-| `cancel(notificationId: string): Promise<void>`                         | Cancels a scheduled notification. No-op if not scheduled.                                          |
-| `cancelAll(): Promise<void>`                                            | Cancels all pending notifications scheduled by this app.                                           |
-| `requestPermission(): Promise<PermissionResponse>`                      | Shows the OS permission dialog if needed.                                                          |
-| `getPermissionStatus(): Promise<PermissionResponse>`                    | Read-only check — no prompt.                                                                       |
-| `isAvailable(): boolean`                                                | Whether the native module is registered in the current build.                                      |
+| Method                                                              | Notes                                                                                                              |
+| ------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
+| `schedule(content, options?): Promise<string>`                      | Local. Returns the notification id (use it for `cancel`).                                                          |
+| `cancel(notificationId): Promise<void>`                             | Cancels a scheduled notification. No-op if not scheduled.                                                          |
+| `cancelAll(): Promise<void>`                                        | Cancels all pending notifications scheduled by this app.                                                           |
+| `requestPermission(): Promise<PermissionResponse>`                  | Shows the OS permission dialog if needed.                                                                          |
+| `getPermissionStatus(): Promise<PermissionResponse>`                | Read-only check — no prompt.                                                                                       |
+| `registerForPushNotifications(): Promise<RegisterPushResult>`       | iOS dispatches APNs registration (token via `addTokenListener`). Android resolves with FCM token directly.         |
+| `unregisterForPushNotifications(): Promise<void>`                   | Stops receiving remote pushes.                                                                                     |
+| `setBadgeCount(n): Promise<void>`                                   | iOS: app icon badge. Android: no-op (stock Android has no portable badging API; call `cancelAll()` to clear).      |
+| `getBadgeCount(): Promise<number>`                                  | iOS: current badge. Android: always 0.                                                                             |
+| `getInitialNotification(): Promise<NotificationResponse \| null>`   | Payload that launched the app from a cold start. One-shot — call exactly once on startup.                          |
+| `addTokenListener(cb): () => void`                                  | Subscribe to `{ token, platform }`. Returns unsubscribe.                                                           |
+| `addTokenErrorListener(cb): () => void`                             | Subscribe to APNs / FCM registration failures.                                                                     |
+| `addPushListener(cb): () => void`                                   | Subscribe to incoming remote messages. Fires on foreground + when FCM data messages arrive while backgrounded.     |
+| `addNotificationResponseListener(cb): () => void`                   | Subscribe to user taps — fires for **remote AND local** notifications.                                             |
+| `isAvailable(): boolean`                                            | Whether the native module is registered in the current build.                                                      |
 
 ```ts
-interface NotificationContent {
-    title: string;
-    body: string;
-    data?: Record<string, string>;
-}
-
-interface ScheduleOptions {
-    delay?: number;                                   // seconds from now; default = immediate
-    repeat?: 'minute' | 'hour' | 'day' | 'week';      // periodic re-fire
-}
+interface NotificationContent { title: string; body: string; data?: Record<string, string>; }
+interface ScheduleOptions     { delay?: number; repeat?: 'minute' | 'hour' | 'day' | 'week'; }
+interface RegisterPushResult  { token?: string; platform?: 'apns' | 'fcm'; dispatched?: boolean; error?: string; }
+interface RemoteMessage       { title?: string; body?: string; data: Record<string, string>; foreground: boolean; }
+interface NotificationResponse{ notificationId: string; data: Record<string, string>; actionIdentifier: string; }
 ```
 
+## Event channels (advanced)
+
+Native publishes on three `GlobalEventEmitter` channels: `__sigxPushToken`, `__sigxPushMessage`, `__sigxNotificationResponse` (plus `__sigxPushTokenError`). The listener helpers above are thin wrappers — apps that already manage their own event bus can subscribe to those channels directly.
+
 ## Gotchas
 
-- **Foreground delivery on iOS.** When the app is in the foreground, iOS suppresses the banner by default. Hook into `UNUserNotificationCenterDelegate` natively if you need in-app banners.
-- **Tap callbacks aren't surfaced in JS yet.** The notification fires, but if the user taps it the routing/payload-handling has to happen on the native side (or via deep links). A future revision could expose an `onResponse` event.
+- **iOS simulator can't receive APNs pushes** — registration will fail with `remote notifications are not supported in the simulator`. Use a real device for end-to-end push testing. Local notifications and the tap-callback path work fine in the simulator.
+- **FCM token before Firebase init** — if `google-services.json` is missing or invalid, `registerForPushNotifications` resolves with `{ error: 'FCM unavailable: ...' }` instead of crashing the bridge. Check the result.
+- **Foreground delivery on iOS** — now shown with banner + sound by default. To suppress, override `UNUserNotificationCenter.current().delegate` in your own AppDelegate hook.
+- **Android notification taps** — fire `addNotificationResponseListener` only when the notification was popped via `SigxFirebaseMessagingService` (the launch intent carries our extras). Local notifications scheduled via `Notifications.schedule` do not yet route taps on Android — track via the GitHub issue.
 
 ## Reference app
 
-`examples/lynx-one/my-sigx-app/src/cards/NotificationsCard.tsx` covers permission + schedule-with-delay + cancel.
+`examples/showcase/src/cards/NotificationsCard.tsx` covers permission, schedule + cancel, push registration, listeners, and badge clearing.

package/android/com/sigx/notifications/NotificationsModule.kt

@@ -6,6 +6,8 @@ import android.content.Context
 import android.os.Build
 import android.util.Log
 import androidx.core.app.NotificationCompat
+import com.google.android.gms.tasks.OnCompleteListener
+import com.google.firebase.messaging.FirebaseMessaging
 import com.lynx.jsbridge.LynxMethod
 import com.lynx.jsbridge.LynxModule
 import com.lynx.react.bridge.Callback
@@ -15,14 +17,14 @@ import com.lynx.react.bridge.ReadableMap
 import java.util.UUID
 
 /**
- * Local notifications module.
- * JS usage: NativeModules.Notifications.schedule({ title, body }, { delay }, callback)
+ * Local + remote notifications module.
+ * JS usage: NativeModules.Notifications.<method>(...)
  */
 class NotificationsModule(context: Context) : LynxModule(context) {
 
     companion object {
         private const val TAG = "NotificationsModule"
-        private const val CHANNEL_ID = "sigx_lynxgo_default"
+        internal const val CHANNEL_ID = "sigx_lynxgo_default"
         private const val CHANNEL_NAME = "sigx-lynx-go"
     }
 
@@ -91,6 +93,106 @@ class NotificationsModule(context: Context) : LynxModule(context) {
         callback?.invoke(result)
     }
 
+    // ── Remote push ──────────────────────────────────────────────────────────
+
+    /**
+     * Resolve the FCM token. Unlike iOS where APNs delivery is async via
+     * AppDelegate, FCM exposes a Task<String> we can await directly. We still
+     * publish to [PushEventBus] (for the global event channel) so consumers
+     * using `addTokenListener` see the same value.
+     */
+    @LynxMethod
+    fun registerForPushNotifications(callback: Callback?) {
+        try {
+            FirebaseMessaging.getInstance().token.addOnCompleteListener(OnCompleteListener { task ->
+                if (!task.isSuccessful) {
+                    val message = task.exception?.localizedMessage ?: "FCM token unavailable"
+                    PushEventBus.publishTokenError(message)
+                    val err = JavaOnlyMap().apply { putString("error", message) }
+                    callback?.invoke(err)
+                    return@OnCompleteListener
+                }
+                val token = task.result ?: ""
+                PushEventBus.publishToken(token, platform = "fcm")
+                val payload = JavaOnlyMap().apply {
+                    putString("token", token)
+                    putString("platform", "fcm")
+                }
+                callback?.invoke(payload)
+            })
+        } catch (e: Throwable) {
+            // Firebase not initialised (no google-services.json). Surface a
+            // clean error instead of letting the bridge spam an uncaught.
+            val message = "FCM unavailable: ${e.message ?: e.javaClass.simpleName}"
+            PushEventBus.publishTokenError(message)
+            callback?.invoke(JavaOnlyMap().apply { putString("error", message) })
+        }
+    }
+
+    /**
+     * Awaits the FCM `deleteToken()` Task. Callers get an `{ ok, error? }`
+     * back so the JS shim can tell whether the device is genuinely
+     * unregistered or still holding a token server-side.
+     */
+    @LynxMethod
+    fun unregisterForPushNotifications(callback: Callback?) {
+        try {
+            FirebaseMessaging.getInstance().deleteToken()
+                .addOnCompleteListener(OnCompleteListener { task ->
+                    if (task.isSuccessful) {
+                        callback?.invoke(JavaOnlyMap().apply { putBoolean("ok", true) })
+                    } else {
+                        val message = task.exception?.localizedMessage
+                            ?: "Failed to delete FCM token"
+                        PushEventBus.publishTokenError(message)
+                        callback?.invoke(JavaOnlyMap().apply {
+                            putBoolean("ok", false)
+                            putString("error", message)
+                        })
+                    }
+                })
+        } catch (e: Throwable) {
+            val message = "FCM unavailable: ${e.message ?: e.javaClass.simpleName}"
+            PushEventBus.publishTokenError(message)
+            callback?.invoke(JavaOnlyMap().apply {
+                putBoolean("ok", false)
+                putString("error", message)
+            })
+        }
+    }
+
+    /**
+     * No-op on Android. Stock Android has no portable app-icon badging API
+     * (it's vendor-specific: Samsung's `ShortcutBadger`, etc.) and we
+     * intentionally don't wipe pending notifications on setBadgeCount(0) —
+     * the call's name promises "set a badge", not "clear notifications".
+     * Callers wanting to clear notifications should use `cancelAll()` directly.
+     */
+    @LynxMethod
+    fun setBadgeCount(count: Int, callback: Callback?) {
+        callback?.invoke(true)
+    }
+
+    @LynxMethod
+    fun getBadgeCount(callback: Callback?) {
+        // No portable read API. Always return 0; documented in README.
+        callback?.invoke(0)
+    }
+
+    /**
+     * One-shot: drain the cold-start tap payload, or null.
+     * Marshals JavaOnlyMap → callback so JS sees the same shape as remote events.
+     */
+    @LynxMethod
+    fun getInitialNotification(callback: Callback?) {
+        val payload = PushEventBus.consumeInitialResponse()
+        if (payload == null) {
+            callback?.invoke(null as Any?)
+        } else {
+            callback?.invoke(payload)
+        }
+    }
+
     private fun createNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             val channel = NotificationChannel(
@@ -101,4 +203,3 @@ class NotificationsModule(context: Context) : LynxModule(context) {
         }
     }
 }
-

package/android/com/sigx/notifications/PushActivityHook.kt

@@ -0,0 +1,66 @@
+package com.sigx.notifications
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+
+/**
+ * Activity-lifecycle hook for push notifications. Discovered by the auto-linker
+ * via `signalx-module.json`'s `android.activityHook` field.
+ *
+ * Responsibilities:
+ *   - `onCreate`: app cold-started by a notification tap → stash the payload
+ *     for [PushEventBus.captureInitialResponse] so JS can read it via
+ *     `Notifications.getInitialNotification()`.
+ *   - `onNewIntent`: app foregrounded by a tap while alive → publish to JS
+ *     immediately via [PushEventBus.publishResponse].
+ *
+ * The launch intent is populated by [SigxFirebaseMessagingService]
+ * (`EXTRA_NOTIFICATION_TAP` + `sigx_push_data_*` extras). Local notifications
+ * scheduled via [NotificationsModule.schedule] don't currently set this flag
+ * (they show via the system manager directly), so local-tap routing on Android
+ * lands here only when scheduled with a launch intent — TODO for v2.
+ */
+object PushActivityHook {
+
+    const val EXTRA_NOTIFICATION_TAP = "sigx_notification_tap"
+
+    @JvmStatic
+    fun onCreate(activity: Activity, savedInstanceState: Bundle?) {
+        val intent = activity.intent ?: return
+        if (intent.getBooleanExtra(EXTRA_NOTIFICATION_TAP, false)) {
+            val (id, data) = extractPayload(intent)
+            PushEventBus.captureInitialResponse(
+                notificationId = id,
+                data = data,
+                actionIdentifier = "default",
+            )
+        }
+    }
+
+    @JvmStatic
+    fun onNewIntent(activity: Activity, intent: Intent) {
+        if (!intent.getBooleanExtra(EXTRA_NOTIFICATION_TAP, false)) return
+        val (id, data) = extractPayload(intent)
+        PushEventBus.publishResponse(
+            notificationId = id,
+            data = data,
+            actionIdentifier = "default",
+        )
+    }
+
+    private fun extractPayload(intent: Intent): Pair<String, Map<String, String>> {
+        val data = mutableMapOf<String, String>()
+        val extras = intent.extras ?: return "" to data
+        for (key in extras.keySet()) {
+            if (!key.startsWith("sigx_push_data_")) continue
+            val short = key.removePrefix("sigx_push_data_")
+            val v = extras.getString(key) ?: continue
+            data[short] = v
+        }
+        val id = data["notification_id"]
+            ?: data["notificationId"]
+            ?: java.util.UUID.randomUUID().toString()
+        return id to data
+    }
+}

package/android/com/sigx/notifications/PushEventBus.kt

@@ -0,0 +1,148 @@
+package com.sigx.notifications
+
+import com.lynx.react.bridge.JavaOnlyMap
+import java.util.UUID
+
+/**
+ * Process-wide pub/sub bus that converts FCM + notification-tap callbacks
+ * into JS-side event payloads. [SigxFirebaseMessagingService] and
+ * [PushActivityHook] write here; per-LynxView [PushPublisher] instances read.
+ *
+ * Mirrors the [com.sigx.websocket.WebSocketEventBus] pattern. Decoupled from
+ * any specific LynxView so events that fire before the JS heap is ready
+ * (cold-start taps, async token refresh) survive view recreation.
+ */
+internal object PushEventBus {
+
+    /**
+     * Single lock guards [listeners] + [lastToken] + [initialResponse]. We
+     * use a private monitor object so external code can't accidentally
+     * acquire our lock and deadlock the bus.
+     *
+     * All listener invocations happen OUTSIDE the lock — a listener that
+     * publishes recursively (e.g. attaches another listener inside its
+     * callback) must not deadlock.
+     */
+    private val lock = Any()
+    private val listeners = mutableListOf<Pair<UUID, (String, JavaOnlyMap) -> Unit>>()
+
+    /** Cached cold-start tap. Drained by [consumeInitialResponse]. */
+    private var initialResponse: JavaOnlyMap? = null
+
+    /**
+     * Cached last token so a JS subscriber that attaches after FCM has already
+     * returned the token still sees the value on subscribe. FCM returns the
+     * same token across calls until rotation.
+     */
+    private var lastToken: JavaOnlyMap? = null
+
+    fun addListener(fn: (String, JavaOnlyMap) -> Unit): UUID {
+        val token = UUID.randomUUID()
+        // Snapshot the cached token in the same critical section as the
+        // listener append — without this, a concurrent publishToken can slip
+        // between `listeners.add` and reading `lastToken`, causing the new
+        // listener to fire twice (once from the publish, once from the
+        // replay). Matches the iOS bus' semantics.
+        val cached: JavaOnlyMap?
+        synchronized(lock) {
+            listeners.add(token to fn)
+            cached = lastToken
+        }
+        cached?.let { fn(Channel.TOKEN, it) }
+        return token
+    }
+
+    fun removeListener(token: UUID) {
+        synchronized(lock) {
+            listeners.removeAll { it.first == token }
+        }
+    }
+
+    fun publishToken(token: String, platform: String = "fcm") {
+        val payload = JavaOnlyMap().apply {
+            putString("token", token)
+            putString("platform", platform)
+        }
+        synchronized(lock) { lastToken = payload }
+        emit(Channel.TOKEN, payload)
+    }
+
+    fun publishTokenError(message: String) {
+        emit(
+            Channel.TOKEN_ERROR,
+            JavaOnlyMap().apply { putString("error", message) },
+        )
+    }
+
+    fun publishMessage(
+        title: String?,
+        body: String?,
+        data: Map<String, String>,
+        foreground: Boolean,
+    ) {
+        val payload = JavaOnlyMap().apply {
+            if (title != null) putString("title", title)
+            if (body != null) putString("body", body)
+            putMap("data", data.toJavaOnlyMap())
+            putBoolean("foreground", foreground)
+        }
+        emit(Channel.MESSAGE, payload)
+    }
+
+    fun publishResponse(
+        notificationId: String,
+        data: Map<String, String>,
+        actionIdentifier: String,
+    ) {
+        val payload = JavaOnlyMap().apply {
+            putString("notificationId", notificationId)
+            putMap("data", data.toJavaOnlyMap())
+            putString("actionIdentifier", actionIdentifier)
+        }
+        emit(Channel.RESPONSE, payload)
+    }
+
+    /** Stash a cold-start tap until JS calls `getInitialNotification`. */
+    fun captureInitialResponse(
+        notificationId: String,
+        data: Map<String, String>,
+        actionIdentifier: String,
+    ) {
+        val payload = JavaOnlyMap().apply {
+            putString("notificationId", notificationId)
+            putMap("data", data.toJavaOnlyMap())
+            putString("actionIdentifier", actionIdentifier)
+        }
+        synchronized(lock) { initialResponse = payload }
+    }
+
+    /** One-shot drain. */
+    fun consumeInitialResponse(): JavaOnlyMap? {
+        return synchronized(lock) {
+            val p = initialResponse
+            initialResponse = null
+            p
+        }
+    }
+
+    private fun emit(channel: String, payload: JavaOnlyMap) {
+        // Snapshot under the lock so a concurrent add/remove can't tear the
+        // iteration. Call listeners OUTSIDE the lock so a callback that
+        // re-enters the bus doesn't deadlock.
+        val snapshot = synchronized(lock) { listeners.toList() }
+        for ((_, fn) in snapshot) fn(channel, payload)
+    }
+
+    private fun Map<String, String>.toJavaOnlyMap(): JavaOnlyMap {
+        val m = JavaOnlyMap()
+        for ((k, v) in this) m.putString(k, v)
+        return m
+    }
+
+    object Channel {
+        const val TOKEN = "__sigxPushToken"
+        const val TOKEN_ERROR = "__sigxPushTokenError"
+        const val MESSAGE = "__sigxPushMessage"
+        const val RESPONSE = "__sigxNotificationResponse"
+    }
+}

package/android/com/sigx/notifications/PushPublisher.kt

@@ -0,0 +1,42 @@
+package com.sigx.notifications
+
+import android.util.Log
+import com.lynx.react.bridge.JavaOnlyArray
+import com.lynx.tasm.LynxView
+import java.util.UUID
+
+/**
+ * Per-[LynxView] publisher that pumps [PushEventBus] payloads into JS via
+ * `LynxView.sendGlobalEvent(channel, [payload])`.
+ *
+ * One instance per LynxView; instantiated by the generated
+ * `GeneratedLifecyclePublishers.attachAll(lynxView)` and retained for the
+ * LynxView's lifetime. The bus replays the last token to late subscribers so
+ * a JS shim that mounts after FCM has already returned the token still sees
+ * the value.
+ */
+class PushPublisher(private val lynxView: LynxView) {
+
+    private var token: UUID? = null
+
+    fun attach() {
+        token = PushEventBus.addListener { channel, payload ->
+            try {
+                val params = JavaOnlyArray()
+                params.pushMap(payload)
+                lynxView.sendGlobalEvent(channel, params)
+            } catch (e: Throwable) {
+                Log.w(TAG, "publish failed: ${e.message}")
+            }
+        }
+    }
+
+    fun detach() {
+        token?.let { PushEventBus.removeListener(it) }
+        token = null
+    }
+
+    private companion object {
+        const val TAG = "SigxPushPublisher"
+    }
+}