SwiftUI中WindowGroup替代'window.rootViewController'的方案及无SceneDelegate时的根视图切换实现

嘿，我懂你现在的处境——从依赖SceneDelegate的UIKit思路转到纯SwiftUI的App结构后，没法再直接操作window来切换根视图了。不过SwiftUI的状态驱动模式其实更贴合它的设计，下面给你两种实用的实现方案，你可以根据自己的应用复杂度选：

这种方式适合简单场景，直接在MyApp里维护一个状态变量，通过状态变化自动切换根视图：

import SwiftUI

struct MyApp: App {
    // 用状态变量标记当前要显示的根视图类型
    @State private var currentRoot: RootViewKind = .splash
    
    var body: some Scene {
        WindowGroup {
            // 根据状态切换对应视图
            switch currentRoot {
            case .splash:
                SplashScreenView()
                    // 通过环境传递切换根视图的闭包
                    .environment(\.rootSwitcher, { newKind in
                        currentRoot = newKind
                    })
            case .main:
                MainContentView()
            case .login:
                LoginView()
            }
        }
    }
}

// 枚举定义所有根视图类型，方便管理
enum RootViewKind {
    case splash, main, login
}

// 自定义环境键，用来传递切换逻辑
struct RootSwitcherKey: EnvironmentKey {
    static var defaultValue: (RootViewKind) -> Void = { _ in }
}

extension EnvironmentValues {
    var rootSwitcher: (RootViewKind) -> Void {
        get { self[RootSwitcherKey.self] }
        set { self[RootSwitcherKey.self] = newValue }
    }
}

在子视图里调用切换逻辑也很简单，比如在SplashScreenView中：

struct SplashScreenView: View {
    @Environment(\.rootSwitcher) private var switchRoot
    
    var body: some View {
        Button("跳转到主界面") {
            switchRoot(.main)
        }
    }
}

如果你的应用需要在多个地方触发根视图切换，或者状态逻辑更复杂，用ObservableObject会更清晰，也方便后续扩展：

import SwiftUI

// 全局状态管理器，负责根视图的状态控制
class AppState: ObservableObject {
    @Published var currentRoot: RootViewKind = .splash
    
    // 封装切换根视图的方法
    func switchToRoot(_ kind: RootViewKind) {
        currentRoot = kind
    }
}

struct MyApp: App {
    // 用@StateObject确保状态管理器的生命周期和App一致
    @StateObject private var appState = AppState()
    
    var body: some Scene {
        WindowGroup {
            switch appState.currentRoot {
            case .splash:
                SplashScreenView()
                    .environmentObject(appState)
            case .main:
                MainContentView()
                    .environmentObject(appState)
            case .login:
                LoginView()
                    .environmentObject(appState)
            }
        }
    }
}

// 同样的根视图枚举
enum RootViewKind {
    case splash, main, login
}

在子视图中使用时，直接通过环境对象调用方法：

struct SplashScreenView: View {
    @EnvironmentObject private var appState: AppState
    
    var body: some View {
        Button("跳转到主界面") {
            appState.switchToRoot(.main)
        }
    }
}

如果你习惯了之前用通知触发的逻辑，也可以在状态管理器里监听通知：

class AppState: ObservableObject {
    @Published var currentRoot: RootViewKind = .splash
    private var notificationObserver: NSObjectProtocol?
    
    init() {
        // 监听你原来的通知
        notificationObserver = NotificationCenter.default.addObserver(
            forName: Notification.Name("changeWindowNotificationName"),
            object: nil,
            queue: .main
        ) { [weak self] _ in
            // 收到通知后切换根视图
            self?.currentRoot = .splash
        }
    }
    
    deinit {
        // 记得移除监听，避免内存泄漏
        if let observer = notificationObserver {
            NotificationCenter.default.removeObserver(observer)
        }
    }
    
    // ... 其他方法
}

总的来说，SwiftUI是状态驱动视图，所以核心思路是通过修改状态来让视图自动更新，而不是像UIKit那样直接操作底层的window。上面的几种方案都能实现你的需求，选最适合你当前项目的就行~

内容的提问来源于stack exchange，提问作者el3ankaboot