Multiple scenes with TCA

[rzolin]

Let's start with the use case that I want to implement. The app supports multiple profiles/personas, which you probably seen in Slack or even Netflix. The user can open multiple windows with different profiles (accounts) or easily switch between them in the same window. This part I have managed to implement, and will share with you below.
But I got stuck on restoration of the scenes. Basically, the @SceneStorqge is not saving data, though it is used in a view. More about it after the basic blocks of the app. I will redact some code to make it simpler and easier to get the point across.

Info.plist

<dict>
	<key>UIApplicationSupportsMultipleScenes</key>
	<true/>
	<key>UISceneConfigurations</key>
	<dict>
		<key>UIWindowSceneSessionRoleApplication</key>
		<array>
			<dict>
				<key>UISceneDelegateClassName</key>
				<string>$(PRODUCT_MODULE_NAME).ATSceneDelegate</string>
				<key>UISceneConfigurationName</key>
				<string>Default Configuration</string>
			</dict>
		</array>
	</dict>
</dict>

AppDelegate:

    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
        let sceneConfig = UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
            sceneConfig.delegateClass = ATSceneDelegate.self
            return sceneConfig
    }

SceneDelegate:

    
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {

        let sessionId = UUID(uuidString: session.persistentIdentifier) ?? UUID()
        session.sessionId = sessionId
        let mainView = ATAppView(
            store: Store(initialState: ATAppFeature.State(sessionId: sessionId)) {
                ATAppFeature()
            })
        
        if let userActivity = connectionOptions.userActivities.first,
            let atScene = userActivity.scene {
            var view: any View
            switch atScene {
            case .main: view = mainView
            case .login: view = mainView
            }
            self.window = atScene.setup(scene: scene, session: session, options: connectionOptions, view: view)
        } else {
            self.window = ATScene.main.setup(scene: scene, session: session, options: connectionOptions, view: mainView)
        }
    }

Scene - scenes that app supports with ability to open a new scene

public enum ATScene: String, CaseIterable {
    
    case main = "MainScene"
    case login = "LoginScene"
    
    static var allKeys: [String] {
        Self.allCases.map { $0.rawValue }
    }
    
    public func setup(scene: UIScene, session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions, view: some View) -> UIWindow {
        guard let windowScene = scene as? UIWindowScene else {
            fatalError("Expected a UIWindowScene")
        }
        
//        let predicate = NSPredicate(format: "self == '\(kDeepLinkBase)/\(self.rawValue)/*'")
//        scene.activationConditions.canActivateForTargetContentIdentifierPredicate = predicate
//        scene.activationConditions.prefersToActivateForTargetContentIdentifierPredicate = predicate
        
        let appContext = try? ATAppContext.serizializedContext()
        
        if let userActivity = connectionOptions.userActivities.first ?? session.stateRestorationActivity {
            session.accountId = userActivity.accountId
            session.theme = ATTheme(rawValue: Int(userActivity.theme) ?? 0) ?? .default
            if let appContext {
                appContext[session.persistentIdentifier] = ATAppSession(session: session)
            }
        } else {
            if let appContext,
               let sessionContext = appContext[session.persistentIdentifier] {
                session.accountId = sessionContext.accountId
                session.theme = sessionContext.theme
            }
        }
        
        appContext?.serialize()
        
        let window = UIWindow(windowScene: windowScene)
        window.rootViewController = UIHostingController(
            rootView: view
                .environment(\.sceneSession, session)
                .environment(\.sessionId, session.sessionId)
                .environment(\.accountId, session.accountId)
                .environment(\.theme, session.theme)
        )
        window.makeKeyAndVisible()

        return window
    }

    public typealias ATUserActivityConfiguration = (NSUserActivity) -> Void
    
    public func open(account: ATUserAccount, configure: ATUserActivityConfiguration? = nil) {
        let userActivity = NSUserActivity.forScene(account: account, scene: self)
        configure?(userActivity)
        
        UIApplication.shared.requestSceneSessionActivation(
            nil,
            userActivity: userActivity,
            options: nil,
            errorHandler: nil
        )
    }
    
}

AppContext and AppScene - serializable state of the sessions (like account ID, theme, etc)

public class ATAppContext: Codable {
    
    typealias AppSessions = Dictionary<UUID, ATAppSession>
    var sessions = AppSessions()
    
    enum CodingKeys: String, CodingKey {
        case sessions = "sessions"
    }

    public static func serizializedContext() throws -> ATAppContext {
        guard let data = UserDefaults.standard.object(forKey: kAppContext) as? Data else {
            return ATAppContext()
        }
        
        let decoder = JSONDecoder()
        return try decoder.decode(Self.self, from: data)
    }
    
    public static func update(sessionId: UUID?, accountId: ATUserAccount? = nil) {
        if let accountId, let sessionId {
            let appContext = try? ATAppContext.serizializedContext()
            appContext?[sessionId.uuidString] = ATAppSession(sessionId: sessionId.uuidString, accountId: accountId)
            appContext?.serialize()
        }
    }
    
    public func serialize() {
        let encoder = JSONEncoder()
        if let encoded = try? encoder.encode(self) {
            let defaults = UserDefaults.standard
            defaults.set(encoded, forKey: Self.kAppContext)
        }
    }

    ...


public class ATAppSession: ObservableObject, Equatable, Decodable {
    
    enum CodingKeys: String, CodingKey {
        case sessionId = "sessionId"
        case accountId = "accountId"
        case theme = "theme"
    }

    public var sessionId: String
    
    @Published
    public var accountId: ATUserAccount?
    
    @Published
    public var theme: ATTheme

Main view:

@main
struct ATApp: App {
    @UIApplicationDelegateAdaptor(ATAppDelegate.self) var delegate
    @Environment(\.sceneSession) var sceneSession

    var body: some Scene {
        WindowGroup {
            ATAppView(
                store: Store(
                    initialState: ATAppFeature.State(sessionId: UUID())
                ) {
                    ATAppFeature()
                }
            )
        }
    }
}

Main Feature: Reducer and View

public struct ATAppFeature: Reducer {
    
    public enum MainFlow {
        case appInit
        case login
        case content        
    }
    
    public struct State: Equatable {
        public var sessionId: UUID
        public var initialization = ATAppInitializationFeature.State(title: "Loading...")
        public var flow: MainFlow = .appInit
        public var login = ATLoginFeature.State()
        public var accountId: ATUserAccount?
        
    }
    
    public enum Action: Equatable {
        case showInitialization(ATAppInitializationFeature.Action)
        case showLogin(ATLoginFeature.Action)
        case switchAccount(ATUserAccount)
        case showContent
    }
    
    
    @Dependency(\.dismiss) var dismiss
    @Dependency(\.config) var config
    
    public var body: some ReducerOf<Self> {
        
        Reduce<State, Action> { state, action in
            switch action {
                
            case let .showInitialization(.delegate(action)):
                switch action {
                case let .setupComplete(account):
                    Log.config.trace("UI: initialization is complete with account: \(account ?? "<nil>")")
                    if let account {
                        state.accountId = account
                        state.flow = .content
                    } else {
                        state.flow = .login
                    }
                    return .none
                case let .setupFailed(error):
                    state.flow = .login
                    return .run { send in await send( .handleError(error, .none)) }
                }
                
            case let .showLogin(.delegate(action)):
                switch action {
                case let .switchToContent(account):
                    state.accountId = account
                    state.flow = .content
                    return .none
                }
                
            case .showContent:
                state.flow = .content
                return .none
                
            case .switchAccount(let account):
                state.accountId = account
                return .none
        }

        Scope(state: \.initialization, action: /Action.showInitialization) {
            ATAppInitializationFeature()
        }
        Scope(state: \.login, action: /Action.showLogin) {
            ATLoginFeature()
        }
    }
}

struct ATAppView: View {
    
    @SceneStorage("accountId") var sceneAccountId: String?  // <<< THIS THING DOESN'T SAVE
    @Dependency(\.config) var config
    @Environment(\.sceneSession) var sceneSession
    private var store: StoreOf<ATAppFeature>
    
    struct ViewState: Equatable {
        let flow: ATAppFeature.MainFlow
        let sessionId: UUID?
        let accountId: ATUserAccount?
        init(state: ATAppFeature.State) {
            self.flow = state.flow
            self.sessionId = state.sessionId
            self.accountId = state.accountId
            ATAppContext.update(sessionId: sessionId, accountId: accountId)
        }
    }
    
    var body: some View {
        WithViewStore(self.store, observe: ViewState.init) { viewStore in
            Group {
                switch (viewStore.flow) {
                case .appInit:
                    ATAppInitialization(
                        store: self.store.scope(
                            state: { store in
                                var state = store.initialization
                                state.accountId = sceneSession?.accountId
                                return state
                            },
                            action: ATAppFeature.Action.showInitialization
                        )
                    )
                case .login:
                    NavigationStack {
                         ATLoginView(
                            store: store.scope(
                                state: \.login,
                                action: ATAppFeature.Action.showLogin
                            )
                        )                    
                    }
                    
                case .content:
                    ATContentView()
                }
            }
            .onChange(of: viewStore.accountId) { oldValue, newValue in
                sceneSession?.accountId = newValue
            }
            .task {
                // monitor changes to ViewStore, specifically for SceneStorage
                for await _ in viewStore.objectWillChange.values {
                    sceneAccountId = viewStore.accountId        // <<< THIS THING DOESN'T SAVE
                }
            }
            
            let _ = ATNotification.Config.AccountSwitch.observe { notification in
                guard let account = notification.value as? ATUserAccount,
                      let targetedSessionId = notification.flags as? UUID else {
                    return
                }
                if targetedSessionId == viewStore.sessionId {
                    viewStore.send(.switchAccount(account))
                }
            }
        }
    }
}

This is pretty much all the main parts. The AppContext holds a list of active sessions and is saved in UserDefaults. So on the next launch I can know which session was with which account Id. And this is mostly works. Though the restoration is broken, or rathe strange to me. Here the flow:

• opened the app,
• logged in,
• have two accounts,
• opened another session for the second account
• kill the app (state is saved when I opened the second scene)

And now when I open the app, there are three (!) sessions. The first two were restored and there is a new one - empty, without an account id. And this empty one is the primary (visible), the other two are kind of behind the scene, need to tap the tree dots on top of the iPad to switch to them.
Ok, I figured that I am not doing the restoration per se. But rather do it my self in parallel, so issues like that are expected. My next step would be to integrate into the restoration flow, which is better to be done with the @SceneStorage. And that's where I get into things that I don't understand. I followed the WWDC 23 video about @SceneStorage and added this code to the view (also is above):

struct ATAppView: View {
    
    @SceneStorage("accountId") var sceneAccountId: String? 

     ....

            .task {
                // monitor changes to ViewStore, specifically for SceneStorage
                for await _ in viewStore.objectWillChange.values {
                    sceneAccountId = viewStore.accountId       
                }
            }

The most frustrating thing is that the above code doesn't save the accountId. I can put the breakpoint at the line where the sceneAccountId is being updated and after this line is executed the value still nil.

And in the scene delegate (passed to the ATScene) I get the restoration activity, which somehow has persistentIdentifier that never was in any of the scenes before, and that's how it becomes an empty scene

        if let userActivity = connectionOptions.userActivities.first ?? session.stateRestorationActivity {

I always get empty accountId, it is there as a record in the dictionary, but empty. I've tried to close the app and see if the changes to the scene phase can help, nope, still nothing is saved. I tried to put that code in .onChange, still doesn't work. And I cannot figure out why. No errors, like "SceneStorage can only be used on view" or such. It's just silently does nothing.

Any ideas, or comments, would be appreciated. And if you have any questions about the code or missing pieces, let me know.