Mastering the SwiftUI App Lifecycle: iOS 14+ Development

import SwiftUI

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

import SwiftUI

struct DataManager {
    static func saveData() {
        print("App entering background, saving data...")
        // Simulate data saving
    }

    static func fetchData() {
        print("App becoming active, fetching new data...")
        // Simulate data fetching
    }
}

@main
struct ScenePhaseApp: App {
    @Environment("scenePhase") var scenePhase

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { newPhase in
            switch newPhase {
            case .active:
                print("App is active")
                DataManager.fetchData()
            case .inactive:
                print("App is inactive")
            case .background:
                print("App is in background")
                DataManager.saveData()
            @unknown default:
                print("Unknown scene phase")
            }
        }
    }
}

struct ContentView: View {
    var body: some View {
        Text("Observe app lifecycle in console")
            .font(.title)
    }
}

import SwiftUI

struct DetailView: View {
    let item: String

    var body: some View {
        Text("Detail for \(item)")
            .onAppear {
                print("DetailView for \(item) appeared")
            }
            .onDisappear {
                print("DetailView for \(item) disappeared")
            }
            .navigationTitle(item)
    }
}

struct ContentView: View {
    var body: some View {
        NavigationView {
            List {
                ForEach(0..<5) { index in
                    NavigationLink(destination: DetailView(item: "Item \(index)")) {
                        Text("Go to Item \(index)")
                    }
                }
            }
            .navigationTitle("My List")
        }
    }
}

import SwiftUI
import BackgroundTasks

let backgroundAppRefreshTaskIdentifier = "com.yourapp.apprefresh"

struct BackgroundTasksManager {
    static func registerBackgroundTasks() {
        BGTaskScheduler.shared.register(forTaskWithIdentifier: backgroundAppRefreshTaskIdentifier, using: nil) {
            task in
            // This block is executed when the background task is launched.
            // You must schedule the next refresh and mark the task as complete.
            print("Background app refresh task launched!")
            handleAppRefresh(task: task as! BGAppRefreshTask)
        }
        print("Background tasks registered.")
    }

    static func scheduleAppRefresh() {
        let request = BGAppRefreshTaskRequest(identifier: backgroundAppRefreshTaskIdentifier)
        request.earliestBeginDate = Date(timeIntervalSinceNow: 60 * 15) // Request a refresh after 15 minutes

        do {
            try BGTaskScheduler.shared.submit(request)
            print("Background app refresh scheduled for at least 15 minutes from now.")
        } catch {
            print("Could not schedule app refresh: \(error)")
        }
    }

    static func handleAppRefresh(task: BGAppRefreshTask) {
        // Schedule the next background app refresh
        scheduleAppRefresh()

        // Perform your long-running operation here.
        // Ensure your task is finished within the allotted time (typically 30 seconds).
        let backgroundQueue = DispatchQueue.global(qos: .default)
        backgroundQueue.async {
            print("Performing background data fetch...")
            // Simulate network request or data processing
            Thread.sleep(forTimeInterval: 5)
            print("Background data fetch complete.")

            // You must call setTaskCompleted(success: true/false) when done
            task.setTaskCompleted(success: true)
        }

        // If your task supports it, provide an expiration handler.
        // The system will call this if the task runs too long.
        task.expirationHandler = {
            print("Background task expired! Stopping operations.")
            // Clean up any ongoing tasks
            task.setTaskCompleted(success: false)
        }
    }
}

@main
struct BackgroundApp: App {
    @Environment("scenePhase") var scenePhase

    init() {
        // Register background tasks early in the app's lifecycle.
        BackgroundTasksManager.registerBackgroundTasks()
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .onChange(of: scenePhase) { newPhase in
            if newPhase == .background {
                // Schedule a background refresh when the app goes to the background.
                BackgroundTasksManager.scheduleAppRefresh()
            }
        }
    }
}

struct ContentView: View {
    var body: some View {
        Text("App with background refresh enabled. \nSend app to background to trigger scheduling.")
            .font(.title2)
            .multilineTextAlignment(.center)
            .padding()
    }
}

import SwiftUI

// 1. App-wide settings (EnvironmentObject) - Persists for the app's lifetime
class AppWideSettings: ObservableObject {
    @Published var userName: String = "Guest"
    @Published var lastActiveDate: Date = Date()

    init() {
        print("AppWideSettings initialized")
    }

    func updateLastActiveDate() {
        lastActiveDate = Date()
        print("Last active date updated in AppWideSettings")
    }
}

// 2. View-specific data (StateObject) - Persists for the view's lifetime
class ViewModel: ObservableObject {
    @Published var counter: Int = 0

    init() {
        print("ViewModel initialized")
    }

    func increment() {
        counter += 1
    }

    deinit {
        print("ViewModel deinitialized")
    }
}

struct SettingsView: View {
    @EnvironmentObject var settings: AppWideSettings

    var body: some View {
        Form {
            TextField("Username", text: $settings.userName)
            Text("Last App Active: \(settings.lastActiveDate, formatter: DateFormatter.shortDateTime)")
        }
        .navigationTitle("Settings")
    }
}

struct MyContentView: View {
    @StateObject private var viewModel = ViewModel()
    @EnvironmentObject var appSettings: AppWideSettings // Access app-wide settings

    var body: some View {
        VStack(spacing: 20) {
            Text("Counter: \(viewModel.counter)")
                .font(.largeTitle)
            Button("Increment") {
                viewModel.increment()
            }
            Divider()
            Text("Hello, \(appSettings.userName)!")
            Text("App-level Last Active: \(appSettings.lastActiveDate, formatter: DateFormatter.shortDateTime)")
            
            NavigationLink("Go to Settings") {
                SettingsView()
            }
        }
        .onAppear {
            print("MyContentView appeared")
        }
        .onDisappear {
            print("MyContentView disappeared") // ViewModel is deinitialized if MyContentView is removed from hierarchy
        }
    }
}

@main
struct StateManagementApp: App {
    @StateObject private var appSettings = AppWideSettings()
    @Environment("scenePhase") var scenePhase

    var body: some Scene {
        WindowGroup {
            NavigationView {
                MyContentView()
            }
            .environmentObject(appSettings) // Inject appSettings into the environment
        }
        .onChange(of: scenePhase) { newPhase in
            if newPhase == .active {
                appSettings.updateLastActiveDate()
            }
        }
    }
}

extension DateFormatter {
    static let shortDateTime: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateStyle = .short
        formatter.timeStyle = .short
        return formatter
    }()
}

import SwiftUI

// 1. App-wide settings (EnvironmentObject) - Persists for the app's lifetime
class AppWideSettings: ObservableObject {
    @Published var userName: String = "Guest"
    @Published var lastActiveDate: Date = Date()

    init() {
        print("AppWideSettings initialized")
    }

    func updateLastActiveDate() {
        lastActiveDate = Date()
        print("Last active date updated in AppWideSettings")
    }
}

// 2. View-specific data (StateObject) - Persists for the view's lifetime
class ViewModel: ObservableObject {
    @Published var counter: Int = 0

    init() {
        print("ViewModel initialized")
    }

    func increment() {
        counter += 1
    }

    deinit {
        print("ViewModel deinitialized")
    }
}

struct SettingsView: View {
    @EnvironmentObject var settings: AppWideSettings

    var body: some View {
        Form {
            TextField("Username", text: $settings.userName)
            Text("Last App Active: \(settings.lastActiveDate, formatter: DateFormatter.shortDateTime)")
        }
        .navigationTitle("Settings")
    }
}

struct MyContentView: View {
    @StateObject private var viewModel = ViewModel()
    @EnvironmentObject var appSettings: AppWideSettings // Access app-wide settings

    var body: some View {
        VStack(spacing: 20) {
            Text("Counter: \(viewModel.counter)")
                .font(.largeTitle)
            Button("Increment") {
                viewModel.increment()
            }
            Divider()
            Text("Hello, \(appSettings.userName)!")
            Text("App-level Last Active: \(appSettings.lastActiveDate, formatter: DateFormatter.shortDateTime)")
            
            NavigationLink("Go to Settings") {
                SettingsView()
            }
        }
        .onAppear {
            print("MyContentView appeared")
        }
        .onDisappear {
            print("MyContentView disappeared") // ViewModel is deinitialized if MyContentView is removed from hierarchy
        }
    }
}

@main
struct StateManagementApp: App {
    @StateObject private var appSettings = AppWideSettings()
    @Environment("scenePhase") var scenePhase

    var body: some Scene {
        WindowGroup {
            NavigationView {
                MyContentView()
            }
            .environmentObject(appSettings) // Inject appSettings into the environment
        }
        .onChange(of: scenePhase) { newPhase in
            if newPhase == .active {
                appSettings.updateLastActiveDate()
            }
        }
    }
}

extension DateFormatter {
    static let shortDateTime: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateStyle = .short
        formatter.timeStyle = .short
        return formatter
    }()
}

import SwiftUI
import UIKit
import UserNotifications // For push notifications

// Define your custom AppDelegate
class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil
    ) -> Bool {
        print("AppDelegate didFinishLaunchingWithOptions")
        // Example:
        // Configure a third-party SDK that requires early initialization
        // ThirdPartySDK.shared.initialize(apiKey: "YOUR_API_KEY")
        
        // Register for push notifications (if not done in SwiftUI)
        UNUserNotificationCenter.current().delegate = self
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            print("Notification permission granted: \(granted)")
            guard granted else { return }
            DispatchQueue.main.async {
                UIApplication.shared.registerForRemoteNotifications()
                print("Registered for remote notifications")
            }
        }
        
        return true
    }

    func application(
        _ application: UIApplication,
        configurationForConnecting connectingSceneSession: UISceneSession,
        options: UIScene.ConnectionOptions
    ) -> UISceneConfiguration {
        print("AppDelegate configurationForConnecting")
        // This method is called when a new scene session is being created.
        // If you're using SwiftUI's App lifecycle, this might not be strictly necessary to implement
        // unless you need custom UIKit-backed scene configurations.
        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
    }

    // MARK: - Push Notification Delegate Methods
    func application(
        _ application: UIApplication,
        didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
    ) {
        let tokenParts = deviceToken.map { String(format: "%02.2hhx", $0) }
        let token = tokenParts.joined()
        print("Device Token: \(token)")
        // Send this token to your backend server
    }

    func application(
        _ application: UIApplication,
        didFailToRegisterForRemoteNotificationsWithError error: Error
    ) {
        print("Failed to register for remote notifications: \(error.localizedDescription)")
    }
    
    // Handle notifications when the app is in the foreground
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification,
        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
    ) {
        print("Notifications will present in foreground: \(notification.request.content.userInfo)")
        // If you want to display an alert, sound, or badge while the app is in the foreground
        completionHandler([.banner, .sound])
    }

    // Handle user tap on notification
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse,
        withCompletionHandler completionHandler: @escaping () -> Void
    ) {
        print("User Tapped on Notification: \(response.notification.request.content.userInfo)")
        // Perform actions based on the notification payload
        completionHandler()
    }
}

@main
struct CustomAppDelegateApp: App {
    // Use @UIApplicationDelegateAdaptor to integrate your AppDelegate
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

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

struct ContentView: View {
    var body: some View {
        Text("Check console for AppDelegate and Push Notification logs.")
            .font(.title2)
            .multilineTextAlignment(.center)
            .padding()
            .onAppear {
                // Example of requesting notification authorization directly in SwiftUI view
                // For complex handling or background notifications, AppDelegate might still be preferred.
                // UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
                //     print("SwiftUI: Notification permission granted: \(granted)")
                // }
            }
    }
}