如何在我的 iOS 应用程序中每 n 分钟更新一次后台位置？

Question

我正在寻找一种在我的 iOS 应用程序中每 n 分钟更新一次后台位置的方法。我使用的是 iOS 4.3，该解决方案应该适用于未越狱的 iPhone。

我尝试/考虑了以下选项：

• CLLocationManager startUpdatingLocation/startMonitoringSignificantLocationChanges：这根据配置的属性按预期在后台工作，但似乎不可能强制它每 n 分钟更新一次位置
• NSTimer：当应用程序在前台运行时可以工作，但似乎不是为后台任务设计的
• 本地通知：可以每n分钟安排一次本地通知，但不可能执行一些代码来获取当前位置（用户无需通过通知启动应用程序）。这种方法似乎也不是一种干净的方法，因为这不是通知应该使用的用途。
• UIApplication:beginBackgroundTaskWithExpirationHandler：据我了解，当应用程序移至后台时，这应该用于在后台完成一些工作（也受时间限制），而不是实现“长时间运行”后台进程。

如何实现这些定期后台位置更新？

Answer 1

我在Apple开发者论坛的帮助下找到了实现此目的的解决方案：

• 指定位置后台模式
• 使用UIApplication：beginBackgroundTaskWithExpirationHandler：在后台创建一个NSTimer：
• 当n小于UIApplication:backgroundTimeRemaining时，它会正常工作。当n更大时，应在没有剩余时间之前再次启用（和禁用）位置管理器，以避免后台任务被终止。

这是可行的，因为位置是三种允许的后台执行类型之一。

注意：我在模拟器中测试它，但它不起作用，因此浪费了一些时间。不过，它在我的手机上运行良好。

Answer 2

在 iOS 8/9/10 上，要每 5 分钟更新一次后台位置，请执行以下操作：

1. 转到项目 ->能力->背景模式 ->选择位置更新

2. 转到项目 ->信息->添加一个具有空值（或可选的任何文本）的键 NSLocationAlwaysUsageDescription

3. 要使位置在您的应用程序处于后台时工作并将坐标发送到 Web 服务或每 5 分钟对它们执行任何操作，请像下面的代码一样实现它。< /p>

我没有使用任何后台任务或计时器。我已经用我的 iOS 8.1 设备测试了这段代码，该设备放在我的桌子上几个小时，我的应用程序在后台运行。设备被锁定，代码始终正常运行。

@interface LocationManager () <CLLocationManagerDelegate>
@property (strong, nonatomic) CLLocationManager *locationManager;
@property (strong, nonatomic) NSDate *lastTimestamp;

@end

@implementation LocationManager

+ (instancetype)sharedInstance
{
    static id sharedInstance = nil;

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
        LocationManager *instance = sharedInstance;
        instance.locationManager = [CLLocationManager new];
        instance.locationManager.delegate = instance;
        instance.locationManager.desiredAccuracy = kCLLocationAccuracyBest; // you can use kCLLocationAccuracyHundredMeters to get better battery life
        instance.locationManager.pausesLocationUpdatesAutomatically = NO; // this is important
    });

    return sharedInstance;
}

- (void)startUpdatingLocation
{
    CLAuthorizationStatus status = [CLLocationManager authorizationStatus];

    if (status == kCLAuthorizationStatusDenied)
    {
        NSLog(@"Location services are disabled in settings.");
    }
    else
    {
        // for iOS 8
        if ([self.locationManager respondsToSelector:@selector(requestAlwaysAuthorization)])
        {
            [self.locationManager requestAlwaysAuthorization];
        }
        // for iOS 9
        if ([self.locationManager respondsToSelector:@selector(setAllowsBackgroundLocationUpdates:)])
        {
            [self.locationManager setAllowsBackgroundLocationUpdates:YES];
        }

        [self.locationManager startUpdatingLocation];
    }
}

- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray *)locations
{
    CLLocation *mostRecentLocation = locations.lastObject;
    NSLog(@"Current location: %@ %@", @(mostRecentLocation.coordinate.latitude), @(mostRecentLocation.coordinate.longitude));

    NSDate *now = [NSDate date];
    NSTimeInterval interval = self.lastTimestamp ? [now timeIntervalSinceDate:self.lastTimestamp] : 0;

    if (!self.lastTimestamp || interval >= 5 * 60)
    {
        self.lastTimestamp = now;
        NSLog(@"Sending current location to web service.");
    }
}

@end

Answer 3

我在我正在开发的应用程序中这样做了。当应用程序处于后台但应用程序不断接收位置更新时，计时器不起作用。我在文档中的某个地方读到（我现在似乎找不到它，我会在找到时发布更新），当应用程序位于后台时，只能在活动运行循环上调用方法。即使在背景中，应用程序委托也有一个活动的运行循环，因此您不需要创建自己的运行循环来使其工作。
[我不确定这是否是正确的解释，但这就是我从所读内容中的理解]

首先，在应用程序信息中添加键 UIBackgroundModes 的 location 对象.plist。现在，您需要做的是在应用程序中的任何位置启动位置更新：

    CLLocationManager locationManager = [[CLLocationManager alloc] init];
    locationManager.delegate = self;//or whatever class you have for managing location
    [locationManager startUpdatingLocation];

接下来，编写一个方法来处理位置更新，
在应用程序委托中说 -(void)didUpdateToLocation:(CLLocation*)location。然后在启动位置管理器的类中实现 CLLocationManagerDelegate 的 locationManager:didUpdateLocation:fromLocation 方法（因为我们将位置管理器委托设置为“self”）。在此方法中，您需要检查必须处理位置更新的时间间隔是否已过。您可以通过每次保存当前时间来做到这一点。如果该时间已过，请从应用程序委托中调用 UpdateLocation 方法：

NSDate *newLocationTimestamp = newLocation.timestamp;
NSDate *lastLocationUpdateTiemstamp;

int locationUpdateInterval = 300;//5 mins

NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
if (userDefaults) {

        lastLocationUpdateTiemstamp = [userDefaults objectForKey:kLastLocationUpdateTimestamp];

        if (!([newLocationTimestamp timeIntervalSinceDate:lastLocationUpdateTiemstamp] < locationUpdateInterval)) {
            //NSLog(@"New Location: %@", newLocation);
            [(AppDelegate*)[UIApplication sharedApplication].delegate didUpdateToLocation:newLocation];
            [userDefaults setObject:newLocationTimestamp forKey:kLastLocationUpdateTimestamp];
        }
    }
}

即使您的应用程序处于后台，这也会每 5 分钟调用您的方法一次。
Imp：此实现会耗尽电池，如果您的位置数据的准确性并不重要，您应该使用 [locationManager startMonitoringSignificantLocationChanges]

在将此添加到您的应用程序之前，请阅读 位置感知编程指南

Answer 4

既然 iOS6 已经推出，那么拥有永久运行的位置服务的最佳方式是......

- (void)applicationWillResignActive:(UIApplication *)application
{
/*
 Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
 Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
 */

NSLog(@"to background");

app.isInBackground = TRUE;

UIApplication *app = [UIApplication sharedApplication];

// Request permission to run in the background. Provide an
// expiration handler in case the task runs long.
NSAssert(bgTask == UIBackgroundTaskInvalid, nil);

bgTask = [app beginBackgroundTaskWithExpirationHandler:^{
    // Synchronize the cleanup call on the main thread in case
    // the task actually finishes at around the same time.
    dispatch_async(dispatch_get_main_queue(), ^{

        if (bgTask != UIBackgroundTaskInvalid)
        {
            [app endBackgroundTask:bgTask];
            bgTask = UIBackgroundTaskInvalid;
        }
    });
}];

// Start the long-running task and return immediately.
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

    // Do the work associated with the task.

    locationManager.distanceFilter = 100;
    locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters;
    [locationManager startMonitoringSignificantLocationChanges];
    [locationManager startUpdatingLocation];

    NSLog(@"App staus: applicationDidEnterBackground");
    // Synchronize the cleanup call on the main thread in case
    // the expiration handler is fired at the same time.
    dispatch_async(dispatch_get_main_queue(), ^{
        if (bgTask != UIBackgroundTaskInvalid)
        {
            [app endBackgroundTask:bgTask];
            bgTask = UIBackgroundTaskInvalid;
        }
    });
});

NSLog(@"backgroundTimeRemaining: %.0f", [[UIApplication sharedApplication] backgroundTimeRemaining]);

}

只是这样测试：

我启动了应用程序，进入后台并在车内移动了几分钟。然后我回家 1 小时并再次开始移动（无需再次打开应用程序）。地点又开始了。然后停了两个小时又开始了。一切又恢复正常了...

不要忘记使用 iOS6 中的新位置服务

- (void)locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray *)locations
{   
    CLLocation *loc = [locations lastObject];

    // Lat/Lon
    float latitudeMe = loc.coordinate.latitude;
    float longitudeMe = loc.coordinate.longitude;
}

Answer 5

对于其他有噩梦的人来说，请弄清楚这个。我有一个简单的解决方案。

1. 从 raywenderlich.com-> 查看此示例有示例代码，这完美地工作，但不幸的是在后台定位期间没有计时器。这将无限期地运行。

2. 使用以下命令添加计时器：

   -(void)applicationDidEnterBackground {
   [self.locationManager stopUpdatingLocation];
   
   UIApplication* 应用程序 = [UIApplication 共享应用程序];
   
   bgTask = [应用程序 beginBackgroundTaskWithExpirationHandler:^{
       [应用程序结束背景任务：bgTask]；
       bgTask = UIBackgroundTaskInvalid;
   }];
   
    self.timer = [NSTimer ScheduledTimerWithTimeInterval:intervalBackgroundUpdate
                                                 目标：self.locationManager
                                               选择器：@selector(startUpdatingLocation)
                                               用户信息：无
                                                重复：是]；
   
   }
   

3. 只是不要忘记在 info.plist 中添加“应用程序注册位置更新”。

Answer 6

这是我使用的：

import Foundation
import CoreLocation
import UIKit

class BackgroundLocationManager :NSObject, CLLocationManagerDelegate {

    static let instance = BackgroundLocationManager()
    static let BACKGROUND_TIMER = 150.0 // restart location manager every 150 seconds
    static let UPDATE_SERVER_INTERVAL = 60 * 60 // 1 hour - once every 1 hour send location to server

    let locationManager = CLLocationManager()
    var timer:NSTimer?
    var currentBgTaskId : UIBackgroundTaskIdentifier?
    var lastLocationDate : NSDate = NSDate()

    private override init(){
        super.init()
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyKilometer
        locationManager.activityType = .Other;
        locationManager.distanceFilter = kCLDistanceFilterNone;
        if #available(iOS 9, *){
            locationManager.allowsBackgroundLocationUpdates = true
        }

        NSNotificationCenter.defaultCenter().addObserver(self, selector: #selector(self.applicationEnterBackground), name: UIApplicationDidEnterBackgroundNotification, object: nil)
    }

    func applicationEnterBackground(){
        FileLogger.log("applicationEnterBackground")
        start()
    }

    func start(){
        if(CLLocationManager.authorizationStatus() == CLAuthorizationStatus.AuthorizedAlways){
            if #available(iOS 9, *){
                locationManager.requestLocation()
            } else {
                locationManager.startUpdatingLocation()
            }
        } else {
                locationManager.requestAlwaysAuthorization()
        }
    }
    func restart (){
        timer?.invalidate()
        timer = nil
        start()
    }

    func locationManager(manager: CLLocationManager, didChangeAuthorizationStatus status: CLAuthorizationStatus) {
        switch status {
        case CLAuthorizationStatus.Restricted:
            //log("Restricted Access to location")
        case CLAuthorizationStatus.Denied:
            //log("User denied access to location")
        case CLAuthorizationStatus.NotDetermined:
            //log("Status not determined")
        default:
            //log("startUpdatintLocation")
            if #available(iOS 9, *){
                locationManager.requestLocation()
            } else {
                locationManager.startUpdatingLocation()
            }
        }
    }
    func locationManager(manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {

        if(timer==nil){
            // The locations array is sorted in chronologically ascending order, so the
            // last element is the most recent
            guard let location = locations.last else {return}

            beginNewBackgroundTask()
            locationManager.stopUpdatingLocation()
            let now = NSDate()
            if(isItTime(now)){
                //TODO: Every n minutes do whatever you want with the new location. Like for example sendLocationToServer(location, now:now)
            }
        }
    }

    func locationManager(manager: CLLocationManager, didFailWithError error: NSError) {
        CrashReporter.recordError(error)

        beginNewBackgroundTask()
        locationManager.stopUpdatingLocation()
    }

    func isItTime(now:NSDate) -> Bool {
        let timePast = now.timeIntervalSinceDate(lastLocationDate)
        let intervalExceeded = Int(timePast) > BackgroundLocationManager.UPDATE_SERVER_INTERVAL
        return intervalExceeded;
    }

    func sendLocationToServer(location:CLLocation, now:NSDate){
        //TODO
    }

    func beginNewBackgroundTask(){
        var previousTaskId = currentBgTaskId;
        currentBgTaskId = UIApplication.sharedApplication().beginBackgroundTaskWithExpirationHandler({
            FileLogger.log("task expired: ")
        })
        if let taskId = previousTaskId{
            UIApplication.sharedApplication().endBackgroundTask(taskId)
            previousTaskId = UIBackgroundTaskInvalid
        }

        timer = NSTimer.scheduledTimerWithTimeInterval(BackgroundLocationManager.BACKGROUND_TIMER, target: self, selector: #selector(self.restart),userInfo: nil, repeats: false)
    }
}

我在 AppDelegate 中开始跟踪，如下所示：

BackgroundLocationManager.instance.start()

Answer 7

不幸的是，您的所有假设似乎都是正确的，并且我认为没有办法做到这一点。为了节省电池寿命，iPhone的定位服务是基于移动的。如果手机放在一个地方，定位服务就看不到它。

当手机收到位置更新时，CLLocationManager 只会调用 locationManager:didUpdateToLocation:fromLocation:，只有在三种位置服务（手机信号塔、gps、wifi）之一时才会发生这种情况) 感知到变化。

其他一些可能有助于提供进一步解决方案的事情：

• 启动和启动 服务会导致调用 didUpdateToLocation 委托方法，但 newLocation 可能具有旧时间戳。

• 区域监控可能会有所帮助

• 在后台运行时，请注意，可能很难获得“完整”的 LocationServices 支持批准由苹果公司。据我所知，他们专门设计了 startMonitoringSignificantLocationChanges 作为需要后台位置支持的应用程序的低功耗替代方案，并强烈鼓励开发人员使用它，除非应用程序绝对需要它。

祝你好运！

更新：这些想法现在可能已经过时了。看起来人们似乎通过上面@wjans 的回答取得了成功。

Answer 8

我确实使用位置服务编写了一个应用程序，应用程序必须每 10 秒发送一次位置。
而且效果非常好。

只需使用“allowDeferredLocationUpdatesUntilTraveled:timeout”方法，遵循Apple的文档。

我所做的是：

必需：注册后台模式以更新位置。

1. 创建 LocationManger 和 startUpdatingLocation，将 accuracy 和 filteredDistance 设置为您想要的值:

-(void) initLocationManager    
{
    // Create the manager object
    self.locationManager = [[[CLLocationManager alloc] init] autorelease];
    _locationManager.delegate = self;
    // This is the most important property to set for the manager. It ultimately determines how the manager will
    // attempt to acquire location and thus, the amount of power that will be consumed.
    _locationManager.desiredAccuracy = 45;
    _locationManager.distanceFilter = 100;
    // Once configured, the location manager must be "started".
    [_locationManager startUpdatingLocation];
}

2. 要在后台使用 allowDeferredLocationUpdatesUntilTraveled:timeout 方法让应用程序永远运行，您必须在以下情况下使用新参数重新启动 updatingLocation应用程序移动到后台，如下所示：

- (void)applicationWillResignActive:(UIApplication *)application {
     _isBackgroundMode = YES;

    [_locationManager stopUpdatingLocation];
    [_locationManager setDesiredAccuracy:kCLLocationAccuracyBest];
    [_locationManager setDistanceFilter:kCLDistanceFilterNone];
    _locationManager.pausesLocationUpdatesAutomatically = NO;
    _locationManager.activityType = CLActivityTypeAutomotiveNavigation;
    [_locationManager startUpdatingLocation];
 }

3. 应用程序通过 locationManager:didUpdateLocations: 回调正常获取更新位置：

-(void) locationManager:(CLLocationManager *)manager didUpdateLocations:(NSArray *)locations
{
//  store data
    CLLocation *newLocation = [locations lastObject];
    self.userLocation = newLocation;

   //tell the centralManager that you want to deferred this updatedLocation
    if (_isBackgroundMode && !_deferringUpdates)
    {
        _deferringUpdates = YES;
        [self.locationManager allowDeferredLocationUpdatesUntilTraveled:CLLocationDistanceMax timeout:10];
    }
}

4. 但您应该处理然后 locationManager:didFinishDeferredUpdatesWithError: 回调中的数据

- (void) locationManager:(CLLocationManager *)manager didFinishDeferredUpdatesWithError:(NSError *)error {

     _deferringUpdates = NO;

     //do something 
}

5. 注意： 我认为我们应该重置以下参数每次应用程序在后台/前台模式之间切换时，LocationManager。

Answer 9

if ([self.locationManager respondsToSelector:@selector(setAllowsBackgroundLocationUpdates:)]) {
    [self.locationManager setAllowsBackgroundLocationUpdates:YES];
}

从 iOS 9 开始，这是后台位置跟踪所必需的。

Answer 10

我使用了 xs2bush 的获取间隔的方法（使用 timeIntervalSinceDate）并对其进行了一些扩展。我想确保我获得了所需的精度，并且确保我不会因为过度使用 GPS 无线电而耗尽电池电量。

我使用以下设置保持位置连续运行：

locationManager.desiredAccuracy = kCLLocationAccuracyThreeKilometers;
locationManager.distanceFilter = 5;

这是电池消耗相对较低的情况。当我准备好获取下一个定期位置读数时，我首先检查该位置是否在我想要的精度范围内，如果是，我然后使用该位置。如果不是，那么我会通过以下方式提高精度：

locationManager.desiredAccuracy = kCLLocationAccuracyNearestTenMeters;
locationManager.distanceFilter = 0;

获取我的位置，然后一旦获得位置，我就会再次降低精度，以最大程度地减少电池的消耗。我已经编写了一个完整的工作示例，并且还编写了服务器端代码的源代码来收集位置数据，将其存储到数据库并允许用户实时查看 GPS 数据或检索和查看以前存储的路线。我有 iOS、Android、Windows Phone 和 Java Me 客户端。所有客户端都是原生编写的，并且它们都在后台正常工作。该项目已获得麻省理工学院许可。

iOS 项目使用 iOS 7 的基础 SDK 面向 iOS 6。您可以获取代码

如果您发现任何问题，请在 github 上提交问题。谢谢。

Answer 11

似乎 stopUpdatingLocation 是触发后台看门狗计时器的原因，因此我在 didUpdateLocation 中将其替换为：

     [self.locationManager setDesiredAccuracy:kCLLocationAccuracyThreeKilometers];
     [self.locationManager setDistanceFilter:99999];

这似乎有效地关闭了 GPS 电源。然后，后台 NSTimer 的选择器变为：

- (void) changeAccuracy {
[self.locationManager setDesiredAccuracy:kCLLocationAccuracyBest];
[self.locationManager setDistanceFilter:kCLDistanceFilterNone];
}

我所做的就是每隔几分钟定期切换精度以获取高精度坐标，并且由于 locationManager 尚未停止，backgroundTimeRemaining 保持其最大值。在我的设备上，这将电池消耗从每小时约 10%（后台 kCLLocationAccuracyBest 恒定）减少到每小时约 2%

Answer 12

有一个 cocoapod APScheduledLocationManager 允许每 n 秒获取后台位置更新所需的定位精度。

let manager = APScheduledLocationManager(delegate: self)
manager.startUpdatingLocation(interval: 170, acceptableLocationAccuracy: 100)

该存储库还包含一个用 Swift 3 编写的示例应用程序。

Answer 13

在 iOS 9 和 watchOS 2.0 中，CLLocationManager 上有一个新方法可以让您请求当前位置：CLLocationManager:requestLocation()。这会立即完成，然后将位置返回给 CLLocationManager 委托。

您现在可以使用 NSTimer 通过此方法每分钟请求一个位置，而不必使用 startUpdatingLocation 和 stopUpdatingLocation 方法。

但是，如果您想根据距上次位置 X 米的变化来捕获位置，只需设置 CLLocationManger 的 distanceFilter 属性并对 X 调用 startUpdatingLocation() 即可。

Answer 14

附件是一个基于以下内容的 Swift 解决方案：

在 info.plist 中定义 App 注册位置更新

保持 locationManager 始终运行

在 BestForNavigation 之间切换 kCLLocationAccuracy >（等待 5 秒获取位置）并在剩余的等待时间内使用 ThreeKilometers 以避免电池耗尽

此示例在前台每 1 分钟更新一次位置，每 15 秒更新一次位置分钟在后台。

该示例适用于在 iOS 7 设备中运行的 Xcode 6 Beta 6。

在App Delegate中（mapView是一个Optional，指向mapView Controller）

func applicationDidBecomeActive(application: UIApplication!) {
    if appLaunched! == false { // Reference to mapView used to limit one location update per timer cycle
        appLaunched = true
        var appDelegate = UIApplication.sharedApplication().delegate as AppDelegate
        var window = appDelegate.window
        var tabBar = window?.rootViewController as UITabBarController
        var navCon = tabBar.viewControllers[0] as UINavigationController
        mapView = navCon.topViewController as? MapViewController
    }
    self.startInitialPeriodWithTimeInterval(60.0)
}

func applicationDidEnterBackground(application: UIApplication!) {
    self.startInitialPeriodWithTimeInterval(15 * 60.0)
}

func startInitialPeriodWithTimeInterval(timeInterval: NSTimeInterval) {
    timer?.invalidate() // reset timer
    locationManager?.desiredAccuracy = kCLLocationAccuracyBestForNavigation
    timer = NSTimer.scheduledTimerWithTimeInterval(5.0, target: self, selector: Selector("getFirstLocationUpdate:"), userInfo: timeInterval, repeats: false)
}

func getFirstLocationUpdate(sender: NSTimer) {
    let timeInterval = sender.userInfo as Double
    timer?.invalidate()
    mapView?.canReportLocation = true
    timer = NSTimer.scheduledTimerWithTimeInterval(timeInterval, target: self, selector: Selector("waitForTimer:"), userInfo: timeInterval, repeats: true)
}

func waitForTimer(sender: NSTimer) {
    let time = sender.userInfo as Double
    locationManager?.desiredAccuracy = kCLLocationAccuracyBestForNavigation
    finalTimer = NSTimer.scheduledTimerWithTimeInterval(5.0, target: self, selector: Selector("getLocationUpdate"), userInfo: nil, repeats: false)
}

func getLocationUpdate() {
    finalTimer?.invalidate()
    mapView?.canReportLocation = true
}

在mapView中（locationManager指向AppDelegate中的对象）

override func viewDidLoad() {
    super.viewDidLoad()
    var appDelegate = UIApplication.sharedApplication().delegate! as AppDelegate
    locationManager = appDelegate.locationManager!
    locationManager.delegate = self
    canReportLocation = true
}

  func locationManager(manager: CLLocationManager!, didUpdateLocations locations: [AnyObject]!) {
        if canReportLocation! {
            canReportLocation = false
            locationManager.desiredAccuracy = kCLLocationAccuracyThreeKilometers
        } else {
            //println("Ignore location update")
        }
    }