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.

[gilmatok]

I'm still getting this error thrown off at runtime from the isPresented property:

\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 sure why. I did annotate CallbackHandler with MainActor, and it's the only place that accesses it.

I added a precondition to check if its being accessed not from my main:

@Published private var _isMenuOpen = false
        var isMenuOpen: Bool {
            get { precondition(Thread.isMainThread, "READ off main"); return _isMenuOpen }
            set { precondition(Thread.isMainThread, "WRITE off main"); _isMenuOpen = newValue }
        }

... and the precondition was triggered. I wonder why.

EDIT: I think the issue is that some other threads are doing activity and modifying the view, and when the view re-renders, it calls the handler.isMenuOpen because it draws the view again...

Changing my app to work like you initially suggested seem to cause a lot of modifications. Is there another way around it? Maybe with my initial solution with the click?

[gilmatok]

@orchetect any idea?

[orchetect]

This looks like a SwiftUI app architecture / concurrency issue that needs solving in your codebase, as I can't reproduce it.

If a barebones repro can be made in a new app project showing it's a library issue then I can look into it.