iOS

enum AppConstants {
    static let APP_ID     = "YOUR_APP_ID"
    static let REGION     = "YOUR_REGION"
    static let AUTH_KEY   = "YOUR_AUTH_KEY"
    static let PROVIDER_ID = "APNS-PROVIDER-ID"
}

import UIKit
import CometChatSDK
import CometChatUIKitSwift
import CometChatPushNotificationsSwift
#if canImport(CometChatCallsSDK)
import CometChatCallsSDK
#endif

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Your existing CometChat UI Kit / Chat SDK initialization runs elsewhere
        // (typically in SceneDelegate) — the push SDK does not need to run before it.

        let config = CometChatPushNotificationsConfig(
            providerId: AppConstants.PROVIDER_ID,
            enableBadgeCount: true,
            showInAppNotifications: true,
            foregroundCallPresentation: .callKit   // native CallKit UI, foreground included
        )
        CometChatPushNotifications.shared.initialize(config: config)
        CometChatPushNotifications.shared.delegate = self
        CometChatPushNotifications.shared.registerForVoIPPushes()
        return true
    }

    // MARK: - APNs callbacks (forward all three to the SDK)

    func application(_ application: UIApplication,
                     didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        CometChatPushNotifications.shared.registerDeviceToken(deviceToken)
    }

    func application(_ application: UIApplication,
                     didFailToRegisterForRemoteNotificationsWithError error: Error) {
        CometChatPushNotifications.shared.handleRegistrationFailure(error)
    }

    func application(_ application: UIApplication,
                     didReceiveRemoteNotification userInfo: [AnyHashable: Any],
                     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        CometChatPushNotifications.shared.handleBackgroundNotification(userInfo: userInfo)
        completionHandler(.newData)
    }
}

import UIKit
import CometChatUIKitSwift
import CometChatSDK
import CometChatPushNotificationsSwift

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession,
               options: UIScene.ConnectionOptions) {
        let settings = UIKitSettings()
            .set(appID: AppConstants.APP_ID)
            .set(authKey: AppConstants.AUTH_KEY)
            .set(region: AppConstants.REGION)
            .enable(inAppIncomingCall: false)   // let CallKit own the incoming call UI
            .build()

        CometChatUIKit.init(uiKitSettings: settings) { result in
            if case .success = result {
                // Tell the push SDK the Calls stack is ready so a call that arrived
                // during cold start (VoIP push wakes the app in the killed state) can be presented.
                CometChatPushNotifications.shared.notifyCallsSDKReady()
            }
        }
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        CometChatPushNotifications.shared.clearBadgeCount()
    }
}

import CometChatUIKitSwift
import CometChatPushNotificationsSwift

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    if let uid = user?.uid {
        CometChatPushNotifications.shared.setActiveConversation(userId: uid)
    } else if let guid = group?.guid {
        CometChatPushNotifications.shared.setActiveConversation(groupId: guid)
    }
}

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    CometChatPushNotifications.shared.clearActiveConversation()
}

import CometChatSDK
import CometChatUIKitSwift
import CometChatPushNotificationsSwift
#if canImport(CometChatCallsSDK)
import CometChatCallsSDK
#endif

extension AppDelegate: CometChatPushNotificationsDelegate {

    // MARK: - Chat notification taps
    func navigateToChat(for user: CometChatSDK.User) {
        pushMessages(user: user, group: nil)
    }

    func navigateToChat(for group: CometChatSDK.Group) {
        pushMessages(user: nil, group: group)
    }

    func navigateToDefaultScreen() {
        DispatchQueue.main.async {
            self.topMostNavigationController()?.popToRootViewController(animated: true)
        }
    }

    // MARK: - Calls (CallKit already accepted — just present your ongoing-call screen)
    #if canImport(CometChatCallsSDK)
    func presentCallScreen(for call: CometChatSDK.Call, sessionId: String) {
        DispatchQueue.main.async {
            let ongoing = CometChatOngoingCall()
            let isAudioOnly = (call.callType == .audio)
            let builder = CometChatCallsSDK.CallSettingsBuilder()
                .setIsAudioOnly(isAudioOnly)
            ongoing.set(callSettingsBuilder: builder)
            ongoing.set(callWorkFlow: .defaultCalling)
            ongoing.set(sessionId: sessionId)
            ongoing.modalPresentationStyle = .fullScreen
            ongoing.setOnCallEnded { _ in
                // ALWAYS report call end back to CallKit so the system UI dismisses.
                CometChatPushNotifications.shared.endCallKitSession()
                ongoing.dismiss(animated: true)
            }
            self.topMostViewController()?.present(ongoing, animated: true)
        }
    }

    func onCallCleanupComplete() {
        // Called when the SDK fully ended the call (e.g. the user hit End on the
        // native CallKit screen). Dismiss the ongoing-call screen if still on top.
        DispatchQueue.main.async {
            self.dismissIfPresenting(CometChatOngoingCall.self)
        }
    }

    func onCallMissed(call: CometChatSDK.Call, reason: CometChatMissedCallReason) {
        // The SDK already posted the missed-call notification — hook for call logs / analytics.
    }

    func onCallMuteStateChanged(isMuted: Bool) {
        // Fires when the CallKit screen (or the Calls SDK) toggles mute.
    }
    #endif

    func onPushTokenRegistrationFailed(platform: CometChatPushTokenPlatform,
                                       error: CometChatSDK.CometChatException) {
        // Fires for automatic registrations too (VoIP capture, login re-registration).
        print("Push token registration failed [\(platform.rawValue)]: \(error.errorDescription)")
    }
}