Merge branch 'feat/auto-push-tracking' into ab/mage-765-android-add-x-klaviyo-sdk-features-header-to-push-token

Author: Atharva8168

sdk/analytics/src/main/java/com/klaviyo/analytics/Klaviyo.kt

@@ -4,12 +4,10 @@ import android.app.Application
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
-import androidx.core.app.NotificationManagerCompat
 import androidx.core.net.toUri
 import com.klaviyo.analytics.linking.DeepLinkHandler
 import com.klaviyo.analytics.linking.DeepLinking
 import com.klaviyo.analytics.model.Event
-import com.klaviyo.analytics.model.EventKey
 import com.klaviyo.analytics.model.EventMetric
 import com.klaviyo.analytics.model.Profile
 import com.klaviyo.analytics.model.ProfileKey
@@ -19,22 +17,19 @@ import com.klaviyo.analytics.state.KlaviyoState
 import com.klaviyo.analytics.state.State
 import com.klaviyo.analytics.state.StateSideEffects
 import com.klaviyo.core.Constants
-import com.klaviyo.core.Constants.KEY_VALUE_PAIRS
 import com.klaviyo.core.Constants.PACKAGE_PREFIX
 import com.klaviyo.core.Constants.TRACKING_PARAMETER
 import com.klaviyo.core.Operation
+import com.klaviyo.core.PushTokenFetcher
 import com.klaviyo.core.Registry
 import com.klaviyo.core.config.Config
 import com.klaviyo.core.config.LifecycleException
 import com.klaviyo.core.safeApply
 import com.klaviyo.core.safeCall
-import com.klaviyo.core.utils.BoundedIdSet
-import com.klaviyo.core.utils.JSONUtil.toHashMap
 import com.klaviyo.core.utils.takeIf
 import java.io.Serializable
 import java.util.LinkedList
 import java.util.Queue
-import org.json.JSONObject
 
 /**
  * Public API for the core Klaviyo SDK.
@@ -48,17 +43,6 @@ object Klaviyo {
      */
     private val preInitQueue: Queue<Operation<Unit>> = LinkedList()
 
-    /**
-     * Push delivery IDs already handled within this process, so a single tap records one
-     * `$opened_push`. See [handlePush] for how entries are matched and added.
-     */
-    private val handledPushDeliveries = BoundedIdSet()
-
-    /**
-     * Key within the `_k` tracking payload whose value uniquely identifies a single push delivery.
-     */
-    private const val PUSH_DELIVERY_KEY = "tm"
-
     /**
      * This method is provided for apps that are unable to register their API key immediately
      * on app launch in order enable limited SDK functionality including tracking app lifecycle,
@@ -128,6 +112,43 @@ object Klaviyo {
                 preInitQueue.poll()?.let { safeCall(null, it) }
             }
         }
+
+        // Optional side effect, kept last so it can never interfere with core initialization
+        maybeAutoRegisterPushToken()
+    }
+
+    /**
+     * Opt-in automatic push token registration (via [Constants.AUTOMATIC_PUSH_TRACKING]): pull the
+     * current token and forward it to Klaviyo. Called from [initialize] and on each app foreground so
+     * rotations are picked up. No-op when the flag is off, when forwarding is opted out via
+     * [Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING], or when `push-fcm` is absent.
+     */
+    internal fun maybeAutoRegisterPushToken() {
+        val autoTrackingEnabled = Registry.config.getManifestBoolean(
+            Constants.AUTOMATIC_PUSH_TRACKING,
+            false
+        )
+        // Avoid a second manifest read on the common flag-off path
+        val tokenForwardingDisabled = autoTrackingEnabled && Registry.config.getManifestBoolean(
+            Constants.DISABLE_AUTOMATIC_TOKEN_FORWARDING,
+            false
+        )
+        if (!autoTrackingEnabled || tokenForwardingDisabled) {
+            Registry.log.verbose(
+                "Skipping automatic push token registration " +
+                    "(automaticPushTracking=$autoTrackingEnabled, tokenForwardingDisabled=$tokenForwardingDisabled)"
+            )
+            return
+        }
+
+        Registry.getOrNull<PushTokenFetcher>()?.also { fetcher ->
+            Registry.log.debug("Automatically fetching push token")
+            // Contain any fetcher failure so this optional side effect cannot disrupt the caller
+            runCatching { fetcher.fetchAndSetPushToken() }
+                .onFailure { Registry.log.warning("Automatic push token fetch failed", it) }
+        } ?: Registry.log.verbose(
+            "No push token fetcher registered; skipping automatic registration"
+        )
     }
 
     /**
@@ -337,53 +358,7 @@ object Klaviyo {
      */
     @JvmStatic
     fun handlePush(intent: Intent?): Klaviyo {
-        if (intent == null || !intent.isKlaviyoNotificationIntent) {
-            Registry.log.verbose("Non-Klaviyo intent ignored")
-            return this
-        }
-
-        // Dedup guard: track each push delivery at most once per process. The trampoline calls
-        // handlePush and forwards the same intent to the host, so a leftover manual handlePush call
-        // (or singleTask re-entry) would otherwise double-track one tap. The first call to see a
-        // delivery records it and proceeds; a later call for the same delivery short-circuits — no
-        // event, dismissal, or deep link.
-        val deliveryId = intent.pushDeliveryId
-        if (deliveryId != null && !handledPushDeliveries.markOnce(deliveryId)) {
-            Registry.log.verbose("Ignoring duplicate push open")
-            return this
-        }
-
-        // Create and enqueue an $opened_push. safeApply(preInitQueue) buffers this for replay if
-        // handlePush runs before initialize(), and guards against unexpected failures.
-        safeApply(preInitQueue) {
-            val state = Registry.get<State>()
-            val event = Event(EventMetric.OPENED_PUSH)
-            event.appendKlaviyoExtras(intent)
-            state.pushToken?.let { event[EventKey.PUSH_TOKEN] = it }
-            // Not using Klaviyo.createEvent here to avoid nesting safeApply calls
-            state.createEvent(event, state.getAsProfile())
-        }
-
-        // Dismiss the notification if opened via an action button. Body taps auto-cancel via
-        // setAutoCancel(true) on the builder; action button taps don't (standard Android behavior).
-        safeApply {
-            val notificationTag = intent.getStringExtra(Constants.NOTIFICATION_TAG_EXTRA)
-            if (notificationTag != null) {
-                NotificationManagerCompat
-                    .from(Registry.config.applicationContext)
-                    .cancel(notificationTag, Constants.NOTIFICATION_ID)
-            }
-        }
-
-        // If the notification carries a deep link and a handler is registered, invoke it. Otherwise
-        // do nothing — the host already received the appropriate intent.
-        safeApply {
-            val deepLink = intent.data
-            if (deepLink != null && DeepLinking.isHandlerRegistered) {
-                DeepLinking.handleDeepLink(deepLink)
-            }
-        }
-
+        KlaviyoPushOpenHandler.handle(intent, preInitQueue)
         return this
     }
 
@@ -456,29 +431,6 @@ object Klaviyo {
     @JvmStatic
     fun isKlaviyoNotificationIntent(intent: Intent?): Boolean = intent.isKlaviyoNotificationIntent
 
-    /**
-     * Dedup key for this intent's push delivery, or `null` if none is available. Prefers the `tm`
-     * field of the `_k` payload (a per-delivery ULID on campaign sends), else the SDK-generated
-     * per-notification [Constants.NOTIFICATION_UID_EXTRA]. Both are copied forward to the host's
-     * intent, so a delivery handled by the trampoline and then a leftover manual call resolve to the
-     * same key, while distinct notifications stay distinct.
-     *
-     * Deliberately not the raw `_k`: minus `tm` it is per-message metadata shared across deliveries,
-     * so it would collapse distinct opens.
-     */
-    private val Intent?.pushDeliveryId: String?
-        get() {
-            val deliveryId = this?.getStringExtra(PACKAGE_PREFIX + TRACKING_PARAMETER)
-                ?.takeIf { it.isNotEmpty() }
-                ?.let { trackingPayload ->
-                    runCatching { JSONObject(trackingPayload).optString(PUSH_DELIVERY_KEY) }
-                        .getOrNull()
-                        ?.takeIf { it.isNotEmpty() }
-                }
-            return deliveryId ?: this?.getStringExtra(Constants.NOTIFICATION_UID_EXTRA)
-                ?.takeIf { it.isNotEmpty() }
-        }
-
     /**
      * Determine if an intent is a Klaviyo click-tracking universal/app link
      */
@@ -508,33 +460,4 @@ object Klaviyo {
      */
     @JvmStatic
     fun isKlaviyoUniversalTrackingUri(uri: Uri): Boolean = uri.isKlaviyoUniversalTrackingUri
-
-    /**
-     * Appends Klaviyo extras from an intent to this event, parsing special fields as needed
-     */
-    internal fun Event.appendKlaviyoExtras(intent: Intent?) {
-        intent?.extras?.keySet()?.forEach { key ->
-            if (key.contains(PACKAGE_PREFIX)) {
-                val eventKey = EventKey.CUSTOM(key.replace(PACKAGE_PREFIX, ""))
-                val rawValue = intent.extras?.getString(key, "") ?: ""
-                val parsedValue = when (eventKey.name) {
-                    KEY_VALUE_PAIRS -> {
-                        try {
-                            JSONObject(rawValue).toHashMap()
-                        } catch (e: Exception) {
-                            Registry.log.warning(
-                                "Failed to parse $KEY_VALUE_PAIRS JSON: $rawValue",
-                                e
-                            )
-                            rawValue
-                        }
-                    }
-
-                    else -> rawValue
-                }
-
-                this[eventKey] = parsedValue
-            }
-        }
-    }
 }

sdk/analytics/src/main/java/com/klaviyo/analytics/KlaviyoPushOpenHandler.kt

@@ -0,0 +1,139 @@
+package com.klaviyo.analytics
+
+import android.content.Intent
+import androidx.core.app.NotificationManagerCompat
+import com.klaviyo.analytics.linking.DeepLinking
+import com.klaviyo.analytics.model.Event
+import com.klaviyo.analytics.model.EventKey
+import com.klaviyo.analytics.model.EventMetric
+import com.klaviyo.analytics.state.State
+import com.klaviyo.core.Constants
+import com.klaviyo.core.Constants.KEY_VALUE_PAIRS
+import com.klaviyo.core.Constants.PACKAGE_PREFIX
+import com.klaviyo.core.Constants.TRACKING_PARAMETER
+import com.klaviyo.core.Operation
+import com.klaviyo.core.Registry
+import com.klaviyo.core.safeApply
+import com.klaviyo.core.utils.BoundedIdSet
+import com.klaviyo.core.utils.JSONUtil.toHashMap
+import java.util.Queue
+import org.json.JSONObject
+
+internal object KlaviyoPushOpenHandler {
+
+    /**
+     * Push delivery IDs already handled within this process, so a single tap records one
+     * `$opened_push`. See [handle] for how entries are matched and added.
+     */
+    private val handledPushDeliveries = BoundedIdSet()
+
+    /**
+     * Key within the `_k` tracking payload whose value uniquely identifies a single push delivery.
+     */
+    private const val PUSH_DELIVERY_KEY = "tm"
+
+    /**
+     * Core push-open handling: guards, event enqueue, notification dismissal, deep-link dispatch.
+     * Called by [Klaviyo.handlePush]; not meant for direct use outside this module.
+     */
+    internal fun handle(intent: Intent?, preInitQueue: Queue<Operation<Unit>>) {
+        if (intent == null || !Klaviyo.isKlaviyoNotificationIntent(intent)) {
+            Registry.log.verbose("Non-Klaviyo intent ignored")
+            return
+        }
+
+        // Dedup guard: track each push delivery at most once per process. The trampoline calls
+        // handlePush and forwards the same intent to the host, so a leftover manual handlePush call
+        // (or singleTask re-entry) would otherwise double-track one tap. The first call to see a
+        // delivery records it and proceeds; a later call for the same delivery short-circuits — no
+        // event, dismissal, or deep link.
+        val deliveryId = intent.pushDeliveryId
+        if (deliveryId != null && !handledPushDeliveries.markOnce(deliveryId)) {
+            Registry.log.verbose("Ignoring duplicate push open")
+            return
+        }
+
+        // Create and enqueue an $opened_push. safeApply(preInitQueue) buffers this for replay if
+        // handlePush runs before initialize(), and guards against unexpected failures.
+        safeApply(preInitQueue) {
+            val state = Registry.get<State>()
+            val event = Event(EventMetric.OPENED_PUSH)
+            event.appendKlaviyoExtras(intent)
+            state.pushToken?.let { event[EventKey.PUSH_TOKEN] = it }
+            // Not using Klaviyo.createEvent here to avoid nesting safeApply calls
+            state.createEvent(event, state.getAsProfile())
+        }
+
+        // Dismiss the notification if opened via an action button. Body taps auto-cancel via
+        // setAutoCancel(true) on the builder; action button taps don't (standard Android behavior).
+        safeApply {
+            val notificationTag = intent.getStringExtra(Constants.NOTIFICATION_TAG_EXTRA)
+            if (notificationTag != null) {
+                NotificationManagerCompat
+                    .from(Registry.config.applicationContext)
+                    .cancel(notificationTag, Constants.NOTIFICATION_ID)
+            }
+        }
+
+        // If the notification carries a deep link and a handler is registered, invoke it. Otherwise
+        // do nothing — the host already received the appropriate intent.
+        safeApply {
+            val deepLink = intent.data
+            if (deepLink != null && DeepLinking.isHandlerRegistered) {
+                DeepLinking.handleDeepLink(deepLink)
+            }
+        }
+    }
+
+    /**
+     * Dedup key for this intent's push delivery, or `null` if none is available. Prefers the `tm`
+     * field of the `_k` payload (a per-delivery ULID on campaign sends), else the SDK-generated
+     * [Constants.NOTIFICATION_UID_EXTRA] stamped on trampoline intents. Both are copied forward to
+     * the host's intent, so the trampoline call and a leftover manual call for the same tap resolve
+     * to the same key while distinct notifications stay distinct.
+     *
+     * Deliberately not the raw `_k`: minus `tm` it is per-message metadata shared across deliveries,
+     * so it would collapse distinct opens.
+     */
+    private val Intent?.pushDeliveryId: String?
+        get() {
+            val deliveryId = this?.getStringExtra(PACKAGE_PREFIX + TRACKING_PARAMETER)
+                ?.takeIf { it.isNotEmpty() }
+                ?.let { trackingPayload ->
+                    runCatching { JSONObject(trackingPayload).optString(PUSH_DELIVERY_KEY) }
+                        .getOrNull()
+                        ?.takeIf { it.isNotEmpty() }
+                }
+            return deliveryId ?: this?.getStringExtra(Constants.NOTIFICATION_UID_EXTRA)
+                ?.takeIf { it.isNotEmpty() }
+        }
+
+    /**
+     * Appends Klaviyo extras from an intent to this event, parsing special fields as needed
+     */
+    private fun Event.appendKlaviyoExtras(intent: Intent?) {
+        intent?.extras?.keySet()?.forEach { key ->
+            if (key.contains(PACKAGE_PREFIX)) {
+                val eventKey = EventKey.CUSTOM(key.replace(PACKAGE_PREFIX, ""))
+                val rawValue = intent.extras?.getString(key, "") ?: ""
+                val parsedValue = when (eventKey.name) {
+                    KEY_VALUE_PAIRS -> {
+                        try {
+                            JSONObject(rawValue).toHashMap()
+                        } catch (e: Exception) {
+                            Registry.log.warning(
+                                "Failed to parse $KEY_VALUE_PAIRS JSON: $rawValue",
+                                e
+                            )
+                            rawValue
+                        }
+                    }
+
+                    else -> rawValue
+                }
+
+                this[eventKey] = parsedValue
+            }
+        }
+    }
+}

sdk/analytics/src/main/java/com/klaviyo/analytics/state/StateSideEffects.kt

@@ -180,6 +180,8 @@ internal class StateSideEffects(
                 // Trigger the token in state to refresh overall push state, if changed
                 Klaviyo.setPushToken(it)
             }
+            // Re-pull the token on foreground so rotations while backgrounded are caught
+            Klaviyo.maybeAutoRegisterPushToken()
         }
     }
 }

sdk/analytics/src/test/java/com/klaviyo/analytics/KlaviyoPreInitializeTest.kt

@@ -81,7 +81,9 @@ internal class KlaviyoPreInitializeTest : BaseTest() {
 
     @Test
     fun `Opened Push events are replayed upon initializing`() {
-        Klaviyo.handlePush(KlaviyoTest.mockIntent(KlaviyoTest.stubIntentExtras))
+        Klaviyo.handlePush(
+            KlaviyoPushOpenHandlerTest.mockIntent(KlaviyoPushOpenHandlerTest.stubIntentExtras)
+        )
         verify { spyLog.warning(any(), any<MissingConfig>()) } // Warning bc it will be replayed
 
         Klaviyo.createEvent(EventMetric.OPENED_APP)