feat: implement battery optimizations with adaptive polling

NetBird/Source/App/NetBirdApp.swift

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

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
-
-                }
-                if !details.ip.isEmpty && details.ip != self.ip {
-                    self.defaults.set(details.ip, forKey: "ip")
-                    self.ip = details.ip
+            // Ensure all UI updates happen on the main thread
+            DispatchQueue.main.async {
+                // 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
                 }
-                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,20 @@ 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
+    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,10 +257,34 @@ public class NetworkExtensionAdapter: ObservableObject {
         let messageString = "Status"
         if let messageData = messageString.data(using: .utf8) {
             do {
-                try session.sendProviderMessage(messageData) { response in
+                try session.sendProviderMessage(messageData) { [weak self] response in
+                    guard let self = self else { return }
+
                     if let response = response {
                         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 {
@@ -267,16 +304,81 @@ 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) {
+        // 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
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self else { return }
+                if self.timer.isValid {
+                    self.timer.invalidate()
+                }
+                self.startTimer(completion: completion)
+            }
+        }
+    }
+
     func startTimer(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
+        let interval = isInBackground ? backgroundPollingInterval : currentPollingInterval
+        lastTimerInterval = interval
+
+        // 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: interval, 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: \(interval)s (background: \(self.isInBackground))")
+        }
     }
 
     func stopTimer() {
         self.timer.invalidate()
+        self.consecutiveStablePolls = 0
+        self.currentPollingInterval = minPollingInterval
+    }
+
+    func setBackgroundMode(_ inBackground: Bool) {
+        let wasInBackground = isInBackground
+        isInBackground = inBackground
+
+        // Restart timer with appropriate interval if state changed
+        if wasInBackground != inBackground && timer.isValid {
+            let interval = inBackground ? backgroundPollingInterval : currentPollingInterval
+            print("App state changed to \(inBackground ? "background" : "foreground"), adjusting polling interval to \(interval)s")
+            // Timer will be restarted on next fetchData call
+        }
     }
 
     func getExtensionStatus(completion: @escaping (NEVPNStatus) -> Void) {