Hypothetical WithSceneStore for communications across SwiftUI Scenes.

[DandyLyons]

The Problem

As far as I know there is not a TCA native way to facilitate communication across SwiftUI Scenes. Currently most TCA examples I've seen look something like this:

struct AppFeature: ReducerProtocol {
  struct State: Equatable {
    
  }
  enum Action: Equatable {
    
  }
  var body: some ReducerProtocolOf<Self> {
    Reduce<State, Action> { state, action in
      switch action {
          
      }
    }
  }
}

struct AppView: View {
  let store: StoreOf<AppFeature>
  
  var body: some View {
    WithViewStore(store) { viewStore in
      RootView(store: viewStore)
    }
  }
}

@main
struct ExampleApp: App {
  var body: some Scene {
    WindowGroup {
      AppView() // Not actually app level, only scene level. 
    }
  }
}

However, the naming of this is slightly incorrect. It's not correct to name this AppFeature because it does not have App-level domain. Only Scene-level. The WindowGroup Scene is not just one window but a group of windows. On iOS this is largely irrelevant because WindowGroup will only ever display one window, which is the whole app.

However macOS can display multiple windows. It also supports the Window, Settings, and DocumentGroup scenes. And this is not a macOS only problem. iPadOS also supports running multiple instances of the app side by side in their own. Currently we can pass State between Scenes (e.g. like this ).

To complicate matters more each instance of a WindowGroup Scene has it's own State:

Every window in the group maintains independent state. For example, the system allocates new storage for any State or StateObject variables instantiated by the scene’s view hierarchy for each window that it creates.

• https://developer.apple.com/documentation/swiftui/windowgroup

Also, in the above example, I don't believe AppFeature is able to observe and react to changes of ScenePhase, let alone handle these on a per-instance level of WindowGroup scenes.

As far as I know there isn't a way yet to make truly App-Wide Reducers i.e. one Reducer which can observe and react to all child Scenes (including each individual instance of a WindowGroup Scene).

The Proposal

Fortunately, I don't think we need to rework too much in TCA. I propose adding a new type called WithSceneStore. WithSceneStore would be designed to look and behave the same way that we already use WithViewStore, however instead of creating a SwiftUI View, it would create a SwiftUI Scene.

It could have a callsite that looks something like this:

struct AppFeature: ReducerProtocol {
  struct State {
    var mainScene: IdentifiedArrayOf<MainSceneFeature.State> // Since multiple instances of the scene could be running concurrently in the `WindowGroup` scene we need to store a State for each instance
    // NOTE: If using a macOS `Window` Scene, then IdentifiedArray is unnecessary
#if os(macOS)
    var settingsScene: SettingsFeature.State // or it might be better to model this as optional state with nil meaning the Settings window is closed: 👇
//    var settingsScene: SettingsFeature.State?
    
    
    // MenuBarExtraScene etc.
#endif
  }
  enum Action {
    case mainScene(IdentifiedArrayOf<MainSceneFeature.Action>)
#if os(macOS)
    case settingsScene(SettingsFeature.Action)
    // menu bar extra scene etc.
#endif
  }
  
  var body: some ReducerProtocolOf<Self> {
    Scope(state: \.mainScene, action: /Action.mainScene) {
      MainSceneFeature()
    }
    #if os(macOS)
    Scope(state: \.settingsScene, action: /Action.settingsScene) {
      SettingsFeature()
    } // or it might be better to use `.ifLet` 👇
//    .ifLet(\.settingsScene, action: /Action.settingsScene)
    #endif
  }
}

@main
struct WithSceneStoreApp: App {
  let store: StoreOf<AppFeature>
  
  var body: some Scene {
    WithSceneStore(
      store.scope(state: \.mainScene,
                  action: /Action.mainScene),
      observe: \.mainScene) { sceneStore in
        WindowGroup(sceneStore.windowTitle, id: sceneStore.id) { // each instance could be programmatically opened/closed by e.g. calling `openWindow(id: sceneStore.id)`
          MainSceneView(store: sceneStore) // NOTE: There's no difference in type between `sceneStore` and `viewStore` so the same store could work in a scene or view. The name `sceneStore` is used here only to denote that it holds a Scene level domain. 
          // NOTE: If not on macOS, MainSceneView would include a SettingsView
        }
      }
    

    #if os(macOS)
    WithSceneStore(
      store.scope(state: \.settingsScene,
                  action: /Action.settingsScene),
      observe: \.mainScene) { sceneStore in
        Settings { // Settings is macOS only: https://developer.apple.com/documentation/swiftui/settings/
          SettingsView(store: sceneStore)
        }
      }
    
    #endif
    
  }
}

Note: WithSceneStore would be entirely optional. If you are using a single scene app (like all iOS apps essentially) then you could continue as before without using WithSceneStore.

Advantages

• Similar API to what we're already used to
• Since the State and Action of the WindowGroup is store in an IdentifiedArray we can now observe and send actions to each individual instance of WindowGroup
• In the future WithSceneStore could observe .onChange(of: ScenePhase) under the hood
• WithSceneStore could have support for Scene level mutations such as .commands: https://developer.apple.com/documentation/swiftui/scene/commands(content:)
• The Reducer can be largely ignorant to whether it's being used in a WithSceneStore or a WithViewStore. It simply observes whatever State it cares about. For example, on macOS a SettingsFeature Reducer could drive a SettingsView inside a Settings Scene (which is macOS only) but on iOS the same SettingsFeature could drive the same SettingsView inside of MainSceneView.

See also

• This slack thread on multi-window support in macOS: https://pointfreecommunity.slack.com/archives/C04KQQ7NXHV/p1684786539094679

[kamcma]

I would be happy to see something like this in TCA, though I'm sort of agnostic on what it actually looks like. Just wanted to share for context of the discussion that a less-specialized version of something like this was briefly possible (#336), though it was deprecated and removed (#1910).

[kamcma]

I wonder if the API could look a lot like the complement of pieces that make up stack navigation, but with scene state held in an unordered scene-id-to-scene-enum dictionary instead of an identified array. And in the root app reducer, you implement a nested Scene reducer that scopes to the different scenes. And the app state holds on to some sort of SceneState<Scene.State>, etc etc. 🤔

[DandyLyons]

Interesting. I honestly am not sure.

I just know that we have to model it so that there can only be one State per Setting or Window Scene but there can be multiple State per WindowGroup Scenes.

[DandyLyons]

One problem with my proposal. Upon further inspection, it looks like the id on WindowGroup is unique to the WindowGroup, not the individual Windows in the WindowGroup. (See openWindow(id:) ) So I don't know if there is a way to uniquely identify each Window.

(Though, I'm not sure if that's a big deal. Off the top of my head, I can't think of a use case where I would need that).

[kakhaberikiknadze]

I've just added this comment on the slack channel. Copying it here as well.

I think that issue still lies in scoping the store.

let's say we've got 2 windows:
Main window
Feature N window

we've got store and @ObservedObject viewStore declared in App and create windows through the view store.

Main window has some hierarchy:
FeatureA > FeatureB > FeatureC > Feature D

Now let's say from FeatureD we need to open a new window and we need to initialise FeatureN state from FeatureD, scope store to FeatureN store and since it's not nil open the window. (I wonder how would we do that cuz through openWindow we could only send Codable & Hashable parameter. Reducer's states are not Codable. Maybe we could have a @dependency(.openWindow) just like we've got @dependency(.dismiss) where we could actually send the state instead of Codable & Hashable value to the scene reducer but that's too high level thoughts of mine. So far I couldn't think of the details that would make it achievable.

So it seems like child state notifying the very root state about the action but without us needing to write something like this:

struct AppReducer: ReducerProtocol {
 struct State: Equatable {
   var featureA: FeatureA.State
   @BindingState var featureD: FeatureD.State?
 }
 // ...
 var body: some ReducerProtocolOf<Self> {
   // ...
   case let featureA(.featureB(.featureC(.featureD(.openFeatureN(state))))):
     state.featureN = state
     return .none
 }
}

Writing this comment I've just discovered we can't really conditionally define window groups. Let's say we've got an optional state we can't declare window group depending on it being nil or not and if we define window group with id and use IfLetStore in its body then if the state is nil we'll just have an empty window presented.

[DandyLyons]

I really like the @Dependency(\.openWindow) idea.

[DandyLyons]

I don’t think I said this explicitly in the proposal but this proposal is inspired by the TCA Navigation series. The idea is that:

• Window is analogous to .sheet presentations: optional State
• WindowGroup is analogous to NavigationStack: IdentifiedArray of State

Does that model line up correctly? Please let me know if there are inconsistencies.

Currently we need to confirm that:

• dismiss can be called to close windows
• there is a callback for SwiftUI to notify TCA that a window has been closed
• we create a mechanism for TCA to update the state of a particular window in a WindowGroup

[rzolin]

Allow me to join the discussion, if not too late. Currently I am trying to marry TCA with Scenes and SceneDelegates. Let me start with the use case. This is multi-persona application, meaning that the user can have several logins (or profiles) visible in the same app. Somewhat like Slack has or Netflix. But the idea here is to have multiple windows/scenes open at the same time (on iPad), where each scene could belong to different profile, for example, one window I have work account, on the other personal. I am using SceneDelegate to distinguish scenes and initial views:

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)
        }

I use NSUserActivity to specify the scene and view path (like a deep link) with the use of URL as the targetContentIdentifier. The ATScene is the enum of available scenes, which can be setup and opened with the NSUserActivity

    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
        
        if let userActivity = connectionOptions.userActivities.first {
            session.accountId = userActivity.accountId
            session.theme = ATTheme(rawValue: Int(userActivity.theme) ?? 0) ?? .default
        }
        
        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
        )
    }

The UISceneSession then holds vars like sceneId: UUID, accountId: String and theme: ATTheme. And they are passed down the view hierarchy using Environment wrappers.

So far the only way to make it work with the TCA is passing it down in the View, something like that:

            .onChange(of: viewStore.accountId) { oldValue, newValue in
                accountId = newValue!
                sceneSession?.accountId = newValue
                sceneSession?.theme = config.theme(for: newValue)
            }
            .onChange(of: viewStore.theme!) { oldValue, newValue in
                sceneSession?.theme = newValue
            }

            ...

            let _ = ATNotification.Config.AccountSwitch.observe { notification in
                guard let account = notification.value as? String,
                      let targetedSessionId = notification.flags as? UUID else {
                    return
                }
                if targetedSessionId == viewStore.sessionId {
                    viewStore.send(.switchAccount(account))
                }
            }

This works, to some extent. The first thing that I don't like is that it all in the View. Cannot use it (environment) in the Reducer.
And now I came to another pain point: serialization of the scene. The problem with the UISceneSession, the vars that it holds are run time only, so either I have to manually serialize them or use something like @SceneStorage. Which I briefly tried and it again becomes View-only thing. So, I wondering what would be good approach here: use UserDefaults or something better? Also any questions, comments or feedback on my approach I use with the TCA above is welcome. I'd love to run it by you guys, since I am still getting my hands around TCA

[rzolin]

Thanks @DandyLyons. I did it in reverse. So each scene will have its own AppFeature and the store. And the scene params (like accountId and theme) are passed down as environment objects in the AppView. Here is the code in the scene delegate:

    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)
        }
    }

and from the ATScene:

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
    }

This way it is tied to the NSUserActivity and scene delegate controls the scenes (not the AppFeature) based on the NSUserActivity. So I should probably rename ATAppFeature to ATSceneFeature :). But this works. The only part that irks me is that I have to pass the accountId (related to the scene) through the view. And @SceneStorage doesn't work at all - it doesn't save the data, even though I use it only in the views. And it still gives me those purple warnings that it is not used in the view. Anyway, I managed to have my own serialization mechanism in the scene (ATAppContext).
Just remembered that I may need to do some cleanup of serialized scenes, there were some older scenes that have been deleted or discarded still stored in UserDefaults.

And one more thing, my App view now has no body, all is done via the scene delegate:

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

[DandyLyons]

You should have a look at View.bind(_:to:) from TCA. It allows you to make copies of data in TCA that auto sync with data outside of TCA.

Ideally any data that is mutated in TCA should live in TCA. This is why you're getting those runtime warnings. @Environment never wants to be used outside of a SwiftUI View since it relies on the SwiftUI runtime.

https://pointfreecommunity.slack.com/archives/C04KQQ7NXHV/p1692977942557899?thread_ts=1692977745.936039&channel=C04KQQ7NXHV&message_ts=1692977942.557899

[rzolin]

How can I get onto the slack channel? I think I need an invite.

[DandyLyons]

https://join.slack.com/t/pointfreecommunity/shared_invite/zt-265zmqi8g-bG_LOoZJifZjwf6Su4BMeA

[mbrandonw]

And here's a shortened URL that is easy to remember and easy to share:

https://www.pointfree.co/slack-invite