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

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

        #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)
            }
        }
    }

    @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))
    }
}