feat: implement battery optimizations with adaptive polling

NetBird/Source/App/NetBirdApp.swift

@@ -30,14 +30,22 @@ struct NetBirdApp: App {
         WindowGroup {
             MainView()
                 .environmentObject(viewModel)
-                .onReceive(NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)) {_ in
-                    print("App is active!")
-                    viewModel.checkExtensionState()
-                    viewModel.startPollingDetails()
-                }
-                .onReceive(NotificationCenter.default.publisher(for: UIApplication.willResignActiveNotification)) {_ in
-                    print("App is inactive!")
-                    viewModel.stopPollingDetails()
+                .onChange(of: scenePhase) { newPhase in
+                    switch newPhase {
+                    case .background:
+                        print("App moved to background")
+                        viewModel.networkExtensionAdapter.setBackgroundMode(true)
+                        viewModel.stopPollingDetails()
+                    case .active:
+                        print("App became active")
+                        viewModel.networkExtensionAdapter.setBackgroundMode(false)
+                        viewModel.checkExtensionState()
+                        viewModel.startPollingDetails()
+                    case .inactive:
+                        break
+                    @unknown default:
+                        break
+                    }
                 }
         }
     }

NetBird/Source/App/ViewModels/MainViewModel.swift

@@ -112,41 +112,53 @@ class ViewModel: ObservableObject {
         }
     }
 
+    // Battery optimization: Track last extension state check
+    private var lastExtensionStateCheck: Date = Date.distantPast
+    private let extensionStateCheckInterval: TimeInterval = 30.0 // Check every 30 seconds instead of every poll
+
     func startPollingDetails() {
-        networkExtensionAdapter.startTimer { details in
-
-            self.checkExtensionState()
-            if self.extensionState == .disconnected && self.extensionStateText == "Connected" {
-                self.showAuthenticationRequired = true
-                self.extensionStateText = "Disconnected"
-            }
+        networkExtensionAdapter.startTimer { [weak self] details in
+            guard let self = self else { return }
 
-            if details.ip != self.ip || details.fqdn != self.fqdn || details.managementStatus != self.managementStatus
-            {
-                if !details.fqdn.isEmpty && details.fqdn != self.fqdn {
-                    self.defaults.set(details.fqdn, forKey: "fqdn")
-                    self.fqdn = details.fqdn
-
+            // Ensure all UI updates happen on the main thread
+            Task { @MainActor in
+                // Battery optimization: Only check extension state periodically, not on every poll
+                let now = Date()
+                if now.timeIntervalSince(self.lastExtensionStateCheck) >= self.extensionStateCheckInterval {
+                    self.checkExtensionState()
+                    self.lastExtensionStateCheck = now
                 }
-                if !details.ip.isEmpty && details.ip != self.ip {
-                    self.defaults.set(details.ip, forKey: "ip")
-                    self.ip = details.ip
-                }
-                print("Status: \(details.managementStatus) - Extension: \(self.extensionState) - LoginRequired: \(self.networkExtensionAdapter.isLoginRequired())")
 
-                if details.managementStatus != self.managementStatus {
-                    self.managementStatus = details.managementStatus
+                if self.extensionState == .disconnected && self.extensionStateText == "Connected" {
+                    self.showAuthenticationRequired = true
+                    self.extensionStateText = "Disconnected"
                 }
 
-                if details.managementStatus == .disconnected && self.extensionState == .connected && self.networkExtensionAdapter.isLoginRequired() {
-                    self.networkExtensionAdapter.stop()
-                    self.showAuthenticationRequired = true
+                if details.ip != self.ip || details.fqdn != self.fqdn || details.managementStatus != self.managementStatus
+                {
+                    if !details.fqdn.isEmpty && details.fqdn != self.fqdn {
+                        self.defaults.set(details.fqdn, forKey: "fqdn")
+                        self.fqdn = details.fqdn
+                    }
+                    if !details.ip.isEmpty && details.ip != self.ip {
+                        self.defaults.set(details.ip, forKey: "ip")
+                        self.ip = details.ip
+                    }
+                    print("Status: \(details.managementStatus) - Extension: \(self.extensionState) - LoginRequired: \(self.networkExtensionAdapter.isLoginRequired())")
+
+                    if details.managementStatus != self.managementStatus {
+                        self.managementStatus = details.managementStatus
+                    }
+
+                    if details.managementStatus == .disconnected && self.extensionState == .connected && self.networkExtensionAdapter.isLoginRequired() {
+                        self.networkExtensionAdapter.stop()
+                        self.showAuthenticationRequired = true
+                    }
                 }
-            }
-
-            self.statusDetailsValid = true
-
-            let sortedPeerInfo = details.peerInfo.sorted(by: { a, b in
+
+                self.statusDetailsValid = true
+
+                let sortedPeerInfo = details.peerInfo.sorted(by: { a, b in
                 a.ip < b.ip
             })
             if sortedPeerInfo.count != self.peerViewModel.peerInfo.count || !sortedPeerInfo.elementsEqual(self.peerViewModel.peerInfo, by: { a, b in

NetbirdKit/NetworkExtensionAdapter.swift

@@ -17,7 +17,21 @@ public class NetworkExtensionAdapter: ObservableObject {
     var extensionID = "io.netbird.app.NetbirdNetworkExtension"
     var extensionName = "NetBird Network Extension"
 
-    let decoder = PropertyListDecoder()    
+    let decoder = PropertyListDecoder()
+
+    // Battery optimization: Adaptive polling
+    // All state variables must be accessed only from pollingQueue to prevent race conditions
+    private var currentPollingInterval: TimeInterval = 10.0 // Start with 10 seconds
+    private var consecutiveStablePolls: Int = 0
+    private var lastStatusHash: Int = 0
+    private var isInBackground: Bool = false
+    private var lastTimerInterval: TimeInterval = 10.0 // Track last set interval
+    private let pollingQueue = DispatchQueue(label: "com.netbird.polling", qos: .utility)
+
+    // Polling intervals (in seconds)
+    private let minPollingInterval: TimeInterval = 10.0  // When changes detected
+    private let stablePollingInterval: TimeInterval = 20.0  // When stable
+    private let backgroundPollingInterval: TimeInterval = 60.0  // In background
 
     @Published var timer : Timer
 
@@ -244,19 +258,49 @@ public class NetworkExtensionAdapter: ObservableObject {
         let messageString = "Status"
         if let messageData = messageString.data(using: .utf8) {
             do {
-                try session.sendProviderMessage(messageData) { response in
-                    if let response = response {
+                try session.sendProviderMessage(messageData) { [weak self] response in
+                    guard let self = self else { return }
+
+                    // Serialize all response handling and state mutations through pollingQueue
+                    self.pollingQueue.async { [weak self] in
+                        guard let self = self else { return }
+
+                        guard let response = response else {
+                            let defaultStatus = StatusDetails(ip: "", fqdn: "", managementStatus: .disconnected, peerInfo: [])
+                            completion(defaultStatus)
+                            return
+                        }
+
                         do {
                             let decodedStatus = try self.decoder.decode(StatusDetails.self, from: response)
+
+                            // Calculate hash to detect changes
+                            let statusHash = self.calculateStatusHash(decodedStatus)
+                            let hasChanged = statusHash != self.lastStatusHash
+
+                            if hasChanged {
+                                // Status changed - use faster polling
+                                self.consecutiveStablePolls = 0
+                                self.currentPollingInterval = self.minPollingInterval
+                                self.lastStatusHash = statusHash
+                                print("Status changed, using fast polling (\(self.currentPollingInterval)s)")
+                            } else {
+                                // Status stable - gradually increase interval
+                                self.consecutiveStablePolls += 1
+                                if self.consecutiveStablePolls > 3 {
+                                    self.currentPollingInterval = self.stablePollingInterval
+                                }
+                            }
+
+                            // Restart timer with new interval if needed
+                            self.restartTimerIfNeeded(completion: completion)
+
                             completion(decodedStatus)
-                            return
                         } catch {
                             print("Failed to decode status details.")
+                            let defaultStatus = StatusDetails(ip: "", fqdn: "", managementStatus: .disconnected, peerInfo: [])
+                            completion(defaultStatus)
                         }
-                    } else {
-                        let defaultStatus = StatusDetails(ip: "", fqdn: "", managementStatus: .disconnected, peerInfo: [])
-                        completion(defaultStatus)
-                        return
                     }
                 }
             } catch {
@@ -267,16 +311,123 @@ public class NetworkExtensionAdapter: ObservableObject {
         }
     }
 
+    private func calculateStatusHash(_ status: StatusDetails) -> Int {
+        var hasher = Hasher()
+        hasher.combine(status.ip)
+        hasher.combine(status.fqdn)
+        hasher.combine(status.managementStatus)
+        hasher.combine(status.peerInfo.count)
+        for peer in status.peerInfo {
+            hasher.combine(peer.ip)
+            hasher.combine(peer.connStatus)
+        }
+        return hasher.finalize()
+    }
+
+    private func restartTimerIfNeeded(completion: @escaping (StatusDetails) -> Void) {
+        // This function is called from pollingQueue, so we can safely access state variables
+        // Only restart if interval changed significantly (more than 2 seconds difference)
+        let targetInterval = isInBackground ? backgroundPollingInterval : currentPollingInterval
+
+        // Check if we need to restart timer
+        if abs(lastTimerInterval - targetInterval) > 2.0 {
+            lastTimerInterval = targetInterval
+            // Capture state values here (on pollingQueue) to avoid deadlock
+            let intervalToUse = targetInterval
+            let backgroundStateToUse = isInBackground
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self else { return }
+                if self.timer.isValid {
+                    self.timer.invalidate()
+                }
+                // Pass values directly to avoid pollingQueue.sync call from main thread
+                self.startTimer(interval: intervalToUse, backgroundState: backgroundStateToUse, completion: completion)
+            }
+        }
+    }
+
     func startTimer(completion: @escaping (StatusDetails) -> Void) {
+        startTimer(interval: nil, backgroundState: nil, completion: completion)
+    }
+
+    private func startTimer(interval: TimeInterval?, backgroundState: Bool?, completion: @escaping (StatusDetails) -> Void) {
         self.timer.invalidate()
+
+        // Initial fetch
         self.fetchData(completion: completion)
-        self.timer = Timer.scheduledTimer(withTimeInterval: 3, repeats: true, block: { _ in
-            self.fetchData(completion: completion)
-        })
+
+        // Determine polling interval based on app state
+        // If values are provided (from restartTimerIfNeeded), use them to avoid deadlock
+        // Otherwise, read from pollingQueue (when called directly from main thread)
+        let intervalToUse: TimeInterval
+        let backgroundStateToUse: Bool
+
+        if let providedInterval = interval, let providedBackgroundState = backgroundState {
+            // Values already captured on pollingQueue, use them directly
+            intervalToUse = providedInterval
+            backgroundStateToUse = providedBackgroundState
+            // Update lastTimerInterval synchronously to prevent race condition
+            // This is safe because we're not in a deadlock situation (values already captured)
+            pollingQueue.sync { [weak self] in
+                guard let self = self else { return }
+                self.lastTimerInterval = providedInterval
+            }
+        } else {
+            // Called directly, must read from pollingQueue (but this is safe as we're not in a deadlock situation)
+            var intervalValue: TimeInterval = minPollingInterval
+            var backgroundValue: Bool = false
+            pollingQueue.sync {
+                backgroundValue = isInBackground
+                intervalValue = backgroundValue ? backgroundPollingInterval : currentPollingInterval
+                lastTimerInterval = intervalValue
+            }
+            intervalToUse = intervalValue
+            backgroundStateToUse = backgroundValue
+        }
+
+        // Create timer - must be on main thread for RunLoop
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            self.timer = Timer(timeInterval: intervalToUse, repeats: true) { [weak self] _ in
+                guard let self = self else { return }
+                // Use background queue for actual network work
+                self.pollingQueue.async {
+                    self.fetchData(completion: completion)
+                }
+            }
+
+            // Add timer to main RunLoop
+            RunLoop.main.add(self.timer, forMode: .common)
+
+            print("Started polling with interval: \(intervalToUse)s (background: \(backgroundStateToUse))")
+        }
     }
 
     func stopTimer() {
         self.timer.invalidate()
+        // Reset state variables - must be done on pollingQueue to avoid race conditions
+        pollingQueue.async { [weak self] in
+            guard let self = self else { return }
+            self.consecutiveStablePolls = 0
+            self.currentPollingInterval = self.minPollingInterval
+        }
+    }
+
+    func setBackgroundMode(_ inBackground: Bool) {
+        // All state mutations must happen on pollingQueue to prevent race conditions
+        pollingQueue.async { [weak self] in
+            guard let self = self else { return }
+            let wasInBackground = self.isInBackground
+            self.isInBackground = inBackground
+
+            // Restart timer with appropriate interval if state changed
+            if wasInBackground != inBackground {
+                let interval = inBackground ? self.backgroundPollingInterval : self.currentPollingInterval
+                print("App state changed to \(inBackground ? "background" : "foreground"), adjusting polling interval to \(interval)s")
+                // Timer will be restarted on next fetchData call via restartTimerIfNeeded
+            }
+        }
     }
 
     func getExtensionStatus(completion: @escaping (NEVPNStatus) -> Void) {