Using `isPresented` with `Binding` doesn't work

[gilmatok]

Bug Description, Steps to Reproduce, Crash Logs, Screenshots, etc.

This is my app code:

struct MyApp: App {
  @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

  var body: some Scene {
      MenuBarExtra {
          MainView().environmentObject(appDelegate.handler)
      } label: {
          Image("tray-no-permissions-dark")
      }
      .menuBarExtraAccess(
        isPresented: Binding(
            get: { appDelegate.handler.isMenuOpen },
            set: { appDelegate.handler.isMenuOpen = $0 }
            )
      ) { statusItem in
          appDelegate.statusItem = statusItem
      }
      .menuBarExtraStyle(.window)
  }

This is my handler:

class callbackHandler: ObservableObject {

    @Published var isMenuOpen: Bool = false

}

Then in my AppDelegate I want to open the menu programmatically after 15 seconds like so:

    func applicationDidFinishLaunching(_ notification: Notification) {
        DispatchQueue.main.asyncAfter(deadline: .now() + 15) {
            self.handler.isMenuOpen = true
        }
    }

However, nothing happens. I can use the statusItem to performClick but I thought the binding would work. What am I missing?

Also, there are parts in my app that would need to open the menu programmatically, but that would make this boolean stay true even if the user doesn't dismiss the view. Wouldn't that be an issue? Is there a way to "trigger" the opening once?

[orchetect]

The state variable has to exist within a SwiftUI hierarchy.

Right now your observable handler object is stored in the AppDelegate and you're using a custom binding to redirect to a variable stored in it. This will not cause the SwiftUI stack to update from its changes. You need to implement what you have in the opposite direction. The observable object (state) needs to live inside the SwiftUI hierarchy (in the MyApp struct in this case).

There's a few ways to address this, but what I'd recommend is installing the CallbackHandler class instance in the MyApp struct as a @StateObject var, then in MyApp's init, inject a copy of it into the AppDelegate. MyApp is initialized before the AppDelegate, so the injected handler will be available (non-nil) before applicationDidFinishLaunching(_:) is called.

I've copied your code and done a few modifications to achieve the expected behavior.

MBEATest.zip

[gilmatok]

Thanks for the comment, @orchetect.

I tried your example and it worked, however once I tried to replicate in my own project the following error is thrown:

.menuBarExtraAccess(isPresented: $handler.isMenuOpen) { statusItem in
          appDelegate.statusItem = statusItem
      }

\callbackHandler.isMenuOpen is isolated to the main actor. Accessing it via Binding from a different actor will cause undefined behaviors, and potential data races; This warning will become a runtime crash in a future version of SwiftUI.

I'm not really sure why it happens or what could differ.

[orchetect]

Likely be because the project template I used has MainActor isolation enabled by default in the build settings.

If not already, make sure your class is bound to @MainActor. It's generally a good idea to do that for observable classes.

@MainActor class CallbackHandler: ObservableObject { /* ... */ }

[orchetect]

I re-built the test app without MainActor isolation enabled and it still works fine.

Keep in mind you should only ever mutate the handler's properties from the main thread.