Start a skipped MMP match when the app turns tracking back on

The match was skipped for the rest of the launch if tracking was off
when config enabled the MMP. It now starts when the app opts back in,
and the launch-time setup no longer depends on the tracking setting.
The match still starts at most once per launch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: yusuftor

CHANGELOG.md

@@ -14,6 +14,7 @@ The changelog for `SuperwallKit`. Also see the [releases](https://github.com/sup
 
 - Fixes the SDK getting stuck in test mode when a sheet such as the Customer Center is already open as it finishes loading.
 - Stops matching installs for attribution unless the Superwall MMP is turned on for your app.
+- Fixes paywalls on first launch missing acquisition attributes in their audience filters: they now wait up to 2 seconds for install attribution to finish.
 
 ## 4.17.0
 

Sources/SuperwallKit/Analytics/Attribution/MMPAttributionManager.swift

@@ -26,6 +26,9 @@ final class MMPAttributionManager {
   private unowned let identityManager: IdentityManager
   private unowned let configManager: ConfigManager
   private var pendingMatch: AnyCancellable?
+  private let lock = NSLock()
+  private var startMatch: (() -> Task<Void, Never>?)?
+  private var hasStartedMatch = false
   /// `true` from when this launch's install match is set up until it finishes
   /// or is skipped.
   private let isMatchPending = CurrentValueSubject<Bool, Never>(false)
@@ -50,29 +53,56 @@ final class MMPAttributionManager {
   /// default, so it never fires if the backend doesn't turn it on. Works the
   /// same way `AttributionPoster` waits for Apple Search Ads to be enabled.
   ///
-  /// `startMatch` returns the running match, if it started one, so paywalls
-  /// can wait for it.
+  /// `startMatch` returns the running match, or `nil` if it skipped it
+  /// because the app has opted out of tracking. A skipped match is tried
+  /// again when the app opts back in, via `startMatchIfEnabled()`.
   func matchInstallOnceEnabled(_ startMatch: @escaping () -> Task<Void, Never>?) {
+    lock.lock()
+    self.startMatch = startMatch
+    lock.unlock()
     isMatchPending.send(true)
+
     pendingMatch = configManager.configState
       .compactMap { $0.getConfig() }
       .map { $0.attribution?.mmp?.enabled == true }
-      .first { $0 }
+      .removeDuplicates()
+      .filter { $0 }
       .sink(
         receiveCompletion: { _ in },
         receiveValue: { [weak self] _ in
-          guard let match = startMatch() else {
-            self?.isMatchPending.send(false)
-            return
-          }
-          Task { [weak self] in
-            await match.value
-            self?.isMatchPending.send(false)
-          }
+          self?.startMatchIfEnabled()
         }
       )
   }
 
+  /// Starts this launch's install match if config has the MMP on and it
+  /// hasn't started yet. Called when config arrives and when the app turns
+  /// tracking back on.
+  func startMatchIfEnabled() {
+    if configManager.config?.attribution?.mmp?.enabled != true {
+      return
+    }
+    lock.lock()
+    defer { lock.unlock() }
+    guard
+      !hasStartedMatch,
+      let startMatch = startMatch
+    else {
+      return
+    }
+    guard let match = startMatch() else {
+      // Skipped while opted out. Don't hold paywalls up in the meantime.
+      isMatchPending.send(false)
+      return
+    }
+    hasStartedMatch = true
+    isMatchPending.send(true)
+    Task { [weak self] in
+      await match.value
+      self?.isMatchPending.send(false)
+    }
+  }
+
   /// On a first launch, a paywall can be requested while the install match is
   /// still running. If the MMP is on and the placement's audiences use
   /// `acquisition_*` attributes, this waits for the match, up to `timeout`, so

Sources/SuperwallKit/Superwall.swift

@@ -78,6 +78,10 @@ public final class Superwall: NSObject, ObservableObject {
     set {
       options.eventTrackingBehavior = newValue
 
+      if newValue != .none {
+        dependencyContainer.mmpAttributionManager.startMatchIfEnabled()
+      }
+
       Task {
         await dependencyContainer.placementsQueue.setTrackingBehavior(newValue)
       }
@@ -540,24 +544,22 @@ public final class Superwall: NSObject, ObservableObject {
 
       _ = await configureIdentity
 
-      // Skip install-attribution matching entirely when the developer has
-      // opted out of all event collection. The `/api/match` call and the
-      // `acquisition_*` attribute writes happen outside the event queue, so
-      // queue-level suppression wouldn't catch them.
-      if dependencyContainer.configManager.options.eventTrackingBehavior != .none,
-        dependencyContainer.storage.shouldAttemptInitialMMPInstallAttributionMatch(
-          hadTrackedAppInstallBeforeConfigure: hadTrackedAppInstallBeforeConfigure,
-          appInstalledAtString: dependencyContainer.deviceHelper.appInstalledAtString
-        ) {
-        // The eligibility check above has to run at launch whatever the
-        // config says: it records that this install may be matched, which a
-        // later launch relies on if this one ends before the match completes.
-        // Only the request itself waits for config to enable the MMP.
+      // The eligibility check has to run at launch whatever the config or
+      // tracking setting says: it records that this install may be matched,
+      // which a later launch relies on if this one ends before the match
+      // completes. Only the request itself waits for config to enable the MMP.
+      if dependencyContainer.storage.shouldAttemptInitialMMPInstallAttributionMatch(
+        hadTrackedAppInstallBeforeConfigure: hadTrackedAppInstallBeforeConfigure,
+        appInstalledAtString: dependencyContainer.deviceHelper.appInstalledAtString
+      ) {
         dependencyContainer.mmpAttributionManager.matchInstallOnceEnabled { [weak dependencyContainer] in
           guard let dependencyContainer = dependencyContainer else {
             return nil
           }
-          // The app may have opted out while the match waited for config.
+          // Skip matching when the app has opted out of all event collection.
+          // The `/api/match` call and the `acquisition_*` attribute writes
+          // happen outside the event queue, so queue-level suppression
+          // wouldn't catch them. It's tried again if the app opts back in.
           if dependencyContainer.configManager.options.eventTrackingBehavior == .none {
             return nil
           }

Tests/SuperwallKitTests/Analytics/Attribution/MMPInstallMatchConfigTests.swift

@@ -37,7 +37,7 @@ struct MMPInstallMatchConfigTests {
 
     dependencyContainer.mmpAttributionManager.matchInstallOnceEnabled {
       counter.count += 1
-      return nil
+      return Task {}
     }
     #expect(counter.count == 0)
 
@@ -52,7 +52,7 @@ struct MMPInstallMatchConfigTests {
 
     dependencyContainer.mmpAttributionManager.matchInstallOnceEnabled {
       counter.count += 1
-      return nil
+      return Task {}
     }
     dependencyContainer.configManager.configState.send(.retrieved(makeConfig(mmpEnabled: nil)))
     dependencyContainer.configManager.configState.send(.retrieved(makeConfig(mmpEnabled: false)))
@@ -68,7 +68,7 @@ struct MMPInstallMatchConfigTests {
 
     dependencyContainer.mmpAttributionManager.matchInstallOnceEnabled {
       counter.count += 1
-      return nil
+      return Task {}
     }
 
     #expect(counter.count == 1)
@@ -81,7 +81,7 @@ struct MMPInstallMatchConfigTests {
 
     dependencyContainer.mmpAttributionManager.matchInstallOnceEnabled {
       counter.count += 1
-      return nil
+      return Task {}
     }
     dependencyContainer.configManager.configState.send(.retrieved(makeConfig(mmpEnabled: true)))
     dependencyContainer.configManager.configState.send(.retrieved(makeConfig(mmpEnabled: false)))
@@ -90,6 +90,49 @@ struct MMPInstallMatchConfigTests {
     #expect(counter.count == 1)
   }
 
+  @Test
+  func startsASkippedMatchWhenTrackingIsTurnedBackOn() {
+    let dependencyContainer = DependencyContainer()
+    let manager = dependencyContainer.mmpAttributionManager!
+    let attempts = Counter()
+    let started = Counter()
+    var isOptedOut = true
+
+    manager.matchInstallOnceEnabled {
+      attempts.count += 1
+      if isOptedOut {
+        return nil
+      }
+      started.count += 1
+      return Task {}
+    }
+    dependencyContainer.configManager.configState.send(.retrieved(makeConfig(mmpEnabled: true)))
+    #expect(attempts.count == 1)
+    #expect(started.count == 0)
+
+    isOptedOut = false
+    manager.startMatchIfEnabled()
+    manager.startMatchIfEnabled()
+    #expect(started.count == 1)
+    #expect(attempts.count == 2)
+  }
+
+  @Test
+  func doesNotStartOnOptInWhenTheMMPIsOff() {
+    let dependencyContainer = DependencyContainer()
+    let manager = dependencyContainer.mmpAttributionManager!
+    let attempts = Counter()
+
+    manager.matchInstallOnceEnabled {
+      attempts.count += 1
+      return Task {}
+    }
+    dependencyContainer.configManager.configState.send(.retrieved(makeConfig(mmpEnabled: false)))
+    manager.startMatchIfEnabled()
+
+    #expect(attempts.count == 0)
+  }
+
   // MARK: - Paywalls waiting for the match
 
   @Test