Comment obtenir une mise à jour de l'emplacement en arrière-plan toutes les n minutes dans mon application iOS?

Je cherche un moyen d'obtenir une mise à jour de l'emplacement en arrière-plan toutes les n minutes dans mon application iOS. J'utilise iOS 4.3 et la solution devrait fonctionner pour les iPhones non jailbreakés.

J'ai essayé / envisagé les options suivantes:

• CLLocationManager startUpdatingLocation/startMonitoringSignificantLocationChanges: Cela fonctionne en arrière-plan comme prévu, en fonction des propriétés configurées, mais il ne semble pas possible de le forcer à mettre à jour l'emplacement toutes les n minutes
• NSTimer: Fonctionne lorsque l'application s'exécute au premier plan, mais ne semble pas être conçue pour les tâches en arrière-plan
• Notifications locales: les notifications locales peuvent être planifiées toutes les n minutes, mais il n'est pas possible d'exécuter du code pour obtenir l'emplacement actuel (sans que l'utilisateur n'ait à lancer l'application via la notification). Cette approche ne semble pas non plus être une approche propre, car ce n'est pas pour cela que les notifications doivent être utilisées.
• UIApplication:beginBackgroundTaskWithExpirationHandler: D'après ce que je comprends, cela devrait être utilisé pour terminer certains travaux en arrière-plan (également limités dans le temps) lorsqu'une application est déplacée en arrière-plan plutôt que de mettre en œuvre des processus d'arrière-plan "de longue durée".

Comment puis-je implémenter ces mises à jour régulières de l'emplacement en arrière-plan?

J'ai trouvé une solution pour l'implémenter à l'aide des forums des développeurs Apple:

• Spécifier location background mode
• Créez un NSTimeren arrière-plan avecUIApplication:beginBackgroundTaskWithExpirationHandler:
• Quand nest plus petit que UIApplication:backgroundTimeRemainingcela fonctionnera très bien. Lorsque nest plus grand , le location managerdoit être réactivé (et désactivé) avant qu'il ne reste plus de temps pour éviter que la tâche d'arrière-plan ne soit supprimée.

Cela fonctionne car l'emplacement est l'un des trois types d'exécution en arrière-plan autorisés .

Remarque: j'ai perdu du temps en testant cela dans le simulateur où cela ne fonctionne pas. Cependant, cela fonctionne bien sur mon téléphone.

Sur iOS 8/9/10 pour effectuer la mise à jour de l'emplacement en arrière-plan toutes les 5 minutes, procédez comme suit:

1. Allez dans Project -> Capabilities -> Background Modes -> select Location updates

2. Allez dans Projet -> Info -> ajoutez une clé NSLocationAlwaysUsageDescription avec une valeur vide (ou éventuellement n'importe quel texte)

3. Pour faire fonctionner l'emplacement lorsque votre application est en arrière-plan et envoyer des coordonnées au service Web ou faire quoi que ce soit avec elles toutes les 5 minutes, implémentez-le comme dans le code ci-dessous.

Je n'utilise aucune tâche d'arrière-plan ni aucun minuteur. J'ai testé ce code avec mon appareil avec iOS 8.1 qui était allongé sur mon bureau pendant quelques heures avec mon application en arrière-plan. L'appareil était verrouillé et le code fonctionnait correctement tout le temps.

@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

Je l'ai fait dans une application que je développe. Les minuteries ne fonctionnent pas lorsque l'application est en arrière-plan, mais l'application reçoit constamment les mises à jour de l'emplacement. J'ai lu quelque part dans la documentation (je n'arrive pas à le trouver maintenant, je publierai une mise à jour lorsque je le ferai) qu'une méthode ne peut être appelée que sur une boucle d'exécution active lorsque l'application est en arrière-plan. Le délégué de l'application a une boucle d'exécution active même dans le bg, vous n'avez donc pas besoin de créer la vôtre pour que cela fonctionne. [Je ne sais pas si c'est la bonne explication mais c'est comme ça que j'ai compris de ce que j'ai lu]

Tout d'abord, ajoutez l' locationobjet de la clé UIBackgroundModesdans info.plist de votre application. Maintenant, ce que vous devez faire, c'est commencer les mises à jour de position n'importe où dans votre application:

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

Ensuite, écrivez une méthode pour gérer les mises à jour d'emplacement, par exemple -(void)didUpdateToLocation:(CLLocation*)location, dans le délégué d'application. Ensuite, implémentez la méthode locationManager:didUpdateLocation:fromLocationdeCLLocationManagerDelegate dans la classe dans laquelle vous avez démarré le gestionnaire d'emplacement (puisque nous avons défini le délégué du gestionnaire d'emplacement sur 'self'). Dans cette méthode, vous devez vérifier si l'intervalle de temps après lequel vous devez gérer les mises à jour de l'emplacement s'est écoulé. Vous pouvez le faire en enregistrant l'heure actuelle à chaque fois. Si ce temps s'est écoulé, appelez la méthode UpdateLocation depuis votre délégué d'application:

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];
        }
    }
}

Cela appellera votre méthode toutes les 5 minutes, même lorsque votre application est en arrière-plan. Imp: Cette implémentation vide la batterie, si la précision de vos données de localisation n'est pas critique, vous devez utiliser[locationManager startMonitoringSignificantLocationChanges]

Avant d'ajouter ceci à votre application, veuillez lire le Guide de programmation de détection d'emplacement

Maintenant qu'iOS6 est sorti, la meilleure façon d'avoir des services de localisation toujours actifs est ...

- (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]);

}

Je l'ai juste testé comme ça:

J'ai démarré l'application, je vais en arrière-plan et je me déplace dans la voiture de quelques minutes. Ensuite, je rentre chez moi pendant 1 heure et recommence à bouger (sans rouvrir l'application). Les emplacements ont recommencé. Puis s'est arrêté pendant deux heures et a recommencé. Tout va bien encore ...

N'OUBLIEZ PAS D'UTILISER les nouveaux services de localisation dans iOS6

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

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

Pour quelqu'un d'autre ayant un cauchemar, comprenez celui-ci. J'ai une solution simple.

1. regardez cet exemple de raywenderlich.com -> avoir un exemple de code, cela fonctionne parfaitement, mais malheureusement pas de minuterie pendant l'emplacement en arrière-plan. cela fonctionnera indéfiniment.

2. Ajouter un minuteur en utilisant:

   -(void)applicationDidEnterBackground {
   [self.locationManager stopUpdatingLocation];
   
   UIApplication*    app = [UIApplication sharedApplication];
   
   bgTask = [app beginBackgroundTaskWithExpirationHandler:^{
       [app endBackgroundTask:bgTask];
       bgTask = UIBackgroundTaskInvalid;
   }];
   
    self.timer = [NSTimer scheduledTimerWithTimeInterval:intervalBackgroundUpdate
                                                 target:self.locationManager
                                               selector:@selector(startUpdatingLocation)
                                               userInfo:nil
                                                repeats:YES];
   
   }

3. N'oubliez pas d'ajouter "Registres d'application pour les mises à jour de localisation" dans info.plist.

Voici ce que j'utilise:

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)
    }
}

Je démarre le suivi dans AppDelegate comme ça:

BackgroundLocationManager.instance.start()

Malheureusement, toutes vos hypothèses semblent correctes, et je ne pense pas qu'il existe un moyen de le faire. Afin d'économiser la batterie, les services de localisation de l'iPhone sont basés sur le mouvement. Si le téléphone se trouve au même endroit, il est invisible pour les services de localisation.

Le CLLocationManagerne fera qu'appelerlocationManager:didUpdateToLocation:fromLocation: lorsque le téléphone recevra une mise à jour de localisation, ce qui ne se produit que si l'un des trois services de localisation (tour cellulaire, GPS, Wi-Fi) perçoit un changement.

Quelques autres choses qui pourraient aider à éclairer d'autres solutions:

• Le démarrage et l'arrêt des services entraînent l' didUpdateToLocationappel de la méthode déléguée, mais ils newLocationpeuvent avoir un ancien horodatage.

• La surveillance de la région pourrait aider

• Lors de l'exécution en arrière-plan, sachez qu'il peut être difficile d'obtenir une prise en charge «complète» des LocationServices approuvée par Apple. D'après ce que j'ai vu, ils ont été spécifiquement conçus startMonitoringSignificantLocationChangescomme une alternative à faible consommation pour les applications qui nécessitent une prise en charge de l'emplacement en arrière-plan, et encouragent fortement les développeurs à l'utiliser à moins que l'application n'en ait absolument besoin.

Bonne chance!

MISE À JOUR: Ces pensées peuvent être obsolètes à ce jour. On dirait que les gens ont du succès avec la réponse @wjans, ci-dessus.

J'ai écrit une application à l'aide des services de localisation, l'application doit envoyer une position toutes les 10 secondes. Et cela a très bien fonctionné.

Utilisez simplement le " allowDeferredLocationUpdatesUntilTraveled: timeout ", en suivant le doc d'Apple.

Ce que j'ai fait, c'est:

Obligatoire: enregistrer le mode d'arrière-plan pour l'emplacement de mise à jour.

1. Créez LocationMangeret startUpdatingLocation, avec accuracyet filteredDistancecomme vous voulez:

-(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. Pour que l'application s'exécute indéfiniment en utilisant la allowDeferredLocationUpdatesUntilTraveled:timeoutméthode en arrière-plan, vous devez redémarrer updatingLocationavec un nouveau paramètre lorsque l'application se déplace en arrière-plan, comme ceci:

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

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

3. L' application est mise à jour comme d'habitude avec un locationManager:didUpdateLocations:rappel:

-(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. Mais vous devez gérer les données puis les locationManager:didFinishDeferredUpdatesWithError:rappeler en fonction de votre objectif

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

     _deferringUpdates = NO;

     //do something 
}

5. REMARQUE: je pense que nous devrions réinitialiser les paramètres de LocationManagerchaque fois que l'application bascule entre le mode d'arrière-plan / de fond

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

Cela est nécessaire pour le suivi de l'emplacement en arrière-plan depuis iOS 9.

J'ai utilisé la méthode de xs2bush pour obtenir un intervalle (en utilisant timeIntervalSinceDate ) et développé un peu. Je voulais m'assurer que j'obtenais la précision requise dont j'avais besoin et aussi que je n'épuisais pas la batterie en gardant la radio gps allumée plus que nécessaire.

Je maintiens la localisation en continu avec les paramètres suivants:

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

il s'agit d'un drain relativement faible sur la batterie. Lorsque je suis prêt à obtenir ma prochaine lecture d'emplacement périodique, je vérifie d'abord si l'emplacement est dans la précision souhaitée, si c'est le cas, j'utilise ensuite l'emplacement. Si ce n'est pas le cas, j'augmente la précision avec ceci:

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

obtenir mon emplacement, puis une fois que j'ai l'emplacement, je baisse à nouveau la précision pour minimiser la décharge de la batterie. J'ai écrit un échantillon de travail complet de cela et j'ai également écrit la source du code côté serveur pour collecter les données de localisation, les stocker dans une base de données et permettre aux utilisateurs de visualiser les données GPS en temps réel ou de récupérer et d'afficher les itinéraires précédemment stockés. J'ai des clients pour iOS, android, windows phone et java me. Tous les clients sont écrits en natif et fonctionnent tous correctement en arrière-plan. Le projet est sous licence MIT.

Le projet iOS est ciblé pour iOS 6 à l'aide d'un SDK de base d'iOS 7. Vous pouvez obtenir le code ici .

Veuillez signaler un problème sur github si vous voyez des problèmes avec celui-ci. Merci.

Il semble que stopUpdatingLocation soit ce qui déclenche le temporisateur du chien de garde en arrière-plan, donc je l'ai remplacé dans didUpdateLocation par:

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

qui semble éteindre efficacement le GPS. Le sélecteur de l'arrière-plan NSTimer devient alors:

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

Tout ce que je fais, c'est basculer périodiquement la précision pour obtenir une coordonnée de haute précision toutes les quelques minutes et parce que locationManager n'a pas été arrêté, backgroundTimeRemaining reste à sa valeur maximale. Cela a réduit la consommation de batterie de ~ 10% par heure (avec kCLLocationAccuracyBest constante en arrière-plan) à ~ 2% par heure sur mon appareil

Il existe un cocoapod APScheduledLocationManager qui permet d'obtenir des mises à jour de l'emplacement en arrière-plan toutes les n secondes avec la précision de localisation souhaitée.

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

Le référentiel contient également un exemple d'application écrit en Swift 3.

Dans iOS 9 et watchOS 2.0, il existe une nouvelle méthode sur CLLocationManager qui vous permet de demander l'emplacement actuel: CLLocationManager: requestLocation (). Cela se termine immédiatement, puis renvoie l'emplacement au délégué CLLocationManager.

Vous pouvez utiliser un NSTimer pour demander un emplacement toutes les minutes avec cette méthode maintenant et ne pas avoir à travailler avec les méthodes startUpdatingLocation et stopUpdatingLocation.

Toutefois, si vous souhaitez capturer des emplacements en fonction d'un changement de X mètres par rapport au dernier emplacement, définissez simplement la propriété distanceFilter de CLLocationManger et appelez X startUpdatingLocation ().

Ci-joint une solution Swift basée sur:

Définir App registers for location updates dans info.plist

Gardez le gestionnaire de localisation en cours d'exécution tout le temps

Basculez kCLLocationAccuracyentre BestForNavigation(pendant 5 secondes pour obtenir l'emplacement) etThreeKilometers pour le reste de la période d'attente pour éviter l'épuisement de la batterie

Cet exemple met à jour l'emplacement toutes les 1 min en avant-plan et toutes les 15 minutes en arrière-plan.

L'exemple fonctionne correctement avec Xcode 6 Beta 6, exécuté sur un appareil iOS 7.

Dans le délégué d'application (mapView est une option pointant vers le contrôleur mapView)

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
}

Dans mapView (locationManager pointe vers l'objet dans 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")
        }
    }