@bubblsdk/react-native-sdk 4.1.7 → 5.0.0-alpha.1

package/android/build.gradle

@@ -1,46 +1,49 @@
-plugins {
-    id "com.android.library"
-    id "org.jetbrains.kotlin.android"
+// The TurboModule over the Bubbl Android SDK (tech.bubbl.sdk:bubbl-sdk). The app's build supplies
+// the Android Gradle and React Native plugins; codegen generates NativeBubblSdkSpec from
+// ../src/NativeBubblSdk.ts.
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+def ext(String name, fallback) {
+    rootProject.ext.has(name) ? rootProject.ext.get(name) : fallback
 }
 
-group = "tech.bubbl.reactnative"
-version = "4.1.7"
-
-def isNewArchitectureEnabled() {
-    project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
-}
-
-if (isNewArchitectureEnabled()) {
-    apply plugin: "com.facebook.react"
-}
-
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
-}
-
-def reactNativeVersion = safeExtGet("reactNativeVersion", "0.76.9")
 
 android {
-    namespace = "tech.bubbl.reactnative"
-    compileSdk = safeExtGet("compileSdkVersion", 35)
+    namespace "tech.bubbl.reactnative"
+    compileSdk ext("compileSdkVersion", 35)
 
     defaultConfig {
-        minSdk = safeExtGet("minSdkVersion", 27)
-        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+        // Android 6 and up install it; Bubbl runs on 8.1 (27) and up, and does nothing below.
+        minSdk Math.max(ext("minSdkVersion", 23) as int, 23)
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_17
-        targetCompatibility = JavaVersion.VERSION_17
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
     }
+}
 
-    kotlinOptions {
-        jvmTarget = "17"
+tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
+    compilerOptions {
+        jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)
     }
 }
 
+react {
+    jsRootDir = file("../src")
+    libraryName = "BubblSdkSpec"
+    codegenJavaPackageName = "tech.bubbl.reactnative"
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
 dependencies {
-    implementation "com.facebook.react:react-android:${reactNativeVersion}"
-    implementation "tech.bubbl.sdk:bubbl-sdk:4.1.7"
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1"
+    implementation "com.facebook.react:react-android"
+    // The Bubbl Android SDK, the same version as this package (stamped by scripts/sync-version.mjs).
+    implementation "tech.bubbl.sdk:bubbl-sdk:5.0.0-alpha.1"
 }

package/android/src/main/AndroidManifest.xml

@@ -1 +1,2 @@
+<!-- Everything Bubbl needs (permissions, receivers, its screens) comes from the Bubbl Android SDK's manifest. -->
 <manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/tech/bubbl/reactnative/BubblJson.kt

@@ -0,0 +1,135 @@
+package tech.bubbl.reactnative
+
+import org.json.JSONArray
+import org.json.JSONObject
+import tech.bubbl.sdk.Bubbl
+import tech.bubbl.sdk.BubblEvent
+import tech.bubbl.sdk.BubblMessage
+import tech.bubbl.sdk.BubblOptions
+import tech.bubbl.sdk.BubblPermissionStatus
+
+/**
+ * The JSON that crosses the bridge, in the shape the JS facade's types (src/types.ts) and the
+ * Flutter wrapper share: the SDK's public names in lower camel case, messages as the public
+ * message object with the contract JSON alongside, and events as {"type": "…", …}.
+ */
+internal object BubblJson {
+    /** start()'s options: {"baseUrl", "requireConsent"?, "logLevel"?, "segments"?}. */
+    fun options(json: String): BubblOptions? = runCatching {
+        val o = JSONObject(json)
+        BubblOptions(
+            baseUrl = o.getString("baseUrl"),
+            requireConsent = o.optBoolean("requireConsent", false),
+            logLevel = o.optString("logLevel").takeIf { it.isNotEmpty() }
+                ?.let { BubblOptions.LogLevel.valueOf(it.uppercase()) } ?: BubblOptions.LogLevel.WARNING,
+            segments = o.optJSONArray("segments")?.let { array -> List(array.length()) { array.getString(it) } },
+        )
+    }.getOrNull()
+
+    /** The public message: its fields as the SDK works them out, plus the contract JSON to send back. */
+    fun message(message: BubblMessage): JSONObject = JSONObject()
+        .put("id", message.id)
+        .put("headline", message.headline)
+        .put("body", message.body)
+        .put("isSurvey", message.isSurvey)
+        .put("isSandbox", message.isSandbox)
+        .put("mediaType", message.mediaType ?: JSONObject.NULL)
+        .put("mediaUrl", message.mediaUrl ?: JSONObject.NULL)
+        .put("mediaThumbnailUrl", message.mediaThumbnailUrl ?: JSONObject.NULL)
+        .put("ctaLabel", message.ctaLabel ?: JSONObject.NULL)
+        .put("ctaUrl", message.ctaUrl ?: JSONObject.NULL)
+        .put("questions", JSONArray(message.questions.map { question ->
+            JSONObject()
+                .put("id", question.id)
+                .put("text", question.text)
+                .put("type", lowerCamel(question.type.name))
+                .put("required", question.required)
+                .put("choices", JSONArray(question.choices.map { JSONObject().put("id", it.id).put("text", it.text) }))
+        }))
+        .put("json", message.json)
+
+    fun event(event: BubblEvent): String? {
+        val (type, detail) = when (event) {
+            is BubblEvent.NotificationReceived -> "notification.received" to event.message
+            is BubblEvent.NotificationDisplayed -> "notification.displayed" to event.message
+            is BubblEvent.NotificationOpened -> "notification.opened" to event.message
+            is BubblEvent.NotificationCtaClicked -> "notification.cta_clicked" to event.message
+            is BubblEvent.NotificationDismissed -> "notification.dismissed" to event.message
+            is BubblEvent.MediaViewed -> "media.viewed" to event.message
+            is BubblEvent.MediaCompleted -> "media.completed" to event.message
+            is BubblEvent.SurveyStarted -> "survey.started" to event.message
+            is BubblEvent.SurveySubmitted -> "survey.submitted" to event.message
+            is BubblEvent.GeofenceEntered -> return JSONObject().put("type", "geofence.entered").put("locationId", event.locationId).toString()
+            is BubblEvent.GeofenceExited -> return JSONObject().put("type", "geofence.exited").put("locationId", event.locationId).toString()
+            is BubblEvent.Error -> return JSONObject().put("type", "error").put("message", event.message).toString()
+            is BubblEvent.CredentialRejected -> return JSONObject().put("type", "credential.rejected").toString()
+            else -> return null // One from a newer SDK that JS doesn't know yet.
+        }
+        return JSONObject().put("type", type).put("message", message(detail)).toString()
+    }
+
+    /** A notification held back for the app's listener (never a public event). */
+    /** A notification for the app's listener; JS answers with claimNotification / finishNotification(token). */
+    fun handle(token: String, message: BubblMessage): String =
+        JSONObject().put("type", "notification.handle").put("token", token).put("message", message(message)).toString()
+
+    /** Bubbl.TestDeviceResult: {approved, message}. */
+    fun testDeviceResult(result: Bubbl.TestDeviceResult): String =
+        JSONObject().put("approved", result.approved).put("message", result.message ?: JSONObject.NULL).toString()
+
+    fun error(message: String): String = JSONObject().put("type", "error").put("message", message).toString()
+
+    fun permissions(status: BubblPermissionStatus): String = permissionsObject(status).toString()
+
+    private fun permissionsObject(status: BubblPermissionStatus): JSONObject = JSONObject()
+        .put("notifications", lowerCamel(status.notifications.name))
+        .put("location", lowerCamel(status.location.name))
+        .put("preciseLocation", status.preciseLocation)
+
+    fun diagnostics(d: Bubbl.Diagnostics): String = JSONObject()
+        .put("started", d.started)
+        .put("sdkVersion", d.sdkVersion)
+        .put("supported", d.supported)
+        .put("sdkSupported", d.sdkSupported)
+        .put("registered", d.registered)
+        .put("installId", d.installId ?: JSONObject.NULL)
+        .put("active", d.active)
+        .put("pausedUntil", d.pausedUntil ?: JSONObject.NULL)
+        .put("consentRequired", d.consentRequired)
+        .put("consent", d.consent ?: JSONObject.NULL)
+        .put("locationEnabled", d.locationEnabled)
+        .put("permissions", d.permissions?.let(::permissionsObject) ?: JSONObject.NULL)
+        .put("hasPushToken", d.hasPushToken)
+        .put("geofences", d.geofences)
+        .put("queuedEvents", d.queuedEvents)
+        .put("lastError", d.lastError ?: JSONObject.NULL)
+        .put("credentialRejected", d.credentialRejected)
+        .put("environment", d.environment ?: JSONObject.NULL)
+        .put("testDevice", d.testDevice?.let { JSONObject().put("status", it.status).put("code", it.code ?: JSONObject.NULL) } ?: JSONObject.NULL)
+        .put("backgroundLocation", d.backgroundLocation)
+        .put("transitionsDroppedWhileLocked", d.transitionsDroppedWhileLocked)
+        .put("backgroundRestricted", d.backgroundRestricted)
+        .put("batteryOptimized", d.batteryOptimized)
+        // iOS's own, null here (as in the Flutter wrapper, so both send the same fields).
+        .put("backgroundRefreshAvailable", JSONObject.NULL)
+        .put("lowPowerMode", JSONObject.NULL)
+        .put("osWatchesGeofences", JSONObject.NULL)
+        .toString()
+
+    /** A JSON object as the map track() and submitSurvey() take: null for JSON null, lists for arrays. */
+    fun map(json: String): Map<String, Any?>? = runCatching {
+        val o = JSONObject(json)
+        o.keys().asSequence().associateWith { value(o.get(it)) }
+    }.getOrNull()
+
+    private fun value(value: Any?): Any? = when (value) {
+        JSONObject.NULL, null -> null
+        is JSONArray -> List(value.length()) { value(value.get(it)) }
+        is JSONObject -> value.keys().asSequence().associateWith { value(value.get(it)) }
+        else -> value
+    }
+
+    /** OPEN_ENDED → openEnded, WHEN_IN_USE → whenInUse. */
+    private fun lowerCamel(name: String): String =
+        name.lowercase().split('_').mapIndexed { i, part -> if (i == 0) part else part.replaceFirstChar(Char::uppercaseChar) }.joinToString("")
+}

package/android/src/main/java/tech/bubbl/reactnative/BubblSdkModule.kt

@@ -0,0 +1,277 @@
+package tech.bubbl.reactnative
+
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.module.annotations.ReactModule
+import tech.bubbl.sdk.Bubbl
+import tech.bubbl.sdk.BubblCredential
+import tech.bubbl.sdk.BubblEventListener
+import tech.bubbl.sdk.BubblMessage
+import tech.bubbl.sdk.BubblNotificationListener
+
+/**
+ * The TurboModule the JS facade (src/index.ts) calls: each function passes straight to
+ * tech.bubbl.sdk.Bubbl, with JSON across the bridge (BubblJson). The SDK does the work, and keeps
+ * working without JS: it starts itself from its saved settings when a geofence or a push wakes the
+ * app, and shows its own notifications.
+ *
+ * Events go to JS on one device event (EVENT). The app's notification listener is consulted only
+ * while JS is listening and an activity of the app is resumed: then the notification goes to JS as
+ * "notification.handle" and the facade decides (showing it with present() unless the listener says
+ * the app shows it). In the background Bubbl posts its system notification as usual, so nothing is
+ * lost for want of a screen to draw on.
+ */
+@ReactModule(name = BubblSdkModule.NAME)
+class BubblSdkModule(private val context: ReactApplicationContext) : NativeBubblSdkSpec(context) {
+    /** JS subscriptions to EVENT (NativeEventEmitter's bookkeeping). */
+    @Volatile private var jsListeners = 0
+
+    @Volatile private var notificationListenerEnabled = false
+
+    private val events = BubblEventListener { event -> BubblJson.event(event)?.let(::emit) }
+
+    private val notificationListener = BubblNotificationListener { message -> offerToApp(message) }
+
+    /**
+     * Notifications handed to JS and not yet settled, by token: JS claims one when it arrives and
+     * finishes it once the app's listener has decided. Only touched on the main thread.
+     */
+    private val handedOver = mutableMapOf<String, Handover>()
+    private var nextToken = 0L
+    private val main = Handler(Looper.getMainLooper())
+
+    private class Handover(val message: BubblMessage, val timeout: Runnable)
+
+    init {
+        Bubbl.addEventListener(events)
+    }
+
+    override fun getName() = NAME
+
+    /**
+     * JS is going away (a reload, the host destroyed). Whatever it was handed and hadn't settled,
+     * Bubbl shows. The app's listener is cleared only if this instance set it: another React host
+     * (a headless one, a second screen) going away leaves it alone.
+     */
+    override fun invalidate() {
+        Bubbl.removeEventListener(events)
+        UiThreadUtil.runOnUiThread {
+            handedOver.values.forEach { main.removeCallbacks(it.timeout); Bubbl.present(it.message) }
+            handedOver.clear()
+            if (owner === this) {
+                owner = null
+                Bubbl.setNotificationListener(null)
+            }
+        }
+        notificationListenerEnabled = false
+        super.invalidate()
+    }
+
+    // --- Starting -----------------------------------------------------------------------
+
+    override fun isSupported(): Boolean = Bubbl.isSupported
+
+    /** A mistake (bad options, an empty key, an http:// URL) is logged and reported, never thrown. */
+    override fun start(apiKey: String, optionsJson: String) {
+        val options = BubblJson.options(optionsJson)
+            ?: return mistake("Bubbl.start: options need a baseUrl (and logLevel none, error, warning, info or debug)")
+        try {
+            Bubbl.start(context.applicationContext, apiKey, options)
+        } catch (e: IllegalArgumentException) {
+            mistake(e.message ?: "Bubbl.start: invalid arguments")
+        }
+    }
+
+    /**
+     * The secret goes to the SDK and nowhere else: it arrives as its own argument (never inside
+     * JSON), and what's logged for a mistake is the SDK's message, which leaves it out.
+     */
+    override fun startWithCredential(keyId: String, secret: String, installId: String, optionsJson: String) {
+        val options = BubblJson.options(optionsJson)
+            ?: return mistake("Bubbl.startWithCredential: options need a baseUrl (and logLevel none, error, warning, info or debug)")
+        try {
+            Bubbl.start(context.applicationContext, BubblCredential(keyId, secret, installId), options)
+        } catch (e: IllegalArgumentException) {
+            mistake(e.message ?: "Bubbl.startWithCredential: invalid arguments")
+        }
+    }
+
+    override fun stop() = Bubbl.stop()
+
+    // --- Consent and privacy ------------------------------------------------------------
+
+    override fun setConsent(granted: Boolean) = Bubbl.setConsent(granted)
+
+    override fun optOut() = Bubbl.optOut()
+
+    override fun deleteMyData() = Bubbl.deleteMyData()
+
+    override fun setLocationEnabled(enabled: Boolean) = Bubbl.setLocationEnabled(enabled)
+
+    // --- Permissions --------------------------------------------------------------------
+
+    override fun permissionStatus(promise: Promise) {
+        promise.resolve(Bubbl.permissions.status()?.let(BubblJson::permissions))
+    }
+
+    override fun requestNotifications(promise: Promise) {
+        Bubbl.permissions.requestNotifications { status -> promise.resolve(status?.let(BubblJson::permissions)) }
+    }
+
+    override fun requestLocation(always: Boolean, promise: Promise) {
+        Bubbl.permissions.requestLocation(always) { status -> promise.resolve(status?.let(BubblJson::permissions)) }
+    }
+
+    override fun openSettings() = Bubbl.permissions.openSettings()
+
+    // --- Targeting and events -----------------------------------------------------------
+
+    override fun setSegments(segments: ReadableArray) {
+        Bubbl.setSegments(List(segments.size()) { segments.getString(it).orEmpty() }.filter { it.isNotEmpty() })
+    }
+
+    override fun track(name: String, propertiesJson: String) {
+        Bubbl.track(name, BubblJson.map(propertiesJson) ?: return mistake("Bubbl.track: properties must be a JSON object"))
+    }
+
+    // --- Notifications ------------------------------------------------------------------
+
+    override fun setNotificationListenerEnabled(enabled: Boolean) {
+        notificationListenerEnabled = enabled
+        // The SDK consults its listener on the main thread; swap it there too.
+        UiThreadUtil.runOnUiThread {
+            if (enabled) {
+                owner = this
+                Bubbl.setNotificationListener(notificationListener)
+            } else if (owner === this) {
+                owner = null
+                Bubbl.setNotificationListener(null)
+            }
+        }
+    }
+
+    /** JS has the notification (the timeout that would show it is off). */
+    override fun claimNotification(token: String) {
+        UiThreadUtil.runOnUiThread {
+            handedOver[token]?.let { main.removeCallbacks(it.timeout) }
+        }
+    }
+
+    /** The app's listener decided: Bubbl shows the notification unless the app does. */
+    override fun finishNotification(token: String, appShowsIt: Boolean) {
+        UiThreadUtil.runOnUiThread {
+            val handover = handedOver.remove(token) ?: return@runOnUiThread
+            main.removeCallbacks(handover.timeout)
+            if (!appShowsIt) Bubbl.present(handover.message)
+        }
+    }
+
+    override fun present(messageJson: String) = withMessage(messageJson, "present", Bubbl::present)
+
+    override fun reportDisplayed(messageJson: String) = withMessage(messageJson, "reportDisplayed", Bubbl::reportDisplayed)
+
+    override fun reportOpened(messageJson: String) = withMessage(messageJson, "reportOpened", Bubbl::reportOpened)
+
+    override fun reportCtaClicked(messageJson: String) = withMessage(messageJson, "reportCtaClicked", Bubbl::reportCtaClicked)
+
+    override fun reportDismissed(messageJson: String) = withMessage(messageJson, "reportDismissed", Bubbl::reportDismissed)
+
+    override fun reportMediaViewed(messageJson: String) = withMessage(messageJson, "reportMediaViewed", Bubbl::reportMediaViewed)
+
+    override fun reportMediaCompleted(messageJson: String, durationSeconds: Double) =
+        withMessage(messageJson, "reportMediaCompleted") { Bubbl.reportMediaCompleted(it, durationSeconds) }
+
+    override fun reportSurveyStarted(messageJson: String) = withMessage(messageJson, "reportSurveyStarted", Bubbl::reportSurveyStarted)
+
+    override fun submitSurvey(messageJson: String, answersJson: String, promise: Promise) {
+        val message = BubblMessage.fromJson(messageJson)
+        val answers = BubblJson.map(answersJson)
+        when {
+            message == null -> mistake("Bubbl.submitSurvey: that isn't a Bubbl message's json").also { promise.resolve(false) }
+            answers == null -> mistake("Bubbl.submitSurvey: answers must be a JSON object").also { promise.resolve(false) }
+            else -> promise.resolve(Bubbl.submitSurvey(message, answers))
+        }
+    }
+
+    override fun openCta(messageJson: String) = withMessage(messageJson, "openCta", Bubbl::openCta)
+
+    // --- Sandbox ------------------------------------------------------------------------
+
+    /** Approve this device as a Sandbox test device with the dashboard's code: {approved, message} as JSON. */
+    override fun registerTestDevice(code: String, promise: Promise) {
+        Bubbl.registerTestDevice(code) { promise.resolve(BubblJson.testDeviceResult(it)) }
+    }
+
+    // --- Diagnostics --------------------------------------------------------------------
+
+    override fun diagnostics(promise: Promise) {
+        Bubbl.diagnostics { promise.resolve(BubblJson.diagnostics(it)) }
+    }
+
+    // --- Events to JS -------------------------------------------------------------------
+
+    override fun addListener(eventName: String) {
+        jsListeners++
+    }
+
+    override fun removeListeners(count: Double) {
+        jsListeners = (jsListeners - count.toInt()).coerceAtLeast(0)
+    }
+
+    /**
+     * The SDK's notification listener: hand [message] to JS only while the app can show it (JS is
+     * listening and an activity is resumed); otherwise Bubbl shows it itself.
+     */
+    private fun offerToApp(message: BubblMessage): Boolean {
+        val activity = context.currentActivity as? LifecycleOwner
+        val inForeground = activity?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) == true
+        if (!notificationListenerEnabled || !inForeground || !canEmit()) {
+            return false
+        }
+        // Handed over, it's JS's to settle; if JS doesn't claim it in time (reloading, stuck),
+        // Bubbl shows it: a notification is never lost between the two.
+        val token = (++nextToken).toString()
+        val timeout = Runnable { handedOver.remove(token)?.let { Bubbl.present(it.message) } }
+        handedOver[token] = Handover(message, timeout)
+        main.postDelayed(timeout, CLAIM_TIMEOUT_MS)
+        emit(BubblJson.handle(token, message))
+        return true
+    }
+
+    private fun canEmit(): Boolean = jsListeners > 0 && context.hasActiveReactInstance()
+
+    private fun emit(json: String) {
+        if (canEmit()) {
+            context.emitDeviceEvent(EVENT, json)
+        }
+    }
+
+    private inline fun withMessage(json: String, call: String, block: (BubblMessage) -> Unit) {
+        block(BubblMessage.fromJson(json) ?: return mistake("Bubbl.$call: that isn't a Bubbl message's json"))
+    }
+
+    /** A developer's mistake: in Logcat (the SDK's tag) and to JS as an error event. */
+    private fun mistake(text: String) {
+        Log.e(LOG_TAG, text)
+        emit(BubblJson.error(text))
+    }
+
+    companion object {
+        const val NAME = "BubblSdk"
+
+        /** How long JS has to claim a notification handed to it before Bubbl shows it. */
+        const val CLAIM_TIMEOUT_MS = 5_000L
+
+        /** The instance whose JS set the app's notification listener (main thread). */
+        private var owner: BubblSdkModule? = null
+        const val EVENT = "BubblSdkEvent"
+        private const val LOG_TAG = "BubblSDK"
+    }
+}

package/android/src/main/java/tech/bubbl/reactnative/BubblSdkPackage.kt

@@ -0,0 +1,26 @@
+package tech.bubbl.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+/** Registers the Bubbl TurboModule (found by React Native's autolinking). */
+class BubblSdkPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+        if (name == BubblSdkModule.NAME) BubblSdkModule(reactContext) else null
+
+    override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+        mapOf(
+            BubblSdkModule.NAME to ReactModuleInfo(
+                BubblSdkModule.NAME,
+                BubblSdkModule::class.java.name,
+                false, // canOverrideExistingModule
+                false, // needsEagerInit
+                false, // isCxxModule
+                true, // isTurboModule
+            ),
+        )
+    }
+}

package/app.plugin.js

@@ -0,0 +1,2 @@
+// The Expo config plugin (plugin/src), built to plugin/build.
+module.exports = require('./plugin/build').default;

package/ios/BubblPush.swift

@@ -0,0 +1,44 @@
+import Foundation
+import UserNotifications
+
+/// The iOS SDK's three push hand-overs for an app with `BubblAutoIntegrationEnabled` = NO in
+/// Info.plist, callable from an Objective-C AppDelegate too (the SDK's `Bubbl` is Swift only).
+/// From Swift, `import BubblReactNativeSdk` and call `Bubbl.setPushToken(_:)` and the rest
+/// directly; from Objective-C:
+///
+///     #import <UserNotifications/UserNotifications.h>
+///     #import <BubblReactNativeSdk/BubblReactNativeSdk-Swift.h>
+///
+///     [BubblPush setPushToken:deviceToken];
+///     if ([BubblPush willPresent:notification completionHandler:completionHandler]) return;
+///     if ([BubblPush didReceive:response completionHandler:completionHandler]) return;
+@objc(BubblPush)
+public final class BubblPush: NSObject {
+    /// From `application(_:didRegisterForRemoteNotificationsWithDeviceToken:)`. Before start too.
+    @objc public static func setPushToken(_ deviceToken: Data) {
+        Bubbl.setPushToken(deviceToken)
+    }
+
+    /// From `userNotificationCenter(_:willPresent:…)`: true when the push is Bubbl's, and Bubbl
+    /// calls `completionHandler`; false when it isn't, and the app decides.
+    @objc public static func willPresent(
+        _ notification: UNNotification,
+        completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+    ) -> Bool {
+        Bubbl.willPresent(notification, completionHandler: completionHandler)
+    }
+
+    /// From `userNotificationCenter(_:didReceive:…)`: true when the tapped notification is
+    /// Bubbl's, and Bubbl calls `completionHandler`; false when it isn't.
+    @objc public static func didReceive(
+        _ response: UNNotificationResponse,
+        completionHandler: @escaping () -> Void
+    ) -> Bool {
+        Bubbl.didReceive(response, completionHandler: completionHandler)
+    }
+
+    /// Whether a push's payload is Bubbl's, so the app's own handling can leave it alone.
+    @objc public static func isBubblMessage(_ userInfo: [AnyHashable: Any]) -> Bool {
+        Bubbl.isBubblMessage(userInfo)
+    }
+}

package/ios/BubblSdk.h

@@ -0,0 +1,7 @@
+#import <React/RCTEventEmitter.h>
+#import <BubblSdkSpec/BubblSdkSpec.h>
+
+/// The Bubbl TurboModule (NativeBubblSdk.ts's spec): an event emitter for BubblSdkEvent, passing
+/// every call to BubblSdkImpl (Swift), which drives the iOS SDK.
+@interface BubblSdk : RCTEventEmitter <NativeBubblSdkSpec>
+@end