2.7.15

CHANGELOG.md

@@ -2,6 +2,16 @@
 
 The changelog for `Superwall`. Also see the [releases](https://github.com/superwall/Superwall-Android/releases) on GitHub.
 
+## 2.7.15
+
+## Enhancements
+- Improves preloading logic to reduce number of preloaded paywalls for certain campaign types
+- Improve display of periodic price in some cases
+
+## Fixes
+- Fix dropping delegate events when an error occurs
+- Fix overenthusiastic delivery of `subscriptionStatus_didChange` events on minor changes
+
 ## 2.7.14
 
 ## Fixes

superwall/src/androidTest/java/com/superwall/sdk/analytics/internal/TrackingLogicTest.kt

@@ -64,6 +64,13 @@ class TrackingLogicTest {
                                 override fun experimentalProperties(): Map<String, Any> = emptyMap()
 
                                 override fun makeSuperwallOptions(): SuperwallOptions = SuperwallOptions()
+
+                                override fun customerInfoFlow() =
+                                    kotlinx.coroutines.flow.MutableStateFlow(
+                                        com.superwall.sdk.models.customer.CustomerInfo.empty(),
+                                    )
+
+                                override fun activeEntitlements() = emptySet<com.superwall.sdk.models.entitlements.Entitlement>()
                             },
                     ),
                 ) {

superwall/src/androidTest/java/com/superwall/sdk/config/ConfigManagerInstrumentedTest.kt

@@ -111,6 +111,7 @@ class ConfigManagerTests {
             every { setEnrichment(any()) } just Runs
             coEvery { getTemplateDevice() } returns emptyMap()
             coEvery { getEnrichment(any(), any()) } returns Either.Success(Enrichment.stub())
+            coEvery { preloadFingerprint() } returns "stub-fingerprint"
         }
 
     @Before
@@ -146,7 +147,7 @@ class ConfigManagerTests {
                 val assignments = Assignments(storage, network, backgroundScope)
                 val preload =
                     mockk<PaywallPreload> {
-                        coEvery { preloadAllPaywalls(any(), any()) } just Runs
+                        coEvery { preloadAllPaywalls(any(), any(), any()) } just Runs
                         coEvery { preloadPaywallsByNames(any(), any()) } just Runs
                         coEvery { removeUnusedPaywallVCsFromCache(any(), any()) } just Runs
                     }
@@ -188,7 +189,7 @@ class ConfigManagerTests {
                 val assignmentStore = Assignments(storage, network, backgroundScope)
                 val preload =
                     mockk<PaywallPreload> {
-                        coEvery { preloadAllPaywalls(any(), any()) } just Runs
+                        coEvery { preloadAllPaywalls(any(), any(), any()) } just Runs
                         coEvery { preloadPaywallsByNames(any(), any()) } just Runs
                         coEvery { removeUnusedPaywallVCsFromCache(any(), any()) } just Runs
                     }

superwall/src/main/java/com/superwall/sdk/Superwall.kt

@@ -1,8 +1,10 @@
 package com.superwall.sdk
 
 import android.app.Application
+import android.content.ComponentCallbacks2
 import android.content.Context
 import android.content.Intent
+import android.content.res.Configuration
 import android.net.Uri
 import androidx.work.WorkManager
 import com.android.billingclient.api.BillingResult
@@ -706,8 +708,29 @@ class Superwall(
     // / Listens to config and the subscription status
     private fun addListeners() {
         ioScope.launchWithTracking {
-            entitlements.status // Removes duplicates by default
-                .drop(1) // Drops the first item
+            entitlements.status
+                // Default StateFlow equality re-fires when entitlement product fields get
+                // enriched (productIds, latestProductId) even though the user-facing
+                // status is unchanged. Dedupe ignoring product identifiers — see
+                // Entitlement.isDistinct.
+                .distinctUntilChanged { old, new ->
+                    when {
+                        old === new -> true
+                        old is SubscriptionStatus.Active && new is SubscriptionStatus.Active -> {
+                            if (old.entitlements.size != new.entitlements.size) {
+                                false
+                            } else {
+                                val newById = new.entitlements.associateBy { it.id }
+                                old.entitlements.all { o ->
+                                    val n = newById[o.id] ?: return@all false
+                                    !o.isDistinct(n)
+                                }
+                            }
+                        }
+                        else -> old::class == new::class
+                    }
+                }
+                .drop(1) // Drops the cached/initial emission
                 .collect { newValue ->
                     // Save and handle the new value
                     val oldValue =
@@ -720,6 +743,7 @@ class Superwall(
                     )
                     val event = InternalSuperwallEvent.SubscriptionStatusDidChange(newValue)
                     track(event)
+                    dependencyContainer.configManager.recheckPreloadIfNeeded()
                 }
         }
         ioScope.launchWithTracking {
@@ -735,8 +759,33 @@ class Superwall(
                     dependencyContainer.storage.write(LatestCustomerInfo, new)
                     dependencyContainer.delegateAdapter.customerInfoDidChange(old!!, new)
                     track(CustomerInfoDidChange(old, new))
+                    dependencyContainer.configManager.recheckPreloadIfNeeded()
                 }
         }
+        registerConfigurationChangeListener()
+    }
+
+    private var configurationChangeListener: ComponentCallbacks2? = null
+
+    private fun registerConfigurationChangeListener() {
+        // Locale / region / language / timezone / interfaceStyle (when overrides
+        // are off) all reflect Android Configuration. ComponentCallbacks2 fires on
+        // changes and runs on the main thread; bounce through ioScope to call the
+        // suspend recheck.
+        val listener =
+            object : ComponentCallbacks2 {
+                override fun onConfigurationChanged(newConfig: Configuration) {
+                    ioScope.launchWithTracking {
+                        dependencyContainer.configManager.recheckPreloadIfNeeded()
+                    }
+                }
+
+                override fun onLowMemory() = Unit
+
+                override fun onTrimMemory(level: Int) = Unit
+            }
+        configurationChangeListener = listener
+        context.applicationContext.registerComponentCallbacks(listener)
     }
 
     /**
@@ -780,6 +829,7 @@ class Superwall(
             dependencyContainer.deviceHelper.interfaceStyleOverride = interfaceStyle
             ioScope.launch {
                 track(InternalSuperwallEvent.DeviceAttributes(dependencyContainer.makeSessionDeviceAttributes()))
+                dependencyContainer.configManager.recheckPreloadIfNeeded()
             }
         }
     }
@@ -884,6 +934,11 @@ class Superwall(
             // Note: We intentionally do NOT unregister the activity lifecycle callbacks here
             // because the activity provider will be retained and reused in the next configure call.
             // This ensures the current activity is still tracked across hot reload cycles.
+
+            configurationChangeListener?.let {
+                context.applicationContext.unregisterComponentCallbacks(it)
+                configurationChangeListener = null
+            }
         }
     }
 
@@ -1409,6 +1464,7 @@ class Superwall(
                                                 type = paywallEvent.type.rawValue,
                                             ),
                                         )
+                                        dependencyContainer.configManager.recheckPreloadIfNeeded()
                                     }
                                 }
 
@@ -1445,7 +1501,7 @@ class Superwall(
                                     ?: dependencyContainer
                                         .activityProvider
                                         ?.getCurrentActivity()
-                                ) as SuperwallPaywallActivity?
+                                ) as? SuperwallPaywallActivity?
                     // Cancel any existing fallback notification of the same type before scheduling
                     // the dynamic notification from the paywall
                     paywallActivity?.attemptToScheduleNotifications(
@@ -1456,7 +1512,7 @@ class Superwall(
                         Logger.debug(
                             LogLevel.error,
                             LogScope.paywallView,
-                            message = "No paywall activity alive to schedule notifications",
+                            message = "No superwall paywall activity alive to schedule notifications",
                         )
                     }
                 }

superwall/src/main/java/com/superwall/sdk/config/ConfigLogic.kt

@@ -246,26 +246,23 @@ object ConfigLogic {
 
         // Loop through all the rules and check their preloading behavior
         triggerRulesPerCampaign.forEach { campaignRules ->
-            campaignRules.forEach { rule ->
-                allExperimentIds.add(rule.experiment.id)
-
-                // Check the preloading behavior of each rule
-                when (rule.preload.behavior) {
-                    TriggerPreloadBehavior.IF_TRUE -> {
-                        val outcome =
-                            expressionEvaluator.evaluateExpression(
-                                rule = rule,
-                                eventData = null,
-                            )
-                        if (outcome is TriggerRuleOutcome.NoMatch) {
-                            skippedExperimentIds.add(rule.experiment.id)
-                        }
-                    }
-
-                    TriggerPreloadBehavior.ALWAYS -> {}
-                    TriggerPreloadBehavior.NEVER -> skippedExperimentIds.add(rule.experiment.id)
-                }
+            allExperimentIds.addAll(campaignRules.map { it.experiment.id })
+            val ifTrueRules = campaignRules
+                .filter { it.preload.behavior == TriggerPreloadBehavior.IF_TRUE }
+
+            val firstIfTrueMatch = ifTrueRules.firstOrNull {
+                expressionEvaluator.evaluateExpression(
+                    rule = it,
+                    eventData = null,
+                ) is TriggerRuleOutcome.Match
+            }
+            val skippedIfTrueRules = ifTrueRules.map { it.experiment.id }.filter { rule ->
+                rule != firstIfTrueMatch?.experiment?.id
             }
+            val skippedNeverRules = campaignRules.filter {
+                it.preload.behavior == TriggerPreloadBehavior.NEVER
+            }.map { it.experiment.id }
+            skippedExperimentIds.addAll(skippedIfTrueRules + skippedNeverRules)
         }
 
         // Remove any confirmed experiment IDs that are no longer part of a trigger
@@ -320,12 +317,13 @@ object ConfigLogic {
     }
 
     // Returns entitlements mapped by product ID
-    fun extractEntitlementsByProductId(from: List<ProductItem>) = from.associate { it.fullProductId to it.entitlements }
+    fun extractEntitlementsByProductId(from: List<ProductItem>) =
+        from.associate { it.fullProductId to it.entitlements }
 
     // Returns entitlements mapped by product ID for CrossplatformProduct
     fun extractEntitlementsByProductIdFromCrossplatform(from: List<CrossplatformProduct>) =
         from.associate {
             it.fullProductId to
-                it.entitlements.toSet()
+                    it.entitlements.toSet()
         }
 }

superwall/src/main/java/com/superwall/sdk/config/ConfigManager.kt

@@ -21,6 +21,7 @@ import com.superwall.sdk.models.entitlements.SubscriptionStatus
 import com.superwall.sdk.models.triggers.Experiment
 import com.superwall.sdk.models.triggers.ExperimentID
 import com.superwall.sdk.models.triggers.Trigger
+import com.superwall.sdk.models.triggers.TriggerPreloadBehavior
 import com.superwall.sdk.network.SuperwallAPI
 import com.superwall.sdk.network.awaitUntilNetworkExists
 import com.superwall.sdk.network.device.DeviceHelper
@@ -142,6 +143,29 @@ open class ConfigManager(
         immediate(ConfigState.Actions.PreloadAll)
     }
 
+    /**
+     * Re-runs preload if any DeviceHelper field referenced by IF_TRUE rules has
+     * changed since the last preload. Cheap no-op when (a) config has no IF_TRUE
+     * rule or (b) the fingerprint matches the last dispatched preload.
+     *
+     * Call this from change-emitting signals (subscription status, configuration
+     * change, interface style override, store readiness, review-request increment).
+     */
+    suspend fun recheckPreloadIfNeeded() {
+        val config = actor.state.value.getConfig() ?: return
+        val hasIfTrue =
+            config.triggers.any { trigger ->
+                trigger.rules.any { it.preload.behavior == TriggerPreloadBehavior.IF_TRUE }
+            }
+        if (!hasIfTrue) return
+        // Cheap pre-check; the authoritative dedup + atomic claim lives inside
+        // paywallPreload.preloadAllPaywalls so it commits only when a preload
+        // actually starts (and rolls back if the run is dropped).
+        val fingerprint = deviceHelper.preloadFingerprint()
+        if (paywallPreload.lastFingerprint.get() == fingerprint) return
+        immediate(ConfigState.Actions.PreloadIfEnabled)
+    }
+
     suspend fun preloadPaywallsByNames(eventNames: Set<String>) {
         actor.state.awaitFirstValidConfig()
         immediate(ConfigState.Actions.PreloadByNames(eventNames))

superwall/src/main/java/com/superwall/sdk/config/PaywallPreload.kt

@@ -20,6 +20,7 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.delay
+import java.util.concurrent.atomic.AtomicReference
 
 class PaywallPreload(
     val factory: Factory,
@@ -36,11 +37,32 @@ class PaywallPreload(
 
     private var currentPreloadingTask: Job? = null
 
+    /**
+     * Fingerprint of the device/store/subscription state of the most recent
+     * preload that actually *started* (i.e. wasn't dropped by the "already
+     * running" guard). Compared by ConfigManager.recheckPreloadIfNeeded to
+     * decide whether attribute changes warrant a re-preload. Atomic so concurrent
+     * rechecks don't both claim the same dispatch slot.
+     */
+    internal val lastFingerprint: AtomicReference<String?> = AtomicReference(null)
+
     suspend fun preloadAllPaywalls(
         config: Config,
         context: Context,
+        fingerprint: String? = null,
     ) {
-        if (currentPreloadingTask != null) {
+        if (fingerprint != null) {
+            val previous = lastFingerprint.get()
+            // Already preloaded this exact state, or another caller raced ahead.
+            if (previous == fingerprint) return
+            if (!lastFingerprint.compareAndSet(previous, fingerprint)) return
+            // CAS won; if the preload below is dropped, roll back so future
+            // rechecks can retry.
+            if (currentPreloadingTask != null) {
+                lastFingerprint.compareAndSet(fingerprint, previous)
+                return
+            }
+        } else if (currentPreloadingTask != null) {
             return
         }
 
@@ -208,8 +230,12 @@ class PaywallPreload(
                         oldCacheKey != null && keyChanged
                     }.map { it.identifier } - presentedPaywallId
 
-        changedIds.toSet().filterNotNull().forEach {
+        val toRemove = changedIds.toSet().filterNotNull()
+        toRemove.forEach {
             paywallManager.removePaywallView(it)
         }
+        if (toRemove.isNotEmpty()) {
+            lastFingerprint.set(null)
+        }
     }
 }

superwall/src/main/java/com/superwall/sdk/config/models/ConfigState.kt

@@ -356,7 +356,11 @@ sealed class ConfigState {
         object PreloadIfEnabled : Actions(exec@{
             if (!options.computedShouldPreload(deviceHelper.deviceTier)) return@exec
             val config = state.value.getConfig() ?: return@exec
-            paywallPreload.preloadAllPaywalls(config, context)
+            paywallPreload.preloadAllPaywalls(
+                config,
+                context,
+                fingerprint = deviceHelper.preloadFingerprint(),
+            )
         })
 
         object PreloadAll : Actions(exec@{