Fix "Open in browser" logic from menu bar and dock (#4799)

<!-- Thank you for submitting a Pull Request and helping to improve Home
Assistant. Please complete the following sections to help the processing
and review of your changes. Please do not delete anything from this
template. -->

## Summary
<!-- Provide a brief summary of the changes you have made and most
importantly what they aim to achieve -->

## Screenshots
<!-- If this is a user-facing change not in the frontend, please include
screenshots in light and dark mode. -->

## Link to pull request in Documentation repository
<!-- Pull requests that add, change or remove functionality must have a
corresponding pull request in the Companion App Documentation repository
(https://github.com/home-assistant/companion.home-assistant). Please add
the number of this pull request after the "#" -->
Documentation: home-assistant/companion.home-assistant#

## Any other notes
<!-- If there is any other information of note, like if this Pull
Request is part of a bigger change, please include it here. -->

Author: bgoncal

Sources/App/AppDelegate.swift

@@ -142,6 +142,9 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
 
         #if targetEnvironment(macCatalyst)
         statusItemManager.configure()
+        // Dock icon: when "Open Home Assistant UI in browser" is on there is no in-app web view, so a
+        // reopen with no windows (Dock icon click) should open the browser instead of creating a window.
+        Current.macBridge.setReopenHandler { StatusItemPrimaryAction.openInBrowserIfNeeded() }
         #endif
 
         checkForUpdate()

Sources/App/Utilities/MenuManager.swift

@@ -119,6 +119,27 @@ enum StatusItemTitleRenderer {
     }
 }
 
+/// Shared decision for what the macOS status item should do when "activated" (icon click or the
+/// "Toggle" menu item). When the user enabled "Open Home Assistant UI in browser"
+/// (`macNativeFeaturesOnly`) there is no in-app web view to toggle — it is destroyed at launch by
+/// `QuickActionWindowSceneDelegate` — so any "show me Home Assistant" affordance must open the default
+/// browser instead of spawning a web-view window. The preference is read live on every call because
+/// flipping it does not reconfigure the status item (it posts no `menuRelatedSettingDidChange`).
+enum StatusItemPrimaryAction {
+    /// Opens Home Assistant in the default browser when the browser preference is on.
+    /// - Returns: `true` if it handled the action (browser opened), `false` to fall through to the
+    ///   normal toggle/activate behaviour.
+    static func openInBrowserIfNeeded() -> Bool {
+        guard Current.settingsStore.macNativeFeaturesOnly else { return false }
+        // Prefer the server shown in the menu-bar title; its getter already falls back to the first
+        // server, so this also covers users without a configured menu-bar template.
+        let server = Current.settingsStore.menuItemTemplate?.server ?? Current.servers.all.first
+        guard let url = server?.info.connection.activeURL() else { return false }
+        URLOpener.shared.open(url, options: [:], completionHandler: nil)
+        return true
+    }
+}
+
 class MenuManager {
     let builder: UIMenuBuilder
 
@@ -369,6 +390,7 @@ class MenuManager {
 
     private func toggleMenu() -> AppMacBridgeStatusItemMenuItem {
         .init(name: L10n.Menu.StatusItem.toggle(appName)) { callbackInfo in
+            if StatusItemPrimaryAction.openInBrowserIfNeeded() { return }
             if callbackInfo.isActive {
                 callbackInfo.deactivate()
             } else {
@@ -410,6 +432,7 @@ class MenuManager {
             accessibilityLabel: appName,
             items: menuItems,
             primaryActionHandler: { callbackInfo in
+                if StatusItemPrimaryAction.openInBrowserIfNeeded() { return }
                 if callbackInfo.isActive {
                     callbackInfo.deactivate()
                 } else if callbackInfo.hasWindows {
@@ -539,6 +562,7 @@ final class StatusItemManager {
 
     private func toggleMenu() -> AppMacBridgeStatusItemMenuItem {
         .init(name: L10n.Menu.StatusItem.toggle(appName)) { callbackInfo in
+            if StatusItemPrimaryAction.openInBrowserIfNeeded() { return }
             if callbackInfo.isActive {
                 callbackInfo.deactivate()
             } else {
@@ -579,6 +603,7 @@ final class StatusItemManager {
             accessibilityLabel: appName,
             items: menuItems,
             primaryActionHandler: { callbackInfo in
+                if StatusItemPrimaryAction.openInBrowserIfNeeded() { return }
                 if callbackInfo.isActive {
                     callbackInfo.deactivate()
                 } else if callbackInfo.hasWindows {

Sources/MacBridge/MacBridgeAppDelegateHandler.swift

@@ -5,6 +5,14 @@ import ObjectiveC.runtime
 enum MacBridgeAppDelegateHandler {
     static let terminationWillBeginNotification: Notification.Name = .init("ha_terminationWillBegin")
 
+    /// Invoked when the app is reopened (e.g. the Dock icon is clicked) with no visible windows.
+    /// Returns `true` if it handled the reopen, which suppresses AppKit's default window creation.
+    static var reopenHandler: (() -> Bool)?
+
+    /// Implementation captured from the original `applicationShouldHandleReopen(_:hasVisibleWindows:)`
+    /// (if the delegate had one, directly or inherited) so the swizzled method can call through to it.
+    static var originalReopenIMP: IMP?
+
     static func swizzleAppDelegate() {
         guard !Bundle.main.isRunningInExtension else {
             // Don't try and swizzle the App Delegate in an extension; there won't be one.
@@ -41,6 +49,30 @@ enum MacBridgeAppDelegateHandler {
 
             method_exchangeImplementations(original, replacement)
         }
+
+        installReopenSwizzle(on: klass)
+    }
+
+    /// `applicationShouldHandleReopen(_:hasVisibleWindows:)` is an *optional* `NSApplicationDelegate`
+    /// method, so the Catalyst delegate may not implement it. Install our implementation safely rather
+    /// than with `method_exchangeImplementations` (which `fatalError`s when the method is missing and
+    /// would recurse if we added it with no original): capture any existing/inherited implementation to
+    /// call through to, then add ours if absent or replace it if present.
+    private static func installReopenSwizzle(on klass: AnyClass) {
+        let originalSelector = #selector(NSApplicationDelegate.applicationShouldHandleReopen(_:hasVisibleWindows:))
+        let replacementSelector = #selector(NSObject.ha_applicationShouldHandleReopen(_:hasVisibleWindows:))
+
+        guard let replacement = class_getInstanceMethod(klass, replacementSelector) else { return }
+        let replacementIMP = method_getImplementation(replacement)
+        let typeEncoding = method_getTypeEncoding(replacement)
+
+        // Capture any existing (possibly inherited) implementation up front so we can call through to it.
+        originalReopenIMP = class_getInstanceMethod(klass, originalSelector).map(method_getImplementation)
+
+        if !class_addMethod(klass, originalSelector, replacementIMP, typeEncoding) {
+            // The class defines the method itself; replace it and capture its own implementation.
+            originalReopenIMP = class_replaceMethod(klass, originalSelector, replacementIMP, typeEncoding)
+        }
     }
 }
 
@@ -54,4 +86,27 @@ private extension NSObject {
         // refers to the non-swizzled method
         return ha_applicationShouldTerminate(sender)
     }
+
+    @objc func ha_applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows: Bool) -> Bool {
+        // Reopen with no visible windows (e.g. Dock icon click) — let the app decide what to do. This is
+        // used to open Home Assistant in the browser when that preference is on; if the handler reports it
+        // took over, suppress AppKit's default window creation by returning false.
+        if !hasVisibleWindows, MacBridgeAppDelegateHandler.reopenHandler?() == true {
+            return false
+        }
+
+        // Otherwise fall back to the delegate's original behaviour (if any), else allow the reopen.
+        if let originalIMP = MacBridgeAppDelegateHandler.originalReopenIMP {
+            typealias ReopenFunction = @convention(c) (NSObject, Selector, NSApplication, Bool) -> Bool
+            let original = unsafeBitCast(originalIMP, to: ReopenFunction.self)
+            return original(
+                self,
+                #selector(NSApplicationDelegate.applicationShouldHandleReopen(_:hasVisibleWindows:)),
+                sender,
+                hasVisibleWindows
+            )
+        }
+
+        return true
+    }
 }

Sources/MacBridge/MacBridgeImpl.swift

@@ -97,6 +97,10 @@ import SystemConfiguration
         NSApplication.shared.activate(ignoringOtherApps: true)
     }
 
+    func setReopenHandler(_ handler: @escaping () -> Bool) {
+        MacBridgeAppDelegateHandler.reopenHandler = handler
+    }
+
     func configureStatusItem(using configuration: MacBridgeStatusItemConfiguration) {
         statusItem?.configure(using: configuration)
     }

Sources/Shared/Environment/MacBridgeProtocol.swift

@@ -28,6 +28,11 @@ import Foundation
     /// Brings app to the foreground
     func activateApp()
 
+    /// Registers a handler invoked when the app is reopened with no visible windows (e.g. the user
+    /// clicks the Dock icon). Return `true` from the handler if it fully handled the reopen, which
+    /// suppresses AppKit's default window creation.
+    func setReopenHandler(_ handler: @escaping () -> Bool)
+
     func setLoginItem(forBundleIdentifier: String, enabled: Bool) -> Bool
     func isLoginItemEnabled(forBundleIdentifier identifier: String) -> Bool
 }