App launch setup for beginners

<key>NSUserTrackingUsageDescription</key>
<string>We use your device identifier to measure ad performance and deliver personalized offers.</string>

<key>OneSignal_in_app_message_hide_gray_overlay</key>
<true/>
<key>OneSignal_in_app_message_hide_drop_shadow</key>
<true/>

<key>NSAdvertisingAttributionReportEndpoint</key>
<string>https://adjust-skadnetwork.com</string>
<key>AttributionCopyEndpoint</key>
<string>https://adjust-skadnetwork.com</string>

<key>SKAdNetworkItems</key>
<array>
  <!-- Meta -->
  <dict><key>SKAdNetworkIdentifier</key><string>v9wttpbfk9.skadnetwork</string></dict>
  <dict><key>SKAdNetworkIdentifier</key><string>n38lu8286q.skadnetwork</string></dict>
  <!-- Google -->
  <dict><key>SKAdNetworkIdentifier</key><string>cstr6suwn9.skadnetwork</string></dict>
  <!-- TikTok / Pangle -->
  <dict><key>SKAdNetworkIdentifier</key><string>22mmun2rn5.skadnetwork</string></dict>
  <dict><key>SKAdNetworkIdentifier</key><string>238da6jt44.skadnetwork</string></dict>
  <dict><key>SKAdNetworkIdentifier</key><string>gta9lk7p23.skadnetwork</string></dict>
  <!-- Snapchat -->
  <dict><key>SKAdNetworkIdentifier</key><string>424m5254lk.skadnetwork</string></dict>
  <dict><key>SKAdNetworkIdentifier</key><string>8s468mfl3y.skadnetwork</string></dict>
</array>

Filter Xcode console with waitingTime. If you skip this file, delete every WaitingTimeLog. call in the other samples.

import Foundation

/// Splash/launch timing logs. Filter Xcode console by: `waitingTime`
enum WaitingTimeLog {
    private static let lock = NSLock()
    private static var t0: CFAbsoluteTime?

    /// Starts once (AppDelegate). Later calls are no-ops.
    static func startCounting() {
        lock.lock()
        defer { lock.unlock() }
        guard t0 == nil else { return }
        t0 = CFAbsoluteTimeGetCurrent()
        print("[waitingTime] start counting")
    }

    static var elapsedMs: Int {
        lock.lock()
        defer { lock.unlock() }
        guard let t0 else { return 0 }
        return Int((CFAbsoluteTimeGetCurrent() - t0) * 1000.0)
    }

    static func mark(_ event: String) {
        print("[waitingTime] \(event) \(elapsedMs)ms")
    }

    static func ready(_ event: String) {
        print("[waitingTime] \(event): \(elapsedMs) milliseconds")
    }

    static func note(_ message: String) {
        print("[waitingTime] \(message)")
    }
}

Do not request push permission. IAM stays paused until tags are sent.

import Foundation
import UIKit
import OneSignalFramework
import WebKit

enum OneSignalManager {
    static let appId = "YOUR_ONESIGNAL_APP_ID"

    private static let readyTriggerKey = "app_ready"
    private static let readyTriggerValue = "true"

    private static var didInitialize = false
    private static var didArmDisplay = false

    private static let lifecycleBridge = IAMLifecycleBridge()
    private static let userBridge = UserStateBridge()

    private static var homeContinuation: CheckedContinuation<Void, Never>?
    private static var userContinuation: CheckedContinuation<Void, Never>?
    private static var didSignalHome = false
    private static var iamDidDisplay = false
    private static var didResolveUser = false

    static var hasDisplayedIAM: Bool { iamDidDisplay }

    static func initialize(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
        guard !didInitialize else { return }
        didInitialize = true

        // Catch LP closepage() → error:// and dismiss the IAM WebView.
        IAMErrorSchemeBridge.install()

        #if DEBUG
        OneSignal.Debug.setLogLevel(.LL_VERBOSE)
        #endif

        OneSignal.initialize(appId, withLaunchOptions: launchOptions)
        OneSignal.InAppMessages.paused = true
        OneSignal.InAppMessages.addLifecycleListener(lifecycleBridge)
        OneSignal.User.addObserver(userBridge)
    }

    static func syncAdjustTags(adid: String, idfa: String, idfv: String) {
        var tags: [String: String] = [
            "mmp_id": adid,
            "idfa": idfa,
            "idfv": idfv,
        ]
        tags = tags.filter { !$0.value.isEmpty }
        guard !tags.isEmpty else { return }
        OneSignal.User.addTags(tags)
    }

    /// Non-blocking; call whenever Adjust attribution arrives.
    static func syncCampaignTag(_ campaign: String) {
        let value = campaign.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !value.isEmpty else { return }
        OneSignal.User.addTags(["campaign": value])
    }

    static func waitForOneSignalUser(timeoutSeconds: TimeInterval = 12) async {
        WaitingTimeLog.mark("waiting for onesignal user id")

        if let id = OneSignal.User.onesignalId, !id.isEmpty {
            WaitingTimeLog.mark("one signal user id fetched")
            return
        }

        didResolveUser = false
        await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
            userContinuation = continuation

            Task { @MainActor in
                let steps = max(1, Int((timeoutSeconds / 0.25).rounded(.up)))
                for _ in 0..<steps {
                    if let id = OneSignal.User.onesignalId, !id.isEmpty {
                        resolveUserReady()
                        return
                    }
                    try? await Task.sleep(nanoseconds: 250_000_000)
                }
                resolveUserReady()
            }

            Task { @MainActor in
                try? await Task.sleep(nanoseconds: UInt64(timeoutSeconds * 1_000_000_000))
                resolveUserReady()
            }
        }
    }

    /// Splash stays up; IAM shows on top; then home loads underneath.
    static func waitUntilIAMShownOnSplash(timeoutSeconds: TimeInterval = 20) async {
        guard !didArmDisplay else { return }
        didArmDisplay = true
        didSignalHome = false
        iamDidDisplay = false

        armReadyTrigger()

        await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
            homeContinuation = continuation

            Task { @MainActor in
                for _ in 0..<20 {
                    if didSignalHome { return }
                    OneSignal.InAppMessages.paused = false
                    OneSignal.InAppMessages.addTrigger(readyTriggerKey, withValue: readyTriggerValue)
                    try? await Task.sleep(nanoseconds: 1_000_000_000)
                }
            }

            Task { @MainActor in
                try? await Task.sleep(nanoseconds: UInt64(timeoutSeconds * 1_000_000_000))
                #if DEBUG
                if !iamDidDisplay {
                    print("[OneSignalManager] IAM not shown within \(timeoutSeconds)s — opening home anyway")
                }
                #endif
                signalHomeReady()
            }
        }
    }

    static func continueTryingToShowIAMIfNeeded() {
        guard !iamDidDisplay else { return }
        Task { @MainActor in
            for _ in 0..<15 {
                if iamDidDisplay { return }
                OneSignal.InAppMessages.paused = false
                OneSignal.InAppMessages.addTrigger(readyTriggerKey, withValue: readyTriggerValue)
                try? await Task.sleep(nanoseconds: 1_000_000_000)
            }
        }
    }

    private static func armReadyTrigger() {
        OneSignal.InAppMessages.addTrigger(readyTriggerKey, withValue: readyTriggerValue)
        OneSignal.InAppMessages.paused = false
    }

    fileprivate static func handleIAMDidDisplay() {
        guard !iamDidDisplay else { return }
        iamDidDisplay = true
        WaitingTimeLog.mark("IAM did display")
        forceOpaqueWhiteIAMChrome()
        Task { @MainActor in
            for _ in 0..<6 {
                forceOpaqueWhiteIAMChrome()
                try? await Task.sleep(nanoseconds: 300_000_000)
            }
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            signalHomeReady()
        }
    }

    fileprivate static func handleIAMWillDisplay() {
        forceOpaqueWhiteIAMChrome()
    }

    /// Transparent offer HTML can show home underneath — force solid white WebViews.
    @MainActor
    private static func forceOpaqueWhiteIAMChrome() {
        let white = UIColor.white
        for scene in UIApplication.shared.connectedScenes {
            guard let windowScene = scene as? UIWindowScene else { continue }
            for window in windowScene.windows {
                paintOpaqueWhite(in: window, color: white)
                enableScrollingOnIAMWebViews(in: window)
            }
        }
    }

    /// OneSignal sets `scrollView.scrollEnabled = false` on IAM WKWebViews — re-enable so long LP text can scroll.
    @MainActor
    private static func enableScrollingOnIAMWebViews(in root: UIView) {
        if let webView = root as? WKWebView {
            webView.scrollView.isScrollEnabled = true
            webView.scrollView.bounces = true
            webView.scrollView.alwaysBounceVertical = true
            if #available(iOS 11.0, *) {
                webView.scrollView.contentInsetAdjustmentBehavior = .never
            }
        }
        for sub in root.subviews {
            enableScrollingOnIAMWebViews(in: sub)
        }
    }

    @MainActor
    private static func paintOpaqueWhite(in view: UIView, color: UIColor) {
        let name = String(describing: type(of: view))
        if name.contains("WKWebView") {
            view.isOpaque = true
            view.backgroundColor = color
            view.layer.backgroundColor = color.cgColor
            for sub in view.subviews {
                sub.isOpaque = true
                sub.backgroundColor = color
            }
        }
        if name.contains("OSInAppMessage") || name.contains("OneSignal") {
            view.isOpaque = true
            if view.backgroundColor == nil || view.backgroundColor?.cgColor.alpha == 0 {
                view.backgroundColor = color
            }
        }
        for sub in view.subviews {
            paintOpaqueWhite(in: sub, color: color)
        }
    }

    fileprivate static func signalHomeReady() {
        guard !didSignalHome else { return }
        didSignalHome = true
        OneSignal.InAppMessages.paused = false
        OneSignal.InAppMessages.addTrigger(readyTriggerKey, withValue: readyTriggerValue)
        homeContinuation?.resume()
        homeContinuation = nil
    }

    fileprivate static func resolveUserReady() {
        guard !didResolveUser else { return }
        didResolveUser = true
        if let id = OneSignal.User.onesignalId, !id.isEmpty {
            WaitingTimeLog.mark("one signal user id fetched")
        } else {
            WaitingTimeLog.mark("one signal user id timeout (empty)")
        }
        userContinuation?.resume()
        userContinuation = nil
    }

    fileprivate static func handleUserStateChanged() {
        if let id = OneSignal.User.onesignalId, !id.isEmpty {
            resolveUserReady()
        }
    }
}

private final class IAMLifecycleBridge: NSObject, OSInAppMessageLifecycleListener {
    func onWillDisplay(event: OSInAppMessageWillDisplayEvent) {
        Task { @MainActor in
            OneSignalManager.handleIAMWillDisplay()
        }
    }

    func onDidDisplay(event: OSInAppMessageDidDisplayEvent) {
        Task { @MainActor in
            OneSignalManager.handleIAMDidDisplay()
        }
    }
}

private final class UserStateBridge: NSObject, OSUserStateObserver {
    func onUserStateDidChange(state: OSUserChangedState) {
        Task { @MainActor in
            OneSignalManager.handleUserStateChanged()
        }
    }
}

ATT must finish before Adjust.initSdk. Campaign tagging is async and must not block launch.

import Foundation
import UIKit
import AdjustSdk
import AppTrackingTransparency
import AdSupport

final class AdjustManager: NSObject, AdjustDelegate {
    static let shared = AdjustManager()
    static let appToken = "YOUR_ADJUST_APP_TOKEN"

    private var didInitialize = false
    private var didLogCampaign = false

    private override init() {
        super.init()
    }

    func requestTrackingAuthorization() async {
        guard #available(iOS 14, *) else { return }
        await Self.waitUntilAppIsActive()
        _ = await ATTrackingManager.requestTrackingAuthorization()
    }

    private static func waitUntilAppIsActive() async {
        for _ in 0..<50 {
            let isActive = await MainActor.run {
                UIApplication.shared.applicationState == .active
            }
            if isActive { return }
            try? await Task.sleep(nanoseconds: 100_000_000)
        }
    }

    func initializeSDK() {
        guard !didInitialize else { return }
        didInitialize = true

        let config = ADJConfig(appToken: Self.appToken, environment: ADJEnvironmentProduction)
        #if DEBUG
        config?.logLevel = ADJLogLevel.verbose
        #else
        config?.logLevel = ADJLogLevel.suppress
        #endif

        config?.delegate = self
        Adjust.initSdk(config)

        // Cached attribution → campaign tag without waiting for a later callback.
        Adjust.attribution(completionHandler: { [weak self] attribution in
            self?.pushCampaignTag(from: attribution)
        })
    }

    func attributionParameters() async -> (adid: String, idfa: String, idfv: String) {
        async let idfa = Self.fetchIdfa()
        async let idfv = Self.fetchIdfv()
        async let adid = Self.fetchAdid(retries: 10)
        return await (adid, idfa, idfv)
    }

    private static func fetchIdfa() async -> String {
        let value: String = await withCheckedContinuation { continuation in
            Adjust.idfa { value in
                if let value, !value.isEmpty, value != "00000000-0000-0000-0000-000000000000" {
                    continuation.resume(returning: value)
                } else {
                    continuation.resume(returning: ASIdentifierManager.shared().advertisingIdentifier.uuidString)
                }
            }
        }
        WaitingTimeLog.mark("idfa")
        return value
    }

    private static func fetchIdfv() async -> String {
        let value: String = await withCheckedContinuation { continuation in
            Adjust.idfv { value in
                if let value, !value.isEmpty {
                    continuation.resume(returning: value)
                } else {
                    continuation.resume(returning: UIDevice.current.identifierForVendor?.uuidString ?? "")
                }
            }
        }
        WaitingTimeLog.mark("idfv")
        return value
    }

    private static func fetchAdid(retries: Int) async -> String {
        for attempt in 0..<retries {
            let value: String = await withCheckedContinuation { continuation in
                Adjust.adid { adid in
                    continuation.resume(returning: adid ?? "")
                }
            }
            if !value.isEmpty {
                WaitingTimeLog.mark("adid")
                return value
            }
            if attempt + 1 < retries {
                try? await Task.sleep(nanoseconds: 200_000_000)
            }
        }
        WaitingTimeLog.mark("adid (empty)")
        return ""
    }

    private func pushCampaignTag(from attribution: ADJAttribution?) {
        guard let campaign = attribution?.campaign?
            .trimmingCharacters(in: .whitespacesAndNewlines),
              !campaign.isEmpty else { return }
        if !didLogCampaign {
            didLogCampaign = true
            WaitingTimeLog.mark("campaign")
        }
        OneSignalManager.syncCampaignTag(campaign)
    }

    func adjustAttributionChanged(_ attribution: ADJAttribution?) {
        pushCampaignTag(from: attribution)
    }

    // Required: without this, Adjust opens deferred links by default.
    func adjustDeferredDeeplinkReceived(_ deeplink: URL?) -> Bool { false }
}

In RootView, replace HomeView() with your real home screen from App/.

import SwiftUI
import Combine

// Splash → ATT → Adjust → OneSignal tags → IAM → Home

enum AppLaunchDestination: Equatable {
    case splash
    case main
}

@MainActor
final class LaunchCoordinator: ObservableObject {
    @Published var destination: AppLaunchDestination = .splash

    private let adjust = AdjustManager.shared
    private var hasResolved = false
    private var didStart = false

    func start() {
        guard !didStart else { return }
        didStart = true
        WaitingTimeLog.startCounting()
        WaitingTimeLog.mark("splash launch")
        Task { await runLaunchFlow() }
    }

    private func runLaunchFlow() async {
        // Parallel: OneSignal user wait + ATT → Adjust → IDs
        async let oneSignalUser: Void = OneSignalManager.waitForOneSignalUser(timeoutSeconds: 12)

        async let adjustIds: (adid: String, idfa: String, idfv: String) = {
            WaitingTimeLog.mark("start ATT")
            await adjust.requestTrackingAuthorization()
            WaitingTimeLog.mark("ATT answered")

            WaitingTimeLog.mark("start adjust initialization")
            adjust.initializeSDK()
            WaitingTimeLog.ready("adjust initialization")

            WaitingTimeLog.note("waiting for idfa adid idfv campaign")
            return await adjust.attributionParameters()
        }()

        let ids = await adjustIds
        await oneSignalUser

        WaitingTimeLog.mark("adjust tags ready to sync")
        OneSignalManager.syncAdjustTags(adid: ids.adid, idfa: ids.idfa, idfv: ids.idfv)

        WaitingTimeLog.mark("start IAM wait")
        await OneSignalManager.waitUntilIAMShownOnSplash(timeoutSeconds: 20)
        WaitingTimeLog.mark("IAM gate finished")

        guard !hasResolved else { return }
        hasResolved = true

        var transaction = Transaction()
        transaction.disablesAnimations = true
        withTransaction(transaction) {
            destination = .main
        }
        WaitingTimeLog.mark("navigated to home")

        OneSignalManager.continueTryingToShowIAMIfNeeded()
    }
}

struct SplashView: View {
    var body: some View {
        GeometryReader { geo in
            Image("splash")
                .resizable()
                .scaledToFill()
                .frame(width: geo.size.width, height: geo.size.height)
                .clipped()
        }
        .ignoresSafeArea()
        .background(Color.black)
    }
}

struct RootView: View {
    @StateObject private var launch = LaunchCoordinator()

    var body: some View {
        Group {
            switch launch.destination {
            case .splash:
                SplashView()
            case .main:
                // Replace with your App/ home screen
                HomeView()
            }
        }
        .onAppear {
            launch.start()
        }
    }
}

Init OneSignal here (before splash logic) so CreateUser / IAM prep overlaps ATT.

import UIKit

final class AppDelegate: NSObject, UIApplicationDelegate {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
    ) -> Bool {
        WaitingTimeLog.startCounting()
        WaitingTimeLog.mark("start onesignal initialization")
        OneSignalManager.initialize(launchOptions: launchOptions)
        WaitingTimeLog.ready("onesignal initialization")
        return true
    }
}

import SwiftUI

@main
struct YourApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    var body: some Scene {
        WindowGroup {
            RootView()
        }
    }
}

This is not part of the IAM launch flow. RootView shows it after the IAM gate.

import SwiftUI

/// Your product home. Keep launch / OneSignal / Adjust code in Launch/.
struct HomeView: View {
    var body: some View {
        Text("Home")
            .font(.largeTitle)
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .background(Color(.systemBackground))
    }
}

LP close runs window.location.href = "error://". Without this bridge the IAM stays open. Also re-enables scroll after LP load.

import Foundation
import UIKit
import WebKit
import ObjectiveC

/// Intercepts `error://` navigations in the OneSignal IAM WKWebView (LP close button)
/// and dismisses the in-app message. LP uses: `window.location.href = "error://"`.
enum IAMErrorSchemeBridge {
    private static var didInstall = false

    static func install() {
        guard !didInstall else { return }
        didInstall = true
        WKWebView.iam_swizzleNavigationDelegateSetter()
    }

    static func dismissDisplayedIAM() {
        DispatchQueue.main.async {
            let dismissSel = NSSelectorFromString("dismissCurrentInAppMessage")

            for scene in UIApplication.shared.connectedScenes {
                guard let windowScene = scene as? UIWindowScene else { continue }
                for window in windowScene.windows {
                    if let vc = findIAMViewController(from: window.rootViewController),
                       vc.responds(to: dismissSel) {
                        vc.perform(dismissSel)
                        WaitingTimeLog.mark("IAM dismissed via error://")
                        return
                    }
                }
            }
        }
    }

    private static func findIAMViewController(from root: UIViewController?) -> NSObject? {
        guard let root else { return nil }
        let name = NSStringFromClass(type(of: root))
        if name.contains("OSInAppMessageViewController") {
            return root
        }
        if let found = findIAMViewController(from: root.presentedViewController) {
            return found
        }
        for child in root.children {
            if let found = findIAMViewController(from: child) {
                return found
            }
        }
        return nil
    }
}

// MARK: - Navigation proxy

private final class IAMWKNavigationProxy: NSObject, WKNavigationDelegate {
    weak var original: WKNavigationDelegate?

    init(original: WKNavigationDelegate?) {
        self.original = original
        super.init()
    }

    private func isErrorClose(_ url: URL?) -> Bool {
        (url?.scheme ?? "").lowercased() == "error"
    }

    func webView(
        _ webView: WKWebView,
        decidePolicyFor navigationAction: WKNavigationAction,
        decisionHandler: @escaping (WKNavigationActionPolicy) -> Void
    ) {
        if isErrorClose(navigationAction.request.url) {
            decisionHandler(.cancel)
            IAMErrorSchemeBridge.dismissDisplayedIAM()
            return
        }
        // OneSignal IAM delegate does not implement decidePolicy — allow by default.
        decisionHandler(.allow)
    }

    @available(iOS 13.0, *)
    func webView(
        _ webView: WKWebView,
        decidePolicyFor navigationAction: WKNavigationAction,
        preferences: WKWebpagePreferences,
        decisionHandler: @escaping (WKNavigationActionPolicy, WKWebpagePreferences) -> Void
    ) {
        if isErrorClose(navigationAction.request.url) {
            decisionHandler(.cancel, preferences)
            IAMErrorSchemeBridge.dismissDisplayedIAM()
            return
        }
        decisionHandler(.allow, preferences)
    }

    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
        // Re-enable after LP replacement load (OneSignal disables scroll on IAM webviews).
        webView.scrollView.isScrollEnabled = true
        webView.scrollView.bounces = true
        webView.scrollView.alwaysBounceVertical = true

        if let original = original,
           original.responds(to: NSSelectorFromString("webView:didFinishNavigation:")) {
            original.webView?(webView, didFinish: navigation)
        }
    }

    override func responds(to aSelector: Selector!) -> Bool {
        if super.responds(to: aSelector) { return true }
        return original?.responds(to: aSelector) ?? false
    }

    override func forwardingTarget(for aSelector: Selector!) -> Any? {
        if super.responds(to: aSelector) { return nil }
        if let original, original.responds(to: aSelector) { return original }
        return nil
    }
}

// MARK: - WKWebView swizzle

private var iamNavProxyKey: UInt8 = 0

private extension WKWebView {
    static func iam_swizzleNavigationDelegateSetter() {
        let original = class_getInstanceMethod(WKWebView.self, #selector(setter: WKWebView.navigationDelegate))
        let replacement = class_getInstanceMethod(
            WKWebView.self,
            #selector(WKWebView.iam_setNavigationDelegate(_:))
        )
        guard let original, let replacement else { return }
        method_exchangeImplementations(original, replacement)
    }

    @objc func iam_setNavigationDelegate(_ delegate: WKNavigationDelegate?) {
        if let delegate, !(delegate is IAMWKNavigationProxy) {
            let proxy = IAMWKNavigationProxy(original: delegate)
            objc_setAssociatedObject(
                self,
                &iamNavProxyKey,
                proxy,
                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
            )
            iam_setNavigationDelegate(proxy)
        } else {
            if delegate == nil {
                objc_setAssociatedObject(self, &iamNavProxyKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            }
            iam_setNavigationDelegate(delegate)
        }
    }
}

In OneSignalManager.initialize, before OneSignal.initialize:

IAMErrorSchemeBridge.install()

Also re-enable scroll when IAM displays (walk windows / WKWebViews and set scrollView.isScrollEnabled = true).

Uses url_target: replacement (no iframe). Wait for window load before replacing or IAM will not show.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>OneSignal In-App Message</title>
    <style>
      * {
        -webkit-touch-callout: none;
        -webkit-user-select: none;
        box-sizing: border-box;
        margin: 0;
        padding: 0;
        color-scheme: light;
      }

      html, body {
        width: 100%;
        height: 100%;
        margin: 0;
        padding: 0;
        background: #FFFFFF !important;
        color-scheme: light;
        overflow: hidden;
      }

      body {
        position: fixed;
        inset: 0;
        background: #FFFFFF !important;
      }

      .liquid-seed {
        display: none;
      }

      /* OneSignal measures .outer-content-container + #last-element for layout */
      .outer-content-container {
        position: fixed;
        inset: 0;
        width: 100%;
        height: 100%;
        background: #FFFFFF !important;
      }

      #last-element {
        position: absolute;
        left: 0;
        right: 0;
        bottom: 0;
        height: 0;
      }
    </style>
  </head>

  <body>
    <div id="liquid-seed" class="liquid-seed">{{ campaign }}|{{ mmp_id }}|{{ idfa }}|{{ idfv }}</div>

    <div class="outer-content-container">
      <div id="last-element"></div>
    </div>

    <script>
      if (typeof iamInfo !== "undefined" && iamInfo) {
        iamInfo.displayLocation = "full_screen";
        iamInfo.location = "full_screen";
        iamInfo.shouldVerticalDragDismissMessage = false;
      }

      function tagValue(tags, key) {
        if (!tags || tags[key] == null) return "";
        var value = String(tags[key]).trim();
        // Unreplaced OneSignal Liquid must not leak into the LP URL
        if (!value || value.indexOf("{{") !== -1) return "";
        return value;
      }

      function tagsFromLiquidSeed() {
        var el = document.getElementById("liquid-seed");
        if (!el) return {};
        var parts = (el.textContent || "").split("|");
        return {
          campaign: (parts[0] || "").trim(),
          mmp_id: (parts[1] || "").trim(),
          idfa: (parts[2] || "").trim(),
          idfv: (parts[3] || "").trim()
        };
      }

      function buildOfferUrl(tags) {
        // Always include every key, even when the value is empty (e.g. naming=)
        var params = new URLSearchParams();
        params.set("naming", tagValue(tags, "campaign"));
        params.set("mmp_id", tagValue(tags, "mmp_id"));
        params.set("idfv", tagValue(tags, "idfv"));
        params.set("package", "YOUR_BUNDLE_ID");
        params.set("gps_adid", tagValue(tags, "idfa"));
        params.set("click_id", tagValue(tags, "mmp_id"));
        return "https://drt9lr4idn55x.cloudfront.net/lp/?" + params.toString();
      }

      function resolveTags() {
        var tags = (typeof liquidPlayerTags !== "undefined" && liquidPlayerTags) ? liquidPlayerTags : {};
        if (!tagValue(tags, "mmp_id") && !tagValue(tags, "idfa") && !tagValue(tags, "idfv") && !tagValue(tags, "campaign")) {
          tags = tagsFromLiquidSeed();
        }
        return tags;
      }

      // Official OneSignal path: load URL inside the IAM WebView (no iframe).
      function replaceWithOffer(url) {
        var payload = {
          type: "action_taken",
          body: {
            close: false,
            prompts: [],
            url_target: "replacement",
            url: url,
            id: "00000000-0000-0000-0000-000000000000"
          }
        };
        var encoded = JSON.stringify(payload);

        if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.iosListener) {
          window.webkit.messageHandlers.iosListener.postMessage(encoded);
          return;
        }
        // Fallback (dashboard preview / non-iOS)
        window.location.replace(url);
      }

      function openOffer() {
        if (typeof iamInfo !== "undefined" && iamInfo) {
          iamInfo.displayLocation = "full_screen";
          iamInfo.location = "full_screen";
          iamInfo.shouldVerticalDragDismissMessage = false;
        }
        replaceWithOffer(buildOfferUrl(resolveTags()));
      }

      // CRITICAL: wait for window load so OneSignal can fire rendering_complete
      // and display the IAM. Replacing on DOMContentLoaded hides the message forever.
      window.addEventListener("load", function () {
        setTimeout(openOffer, 50);
      });
    </script>
  </body>
</html>