Understanding and Modernizing AppDelegate in UIKit Apps

// Example of application(_:didFinishLaunchingWithOptions:)
import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.

        print("App launched successfully!")

        // Example: Initializing a third-party analytics SDK (mock example)
        // AnalyticsManager.shared.configure(withAPIKey: "your_api_key")

        // Pre-iOS 13 single-scene setup (for apps not using SceneDelegate)
        // if #available(iOS 13.0, *) {
        //     // SceneDelegate handles window setup
        // } else {
        //     window = UIWindow(frame: UIScreen.main.bounds)
        //     window?.rootViewController = ViewController()
        //     window?.makeKeyAndVisible()
        // }

        return true
    }
}

// Example of handling Universal Links
// Universal Links require specific entitlements and an 'apple-app-site-association' file.

extension AppDelegate {

    func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {

        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb, // Check if it's a web browsing activity (Universal Link)
              let webpageURL = userActivity.webpageURL else {
            return false
        }

        print("Received Universal Link: \(webpageURL.absoluteString)")

        // Example: Route to a specific view based on the URL path
        if webpageURL.path == "/profile/settings" {
            // Navigate to settings screen
            // (You'd typically use a Coordinator or navigate via your root view controller)
            // let settingsVC = SettingsViewController()
            // (window?.rootViewController as? UINavigationController)?.pushViewController(settingsVC, animated: true)
        }

        return true // Indicate that you handled the activity
    }

    // For custom URL schemes (e.g., 'myapp://product?id=123')
    func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
        print("Received custom URL scheme: \(url.absoluteString)")
        // Handle the custom URL here
        return true
    }
}

// Example of push notification registration (part of AppDelegate)
// This sets up the app to receive push notifications.

extension AppDelegate {

    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        // Convert token to a string and send to your backend
        let tokenParts = deviceToken.map { String(format: "%02.2hhx", $0) }
        let token = tokenParts.joined()
        print("Device Token: \(token)")

        // Example: Send token to your server
        // APIClient.shared.sendDeviceTokenToServer(token: token)
    }

    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
        print("Failed to register for remote notifications: \(error.localizedDescription)")
    }

    // For iOS 9.x and earlier, handle incoming notifications here (if not using UNUserNotificationCenter)
    func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        print("Received remote notification (legacy): \(userInfo)")
        // Process notification payload
        completionHandler(.noData) // Or .newData, .failed
    }
}

// Example SceneDelegate.swift (for iOS 13+ apps)
import UIKit

class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
        // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).

        guard let windowScene = (scene as? UIWindowScene) else { return }
        window = UIWindow(windowScene: windowScene)
        window?.rootViewController = ViewController() // Assign your root view controller
        window?.makeKeyAndVisible()

        // Handle Universal Links or custom URLs received at launch
        if let userActivity = connectionOptions.userActivities.first {
            scene(scene, continue: userActivity)
        }

        if let urlContext = connectionOptions.urlContexts.first {
            scene(scene, openURLContexts: connectionOptions.urlContexts)
        }
    }

    func sceneDidBecomeActive(_ scene: UIScene) {
        // Called when the scene has moved from an inactive state to an active state.
        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
        print("Scene became active")
    }

    func sceneWillResignActive(_ scene: UIScene) {
        // Called when the scene will move from an active state to an inactive state.
        // This may occur due to temporary interruptions (ex. an incoming phone call).
        print("Scene will resign active")
    }

    func sceneDidEnterBackground(_ scene: UIScene) {
        // Called as the scene transitions from the foreground to the background.
        // Use this method to save data, release shared resources, and store enough scene-specific state information
        // to restore the scene back to its current state in case it is terminated later.
        print("Scene entered background")
    }

    func sceneWillEnterForeground(_ scene: UIScene) {
        // Called as the scene transitions from the background to the foreground.
        // Use this method to undo the changes made on entering the background.
        print("Scene will enter foreground")
    }

    func sceneDidDisconnect(_ scene: UIScene) {
        // Called as the scene is being released by the system.
        // This occurs shortly after the scene enters the background, or when its session is discarded.
        // Release any resources associated with this scene that can be re-created the next time the scene connects.
        // The scene may re-connect later, as its session was not necessarily discarded.
        // If the `window` was retained, it might be an idea to release it here as well.
        print("Scene disconnected")
    }

    // Handle Universal Links or URL Schemes after launch
    func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
        print("Scene received Universal Link: \(userActivity.webpageURL?.absoluteString ?? "N/A")")
        // Process userActivity for this specific scene
    }

    func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
        if let url = URLContexts.first?.url {
            print("Scene received custom URL: \(url.absoluteString)")
            // Process URL for this specific scene
        }
    }
}

// A dedicated AppConfigurator.swift
import Foundation
import FirebaseCore // Example
// import Crashlytics // Example
// import AnalyticsSDK // Example

struct AppConfigurator {

    static func configureServices(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
        print("Initializing app services...")

        // Configure Firebase
        FirebaseApp.configure()

        // Configure Crashlytics
        // Crashlytics.sharedInstance().setDebugMode(true)

        // Configure Analytics
        // AnalyticsSDK.shared.initialize(apiKey: "YOUR_ANALYTICS_KEY", launchOptions: launchOptions)

        // ... other service initializations
    }
}

// Then, in AppDelegate.swift
extension AppDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        AppConfigurator.configureServices(launchOptions: launchOptions)
        return true
    }
}

// In AppDelegate.swift (or a dedicated class)
extension AppDelegate: UNUserNotificationCenterDelegate {

    func registerForPushNotifications() {
        UNUserNotificationCenter.current().delegate = self
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            print("Permission granted: \(granted)")
            guard granted else { return }
            DispatchQueue.main.async {
                UIApplication.shared.registerForRemoteNotifications()
            }
        }
    }

    // MARK: UNUserNotificationCenterDelegate methods

    // Called when a notification is delivered to a foreground app.
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        print("Notification will present (Foreground): \(notification.request.content.userInfo)")
        completionHandler([.banner, .sound, .badge]) // Show alert, play sound, update badge
    }

    // Called to let your app know which action a user selected for a given notification.
    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        print("Notification received response: \(response.notification.request.content.userInfo)")

        // Handle user action (e.g., open a specific view, perform a task)
        let userInfo = response.notification.request.content.userInfo
        // if let customData = userInfo["customKey"] as? String { ... }

        completionHandler()
    }
}

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello, SwiftUI from UIKit!")
            .padding()
    }
}

// In SceneDelegate.swift
import UIKit
import SwiftUI

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = (scene as? UIWindowScene) else { return }

        let contentView = ContentView() // Your SwiftUI root view

        // Create the UIWindow and set its root view controller to a UIHostingController
        let window = UIWindow(windowScene: windowScene)
        window.rootViewController = UIHostingController(rootView: contentView)
        self.window = window
        window.makeKeyAndVisible()
    }
    // ... other SceneDelegate methods
}