feat: Implement Seekbar sync for now playing [1/2]

- Guarded behind button called 'Sync Android playback seekbar'
- Also added a tooltip
- Added the seekbar in Menu bar widget and also the phone display
- Requires changes in android app

Author: Mudit200408

airsync-mac/Core/Storage/UserDefaults.swift

@@ -26,6 +26,7 @@ extension UserDefaults {
         static let continueApp = "continueApp"
         static let directKeyInput = "directKeyInput"
         static let sendNowPlayingStatus = "sendNowPlayingStatus"
+        static let syncAndroidPlaybackSeekbar = "syncAndroidPlaybackSeekbar"
         static let isMusicCardHidden = "isMusicCardHidden"
         static let lastOnboarding = "lastOnboarding"
 
@@ -130,6 +131,15 @@ extension UserDefaults {
         set { set(newValue, forKey: Keys.sendNowPlayingStatus)}
     }
 
+    /// When enabled, AirSync plays a silent audio loop to claim macOS Now Playing focus,
+    /// allowing the Android playback seekbar to be exposed in boringNotch / Control Center.
+    /// Disabled by default because it causes Bluetooth multipoint headphones to route
+    /// audio to the Mac, preventing Android media from playing through the headphones.
+    var syncAndroidPlaybackSeekbar: Bool {
+        get { bool(forKey: Keys.syncAndroidPlaybackSeekbar) }
+        set { set(newValue, forKey: Keys.syncAndroidPlaybackSeekbar) }
+    }
+
     var isMusicCardHidden: Bool {
         get { bool(forKey: Keys.isMusicCardHidden) }
         set { set(newValue, forKey: Keys.isMusicCardHidden) }

airsync-mac/Core/Util/MacInfo/MacInfoSyncManager.swift

@@ -108,6 +108,21 @@ class MacInfoSyncManager: ObservableObject {
                     self?.sendDeviceStatusWithoutMusic()
                     return
                 }
+
+                // IMPORTANT: Filter out AirSync's own bundle ID.
+                // NowPlayingPublisher writes Android's media info into macOS
+                // MPNowPlayingInfoCenter so boringNotch can display it.
+                // media-control reads from the same source, so without this guard
+                // we'd forward AirSync's own published entry back to Android,
+                // creating a play/pause feedback loop.
+                let ownBundleId = Bundle.main.bundleIdentifier ?? ""
+                if let bundleId = info.bundleIdentifier, !ownBundleId.isEmpty,
+                   bundleId == ownBundleId {
+                    // This is our own reflection — treat as nothing playing on Mac
+                    self?.sendDeviceStatusWithoutMusic()
+                    return
+                }
+
                 // MUST update @Published properties on main thread
                 DispatchQueue.main.async {
 //                    print("Now Playing fetched:", info) // debug

airsync-mac/Core/WebSocket/WebSocketServer+Handlers.swift

@@ -254,6 +254,32 @@ extension WebSocketServer {
         {
             let albumArt = (music["albumArt"] as? String) ?? ""
             let likeStatus = (music["likeStatus"] as? String) ?? "none"
+            let isBuffering = (music["isBuffering"] as? Bool) ?? false
+
+            // Android sends duration/position in ms; convert to seconds.
+            // Using NSNumber because Swift's `as? Double` fails if the JSON parser inferred an Int.
+            let durationSec = (music["duration"] as? NSNumber).map { $0.doubleValue / 1000.0 } ?? -1.0
+            var positionSec = (music["position"] as? NSNumber).map { $0.doubleValue / 1000.0 } ?? -1.0
+
+            // Timestamp-based position correction:
+            // Android includes the wall-clock ms when the position snapshot was taken.
+            // We add the elapsed time since then (which includes WiFi transit) to get a
+            // much more accurate "current" position — effectively NTP-style compensation.
+            // Clamp: only correct for realistic WiFi delays (< 5s). Larger deltas likely
+            // indicate clock skew between devices, which would worsen accuracy if applied.
+            if positionSec >= 0, playing, !isBuffering,
+               let tsMs = music["positionTimestamp"] as? NSNumber {
+                let capturedAt = tsMs.doubleValue / 1000.0
+                let nowSec = Date().timeIntervalSince1970
+                let networkDelta = nowSec - capturedAt
+                if networkDelta > -2.0 && networkDelta < 5.0 {
+                    positionSec += max(0.0, networkDelta)
+                }
+            }
+            // Clamp to duration to prevent the seekbar going past the end
+            if durationSec > 0 && positionSec > durationSec {
+                positionSec = durationSec
+            }
 
             AppState.shared.status = DeviceStatus(
                 battery: .init(level: level, isCharging: isCharging),
@@ -265,19 +291,38 @@ extension WebSocketServer {
                     volume: volume,
                     isMuted: isMuted,
                     albumArt: albumArt,
-                    likeStatus: likeStatus
+                    likeStatus: likeStatus,
+                    duration: durationSec,
+                    position: positionSec,
+                    isBuffering: isBuffering
                 )
             )
 
-            // Publish Android now-playing info to MPNowPlayingInfoCenter
-            var npInfo = NowPlayingInfo()
-            npInfo.title = title
-            npInfo.artist = artist
-            npInfo.isPlaying = playing
-            if let data = Data(base64Encoded: albumArt) {
-                npInfo.artworkData = data
+            // Publish Android now-playing info to MPNowPlayingInfoCenter only when
+            // the user has opted in, because this requires playing silent audio which
+            // causes multipoint Bluetooth headphones to route audio to the Mac.
+            if UserDefaults.standard.syncAndroidPlaybackSeekbar {
+                var npInfo = NowPlayingInfo()
+                npInfo.title = title
+                npInfo.artist = artist
+                npInfo.isPlaying = playing
+                if let data = Data(base64Encoded: albumArt) {
+                    npInfo.artworkData = data
+                }
+                // Seekbar: Android sends duration/position in ms; MPNowPlayingInfoCenter needs seconds.
+                // positionMs uses optDouble so missing/null safely falls back to -1.
+                // NOTE: Use NSNumber because Swift's JSON parser returns an Int type for flat numbers.
+                if let nsNum = music["duration"] as? NSNumber, nsNum.doubleValue > 0 {
+                    npInfo.duration = nsNum.doubleValue / 1000.0
+                }
+                if let pMs = music["position"] as? NSNumber, pMs.doubleValue >= 0 {
+                    npInfo.elapsedTime = pMs.doubleValue / 1000.0
+                }
+                NowPlayingPublisher.shared.update(info: npInfo)
+            } else {
+                // If the setting is off, ensure any previously running session is cleared
+                NowPlayingPublisher.shared.clear()
             }
-            NowPlayingPublisher.shared.update(info: npInfo)
         }
     }
 

airsync-mac/Core/WebSocket/WebSocketServer+Outgoing.swift

@@ -108,6 +108,12 @@ extension WebSocketServer {
     func like() { sendMediaAction("like") }
     func unlike() { sendMediaAction("unlike") }
 
+    /// Seek Android playback to a specific position (in seconds).
+    func seekTo(positionSeconds: Double) {
+        let positionMs = Int(positionSeconds * 1000)
+        sendMessage(type: "mediaControl", data: ["action": "seekTo", "positionMs": positionMs])
+    }
+
     private func sendMediaAction(_ action: String) {
         sendMessage(type: "mediaControl", data: ["action": action])
     }

airsync-mac/Model/Device.swift

@@ -47,7 +47,10 @@ struct MockData{
         volume: 50,
         isMuted: false,
         albumArt: "",
-        likeStatus: "none"
+        likeStatus: "none",
+        duration: 214,
+        position: 42,
+        isBuffering: false
     )
 
     static let sampleDevices = [

airsync-mac/Model/DeviceStatus.swift

@@ -21,6 +21,12 @@ struct DeviceStatus: Codable {
         let isMuted: Bool
         let albumArt: String
         let likeStatus: String
+        /// Total track duration in seconds. -1 means not available.
+        let duration: Double
+        /// Current playback position in seconds (corrected for network transit on Mac side).
+        let position: Double
+        /// True when Android is buffering — position is frozen, Mac timer should pause.
+        let isBuffering: Bool
     }
 
     let battery: Battery