Develop - Wireless native mirror, desktop and sidebar native mirror, CPU optimizations, Notification settings per-app, custom app search and more

.gitignore

@@ -75,3 +75,4 @@ AGENTS.md
 .tend-stack
 docs/plans/
 build.log
+*.trace

airsync-mac/Core/AppState.swift

@@ -24,6 +24,7 @@ class AppState: ObservableObject {
     private var lastClipboardValue: String? = nil
     private var shouldSkipSave = false
     private var cancellables = Set<AnyCancellable>()
+    private var bleWakeUpWorkItem: DispatchWorkItem?
     private static let licenseDetailsKey = "licenseDetails"
 
     @Published var isOS26: Bool = true
@@ -103,6 +104,7 @@ class AppState: ObservableObject {
 
         self.useADBWhenPossible = UserDefaults.standard.object(forKey: "useADBWhenPossible") == nil ? true : UserDefaults.standard.bool(forKey: "useADBWhenPossible")
         self.useNativeMirroringByDefault = UserDefaults.standard.bool(forKey: "useNativeMirroringByDefault")
+        self.useNativeDesktopMirroringByDefault = UserDefaults.standard.bool(forKey: "useNativeDesktopMirroringByDefault")
         self.isMusicCardHidden = UserDefaults.standard.bool(forKey: "isMusicCardHidden")
 
         self.isCrashReportingEnabled = UserDefaults.standard.object(forKey: "isCrashReportingEnabled") == nil ? true : UserDefaults.standard.bool(forKey: "isCrashReportingEnabled")
@@ -172,6 +174,7 @@ class AppState: ObservableObject {
 
         // Reset mirroring state on launch to prevent auto-opening if it was open during last session
         self.isNativeMirroring = false
+        self.isNativeDesktopMirroring = false
 
         startMediaTimer()
 
@@ -206,23 +209,34 @@ class AppState: ObservableObject {
                 self.selectedTab = .notifications
             }
 
-            // BLE scan management: pause when a regular (non-BLE) connection is active
+            // BLE connection management: Wi-Fi priority over BLE
             let isRegularConnection = device?.ipAddress != nil && device?.ipAddress != "BLE"
             let wasRegularConnection = oldValue?.ipAddress != nil && oldValue?.ipAddress != "BLE"
 
-            if isRegularConnection && !wasRegularConnection {
-                // Regular connection established — stop BLE scanning to save power/bandwidth
-                if isBLEEnabled && BLECentralManager.shared.connectionStatus == .scanning {
-                    print("[state] Regular connection active — pausing BLE scan")
+            if isRegularConnection {
+                // Regular connection established — immediately put BLE to idle (disconnect & stop scan)
+                if isBLEEnabled {
+                    print("[state] Regular connection active — disconnecting BLE and putting to idle")
                     BLECentralManager.shared.stopScanning()
+                    BLECentralManager.shared.disconnect()
                 }
+                // Cancel any pending delayed BLE wake-up tasks
+                self.bleWakeUpWorkItem?.cancel()
+                self.bleWakeUpWorkItem = nil
             } else if !isRegularConnection && wasRegularConnection {
-                // Regular connection lost — resume BLE scanning if BLE is enabled and not already BLE-connected
-                if isBLEEnabled && !BLECentralManager.shared.isAuthenticated {
-                    print("[state] Regular connection lost — resuming BLE scan")
-                    BLECentralManager.shared.isManuallyDisconnected = false
-                    BLECentralManager.shared.startScanning()
+                // Regular connection lost — schedule BLE scanning after 5 seconds to give Wi-Fi a chance to reconnect
+                self.bleWakeUpWorkItem?.cancel()
+                let workItem = DispatchWorkItem { [weak self] in
+                    guard let self = self else { return }
+                    let stillDisconnected = self.device?.ipAddress == nil || self.device?.ipAddress == "BLE"
+                    if stillDisconnected && self.isBLEEnabled && !BLECentralManager.shared.isAuthenticated {
+                        print("[state] Regular connection stayed lost for 5s — resuming BLE scan")
+                        BLECentralManager.shared.isManuallyDisconnected = false
+                        BLECentralManager.shared.startScanning()
+                    }
                 }
+                self.bleWakeUpWorkItem = workItem
+                DispatchQueue.main.asyncAfter(deadline: .now() + 5.0, execute: workItem)
             }
         }
     }
@@ -307,7 +321,30 @@ class AppState: ObservableObject {
     @Published var adbConnectionMode: ADBConnectionMode? = nil
 
     @Published var recentApps: [AndroidApp] = []
-    @Published var isNativeMirroring: Bool = false
+    @Published var isNativeMirroring: Bool = false {
+        didSet {
+            if isNativeMirroring {
+                if isSidebarMirroring { isSidebarMirroring = false }
+                if isNativeDesktopMirroring { isNativeDesktopMirroring = false }
+            }
+        }
+    }
+    @Published var isSidebarMirroring: Bool = false {
+        didSet {
+            if isSidebarMirroring {
+                if isNativeMirroring { isNativeMirroring = false }
+                if isNativeDesktopMirroring { isNativeDesktopMirroring = false }
+            }
+        }
+    }
+    @Published var isNativeDesktopMirroring: Bool = false {
+        didSet {
+            if isNativeDesktopMirroring {
+                if isNativeMirroring { isNativeMirroring = false }
+                if isSidebarMirroring { isSidebarMirroring = false }
+            }
+        }
+    }
     @Published var temporaryDragLabel: String? = nil
 
     // MARK: - Centralized Media Seekbar State
@@ -644,6 +681,12 @@ class AppState: ObservableObject {
         }
     }
 
+    @Published var useNativeDesktopMirroringByDefault: Bool {
+        didSet {
+            UserDefaults.standard.set(useNativeDesktopMirroringByDefault, forKey: "useNativeDesktopMirroringByDefault")
+        }
+    }
+
     @Published var isFileAccessEnabled: Bool {
         didSet {
             if !isPlus && licenseCheck {
@@ -1092,9 +1135,8 @@ class AppState: ObservableObject {
                     self.notifications.insert(notif, at: 0)
                 }
             }
-            // Trigger native macOS notification if not silent and content actually changed/new
-            // Default to alerting if priority is missing (backwards compatibility)
-            if notif.priority != "silent" && contentChanged {
+            let isAppSilentOnMac = UserDefaults.standard.appSilentNotifications[notif.package] ?? false
+            if notif.priority != "silent" && !isAppSilentOnMac && contentChanged {
                 var appIcon: NSImage? = nil
                 if let iconPath = self.androidApps[notif.package]?.iconUrl {
                     appIcon = NSImage(contentsOfFile: iconPath)

airsync-mac/Core/BLE/BLECentralManager.swift

@@ -212,6 +212,12 @@ extension BLECentralManager: CBCentralManagerDelegate {
 
         // Auto connect if enabled and not manually disconnected
         if AppState.shared.isBLEAutoConnectEnabled && !isManuallyDisconnected {
+            let isWifiConnected = AppState.shared.device != nil && AppState.shared.device?.ipAddress != "BLE" && AppState.shared.device?.ipAddress != "Bluetooth LE"
+            if isWifiConnected {
+                print("[BLE] Regular Wi-Fi connection is active — skipping auto-connect to BLE")
+                return
+            }
+
             let token = UserDefaults.standard.string(forKey: "bleAuthToken") ?? ""
             if token.isEmpty {
                 return

airsync-mac/Core/MenuBarManager.swift

@@ -15,6 +15,7 @@ class MenuBarManager: NSObject {
     private var statusItem: NSStatusItem?
     private var menubarPanel: MenubarPanel?
     private var eventMonitor: Any?
+    private var localEventMonitor: Any?
     private var cancellables = Set<AnyCancellable>()
     private var appState = AppState.shared
     private var temporaryDragLabel: String?
@@ -187,14 +188,22 @@ class MenuBarManager: NSObject {
 
             appState.isMenubarWindowOpen = true
 
-            // Monitor clicks outside to close
+            // Monitor clicks outside to close (both globally and locally within current app)
             eventMonitor = NSEvent.addGlobalMonitorForEvents(matching: [.leftMouseDown, .rightMouseDown]) { [weak self] event in
                 if let eventLocation = NSEvent.mouseLocation as NSPoint?,
                    let panelFrame = self?.menubarPanel?.frame,
                    !NSMouseInRect(eventLocation, panelFrame, false) {
                     self?.hidePopover()
                 }
             }
+            localEventMonitor = NSEvent.addLocalMonitorForEvents(matching: [.leftMouseDown, .rightMouseDown]) { [weak self] event in
+                if let eventLocation = NSEvent.mouseLocation as NSPoint?,
+                   let panelFrame = self?.menubarPanel?.frame,
+                   !NSMouseInRect(eventLocation, panelFrame, false) {
+                    self?.hidePopover()
+                }
+                return event
+            }
         }
     }
 
@@ -205,6 +214,10 @@ class MenuBarManager: NSObject {
             NSEvent.removeMonitor(monitor)
             eventMonitor = nil
         }
+        if let localMonitor = localEventMonitor {
+            NSEvent.removeMonitor(localMonitor)
+            localEventMonitor = nil
+        }
     }
 }
 

airsync-mac/Core/QuickConnect/QuickConnectManager.swift

@@ -44,11 +44,23 @@ class QuickConnectManager: ObservableObject {
             return
         }
 
+        let isBLE = device.ipAddress == "Bluetooth LE" || device.ipAddress == "BLE"
+
         DispatchQueue.main.async {
+            if isBLE {
+                if let existing = self.lastConnectedDevices[currentMacIP] {
+                    let existingIsBLE = existing.ipAddress == "Bluetooth LE" || existing.ipAddress == "BLE"
+                    if !existingIsBLE {
+                        print("[quick-connect] Not overwriting existing Wi-Fi device (\(existing.name): \(existing.ipAddress)) with BLE device")
+                        return
+                    }
+                }
+            }
+
             self.lastConnectedDevices[currentMacIP] = device
             self.saveDeviceHistoryToDisk()
+            print("[quick-connect] Saved last connected device for network \(currentMacIP): \(device.name) (\(device.ipAddress))")
         }
-        print("[quick-connect] Saved last connected device for network \(currentMacIP): \(device.name) (\(device.ipAddress))")
     }
 
     /// Clears the last connected device for the current network
@@ -64,8 +76,36 @@ class QuickConnectManager: ObservableObject {
 
     /// Attempts to wake up and reconnect to a specific discovered device
     func connect(to discoveredDevice: DiscoveredDevice) {
+        let hasWifiIPs = discoveredDevice.ips.contains { $0 != "Bluetooth LE" && !$0.isEmpty }
+        if (discoveredDevice.type == "ble" || discoveredDevice.ips.contains("Bluetooth LE")) && !hasWifiIPs {
+            print("[quick-connect] Discovered device is Bluetooth LE, connecting directly via BLE...")
+            // Show progress in UI
+            DispatchQueue.main.async {
+                self.connectingDeviceID = discoveredDevice.id
+            }
+
+            // Save as last connected device (so we can auto-reconnect later)
+            let device = Device(
+                name: discoveredDevice.name,
+                ipAddress: "Bluetooth LE",
+                port: discoveredDevice.port,
+                version: "Unknown",
+                adbPorts: [],
+                deviceId: discoveredDevice.deviceId
+            )
+            saveLastConnectedDevice(device)
+
+            BLECentralManager.shared.connectManually(toUuid: discoveredDevice.deviceId)
+
+            // Clear progress after short delay
+            DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
+                self.connectingDeviceID = nil
+            }
+            return
+        }
+
         // Pick best IP: prefer local (non-100.x) over VPN
-        let bestIP = discoveredDevice.ips.first(where: { !$0.hasPrefix("100.") }) ?? discoveredDevice.ips.first ?? ""
+        let bestIP = discoveredDevice.ips.first(where: { !$0.hasPrefix("100.") && $0 != "Bluetooth LE" }) ?? discoveredDevice.ips.first(where: { $0 != "Bluetooth LE" }) ?? ""
 
         // Convert DiscoveredDevice to Device model
         let device = Device(
@@ -98,6 +138,12 @@ class QuickConnectManager: ObservableObject {
             return
         }
 
+        if lastDevice.ipAddress == "Bluetooth LE" {
+            print("[quick-connect] Last connected device is BLE. Initiating BLE reconnection...")
+            BLECentralManager.shared.connectManually(toUuid: lastDevice.deviceId)
+            return
+        }
+
         print("[quick-connect] Attempting to wake up device: \(lastDevice.name) at \(lastDevice.ipAddress)")
         print("[quick-connect] Will try HTTP port \(Self.ANDROID_HTTP_WAKEUP_PORT), then UDP port \(Self.ANDROID_UDP_WAKEUP_PORT) if needed")