iOS11下Swift4实现永久后台持续定位更新问题求助

Hey Calvin, let's dig into why your background location updates are stopping after ~30 hours and how to get your app running persistently (until the user manually closes it).

First, let's recap the key constraints you're hitting: iOS has built-in battery and resource safeguards that can throttle or suspend even location-enabled apps over time, especially if it thinks the app isn't doing critical work. Let's break down the triggers for suspension and actionable fixes:

Common Triggers for App Suspension in Background #

• Missing Background Mode Entitlement: If you haven't enabled the "Location updates" background mode, iOS will stop location updates once the app moves to background.
• System Resource Throttling: After prolonged background runtime, iOS may reduce location update frequency or suspend apps to save battery, especially if the device is stationary for hours.
• Incorrect Permission Setup: Even if you request Always authorization, missing Info.plist descriptions can lead users to grant only When In Use access, which blocks background updates.
• Unoptimized Background Work: Long-running synchronous tasks (like blocking network calls) or memory leaks can make iOS mark your app as unresponsive and suspend it.

Step-by-Step Fixes #

1. Verify Critical Entitlements & Info.plist Setup #

This is the most common oversight:

• Enable Background Modes: In Xcode, go to your target's Capabilities tab, toggle on Background Modes, and check the Location updates box. This tells iOS your app needs persistent background location access.
• Update Info.plist: Add these two keys with clear, user-facing descriptions (iOS requires both for Always authorization):

  <key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
  <string>We need continuous location tracking to update your GPS data in real-time.</string>
  <key>NSLocationWhenInUseUsageDescription</key>
  <string>We need your location to update your GPS data while the app is open.</string>
  

• Confirm Authorization Status: Add a check to ensure you have Always access before starting updates:

  switch locationManager.authorizationStatus {
  case .authorizedAlways:
      locationManager.startUpdatingLocation()
  case .notDetermined:
      locationManager.requestAlwaysAuthorization()
  default:
      // Handle missing permissions (e.g., prompt user to enable in Settings)
      break
  }
  

2. Optimize Location Manager Configuration for Persistence #

Tweak your location settings to signal to iOS that your app needs continuous tracking:

• Set activityType: For persistent tracking, set this to a value that tells iOS your app is doing critical location work:

  locationManager!.activityType = .automotiveNavigation // or .otherNavigation if not driving
  

  This makes iOS prioritize your app's location updates over less critical background tasks.
• Adjust Accuracy & Distance Filter: If your use case allows, reduce accuracy to save battery (iOS is less likely to throttle apps with lower power usage):

  locationManager!.desiredAccuracy = kCLLocationAccuracyHundredMeters // instead of nearest 10m
  locationManager!.distanceFilter = 150 // slightly higher filter to reduce updates when stationary
  

• Keep pausesLocationUpdatesAutomatically = false: You already have this set, which is correct—this prevents iOS from pausing updates when the device is stationary.

3. Keep the App Active in Background #

• Use Background Tasks for Firebase Operations: Wrap your Firebase write in a background task to ensure iOS doesn't suspend the app mid-operation:

  func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
      guard let userID = Auth.auth().currentUser?.uid, let lastloc = locations.last else { return }
      
      var backgroundTaskID: UIBackgroundTaskIdentifier = .invalid
      backgroundTaskID = UIApplication.shared.beginBackgroundTask(expirationHandler: {
          UIApplication.shared.endBackgroundTask(backgroundTaskID)
          backgroundTaskID = .invalid
      })
      
      let now = Date()
      let dateFormatter = DateFormatter()
      dateFormatter.dateFormat = "HH:mm:ss"
      let currentTime = dateFormatter.string(from: now)
      
      let lat = String(lastloc.coordinate.latitude)
      let lng = String(lastloc.coordinate.longitude)
      let data = ["Lat": lat, "Lng": lng]
      ref.child("GPS").child(userID).child("\(testCount)-\(currentTime)").setValue(data) { error, _ in
          testCount += 1
          UIApplication.shared.endBackgroundTask(backgroundTaskID)
          backgroundTaskID = .invalid
      }
  }
  

  This tells iOS your app is actively processing location data, so it won't suspend it prematurely.
• Avoid Memory Leaks: Use Xcode's Memory Graph Debugger to check for leaks (e.g., strong references to CLLocationManagerDelegate). Leaks increase memory usage, making iOS more likely to kill your app.

4. Handle Edge Cases #

• Check for Location Errors: Implement the error delegate to catch system-level restrictions:

  func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
      if let clError = error as? CLError {
          switch clError.code {
          case .denied, .restricted:
              // Handle permission issues
              break
          case .locationUnknown, .network:
              // Handle temporary location failures
              break
          default:
              print("Location error: \(clError.localizedDescription)")
          }
      }
  }
  

• Validate Firebase Auth State: Even if Firebase doesn't auto-logout, add a check to ensure the user is still authenticated before writing data—unauthenticated requests can fail silently and leave your app doing no useful work, which iOS may penalize.

Final Notes #

Even with all these fixes, iOS may still throttle updates on devices with low battery or strict power settings (like Low Power Mode). The best you can do is follow Apple's guidelines to signal your app's critical need for location tracking, minimize power usage, and handle edge cases gracefully.

内容的提问来源于stack exchange，提问作者Calvin Lin