@attentive-mobile/attentive-react-native-sdk 2.0.0-beta.5 → 2.0.0-beta.6

package/README.md

@@ -270,12 +270,13 @@ return () => subscription.remove();
 
 #### 3. Optional: Register FCM token (Android)
 
-If your app uses Firebase Cloud Messaging and you have an FCM token, register it with the Attentive backend and then call `handleRegularOpen` in the callback (same pattern as iOS):
+**Recommended:** This React Native SDK’s Android native module depends on Attentive Android SDK **2.1.1**, which exposes `AttentiveSdk.getPushTokenWithCallback`. Calling `registerForPushNotifications()` from JS triggers that API: the SDK requests permission (when needed), fetches the FCM token, and registers it with Attentive. No separate native code is required.
+
+**Alternative (token from JS):** If you obtain the FCM token elsewhere (e.g. Firebase Messaging), use `registerDeviceTokenWithCallback` and then call `handleRegularOpen` in the callback:
 
 ```typescript
 import { registerDeviceTokenWithCallback, handleRegularOpen } from 'attentive-react-native-sdk';
 
-// When you receive the FCM token (e.g. from Firebase Messaging):
 getPushAuthorizationStatus().then((authStatus) => {
   registerDeviceTokenWithCallback(
     fcmToken,

package/android/build.gradle

@@ -82,7 +82,10 @@ dependencies {
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
-  implementation 'com.attentive:attentive-android-sdk:1.0.1'
+  // Use `api` so that the Attentive Android SDK types (AttentiveSdk, CustomEvent, etc.)
+  // are visible to app-level code (e.g. Bonni's AttentiveFirebaseMessagingService) that
+  // depends on this library and needs to call the SDK directly from native components.
+  api 'com.attentive:attentive-android-sdk:2.1.3-beta.1'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.10"
   implementation(platform("org.jetbrains.kotlin:kotlin-bom:1.9.10"))
   

package/android/src/main/kotlin/com/attentivereactnativesdk/AttentiveNotificationStore.kt

@@ -0,0 +1,60 @@
+package com.attentivereactnativesdk
+
+/**
+ * In-process store for a pending initial push notification payload.
+ *
+ * When the user taps an FCM notification while the app is in the killed state,
+ * Android launches the app's main activity before the React Native bridge is
+ * initialised. The notification payload is written here by the host app's
+ * `MainActivity` and consumed exactly once by [AttentiveReactNativeSdkModule.getInitialPushNotification]
+ * after the JS layer is ready.
+ *
+ * ## Usage pattern
+ *
+ * ```kotlin
+ * // In host app's MainActivity.onCreate:
+ * intent?.extras?.let { extras ->
+ *     val payload = // … extract FCM data …
+ *     AttentiveNotificationStore.setPendingInitialNotification(payload)
+ * }
+ * ```
+ *
+ * ```typescript
+ * // In JS (App.tsx), after initialize():
+ * const initial = await getInitialPushNotification()
+ * if (initial) handlePushOpen(initial, authStatus)
+ * ```
+ *
+ * Thread-safety: the two public methods are `@Synchronized` so concurrent access
+ * from the main UI thread (writer) and the JS bridge thread (reader) is safe.
+ */
+object AttentiveNotificationStore {
+
+    @Volatile
+    private var pendingInitialNotification: Map<String, String>? = null
+
+    /**
+     * Stores [payload] as the pending initial push notification.
+     *
+     * Replaces any previously stored value (only one initial notification is tracked at a time).
+     *
+     * @param payload A map of string key-value pairs representing the notification data.
+     */
+    @Synchronized
+    fun setPendingInitialNotification(payload: Map<String, String>) {
+        pendingInitialNotification = payload
+    }
+
+    /**
+     * Returns the stored initial push notification payload and clears it atomically,
+     * ensuring the payload is delivered to the JS layer exactly once.
+     *
+     * @return The stored payload map, or `null` if no initial notification is pending.
+     */
+    @Synchronized
+    fun getAndClear(): Map<String, String>? {
+        val pending = pendingInitialNotification
+        pendingInitialNotification = null
+        return pending
+    }
+}

package/android/src/main/kotlin/com/attentivereactnativesdk/AttentivePushHelper.kt

@@ -26,8 +26,8 @@ object AttentivePushHelper {
     /**
      * Authorization status values aligned with iOS push authorization for use in handleRegularOpen etc.
      * - "authorized" – user has granted notification permission (or API < 33)
-     * - "denied" – user denied or permission not granted
-     * - "notDetermined" – not yet requested (API 33+ only)
+     * - "denied" – user was asked and denied (API 33+, when determinable via activity)
+     * - "notDetermined" – not yet requested, or unable to distinguish (API 33+ only)
      */
     const val STATUS_AUTHORIZED = "authorized"
     const val STATUS_DENIED = "denied"
@@ -36,14 +36,18 @@ object AttentivePushHelper {
     /**
      * Returns the current push notification authorization status.
      *
-     * On API 33+: uses [android.permission.POST_NOTIFICATIONS].
+     * On API 33+: uses [android.permission.POST_NOTIFICATIONS]. When permission is not granted,
+     * uses [activity] (when provided) and [ActivityCompat.shouldShowRequestPermissionRationale]
+     * to distinguish "denied" (user was asked and declined) from "notDetermined" (not yet asked).
      * On API < 33: returns [STATUS_AUTHORIZED] (no runtime permission required).
      *
      * @param context Application or Activity context
+     * @param activity Current activity, or null. When non-null on API 33+, used to detect
+     *   "denied" vs "notDetermined" so downstream logic and analytics are correct for denied users.
      * @return One of [STATUS_AUTHORIZED], [STATUS_DENIED], or [STATUS_NOT_DETERMINED]
      */
     @JvmStatic
-    fun getAuthorizationStatus(context: Context): String {
+    fun getAuthorizationStatus(context: Context, activity: Activity? = null): String {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
             // API 32 and below: notification permission not required at runtime
             return STATUS_AUTHORIZED
@@ -51,9 +55,13 @@ object AttentivePushHelper {
         return when (ContextCompat.checkSelfPermission(context, android.Manifest.permission.POST_NOTIFICATIONS)) {
             PackageManager.PERMISSION_GRANTED -> STATUS_AUTHORIZED
             else -> {
-                // Not granted. Without an Activity we cannot distinguish "denied" vs "not yet asked".
-                // Return notDetermined so the app can call registerForPushNotifications to request.
-                STATUS_NOT_DETERMINED
+                // Not granted. Use shouldShowRequestPermissionRationale when we have an Activity
+                // so we do not report "denied" users as "notDetermined" (fixes prompt-gating and analytics).
+                if (activity != null && ActivityCompat.shouldShowRequestPermissionRationale(activity, android.Manifest.permission.POST_NOTIFICATIONS)) {
+                    STATUS_DENIED
+                } else {
+                    STATUS_NOT_DETERMINED
+                }
             }
         }
     }