Come posso ottenere un aggiornamento della posizione in background ogni n minuti nella mia applicazione iOS?

Sto cercando un modo per ottenere un aggiornamento della posizione in background ogni n minuti nella mia applicazione iOS. Sto usando iOS 4.3 e la soluzione dovrebbe funzionare per iPhone senza jailbreak.

Ho provato / considerato le seguenti opzioni:

• CLLocationManager startUpdatingLocation/startMonitoringSignificantLocationChanges: Funziona in background come previsto, in base alle proprietà configurate, ma non sembra possibile forzarlo per aggiornare la posizione ogni n minuti
• NSTimer: Funziona quando l'app è in esecuzione in primo piano ma non sembra essere progettata per attività in background
• Notifiche locali: le notifiche locali possono essere programmate ogni n minuti, ma non è possibile eseguire un codice per ottenere la posizione corrente (senza che l'utente debba avviare l'app tramite la notifica). Anche questo approccio non sembra essere un approccio pulito in quanto non è questo ciò per cui le notifiche dovrebbero essere utilizzate.
• UIApplication:beginBackgroundTaskWithExpirationHandler: Per quanto ho capito, questo dovrebbe essere usato per finire un po 'di lavoro in background (anche limitato nel tempo) quando un'app viene spostata in background piuttosto che implementare processi in background "di lunga durata".

Come posso implementare questi aggiornamenti regolari della posizione in background?

Ho trovato una soluzione per implementarlo con l'aiuto dei forum degli sviluppatori Apple:

• Specificare location background mode
• Crea uno NSTimerin background conUIApplication:beginBackgroundTaskWithExpirationHandler:
• Quando nè più piccolo di UIApplication:backgroundTimeRemainingquanto funzionerà bene. Quando nè più grande , location managerdovrebbe essere nuovamente abilitato (e disabilitato) prima che non rimanga tempo per evitare che l'attività in background venga uccisa.

Questo funziona perché la posizione è uno dei tre tipi consentiti di esecuzione in background .

Nota: ho perso un po 'di tempo testandolo nel simulatore in cui non funziona. Tuttavia, funziona bene sul mio telefono.

Su iOS 8/9/10 per effettuare l'aggiornamento della posizione in background ogni 5 minuti, procedi come segue:

1. Vai a Progetto -> Funzionalità -> Modalità sfondo -> seleziona Aggiornamenti posizione

2. Vai a Progetto -> Informazioni -> aggiungi una chiave NSLocationAlwaysUsageDescription con valore vuoto (o facoltativamente qualsiasi testo)

3. Per far funzionare la posizione quando la tua app è in background e inviare coordinate al servizio web o fare qualcosa con loro ogni 5 minuti implementala come nel codice qui sotto.

Non sto usando attività in background o timer. Ho testato questo codice con il mio dispositivo con iOS 8.1 che giaceva sulla mia scrivania per alcune ore con la mia app in esecuzione in background. Il dispositivo era bloccato e il codice era sempre in esecuzione correttamente.

@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

L'ho fatto in un'applicazione che sto sviluppando. I timer non funzionano quando l'app è in background ma l'app riceve costantemente gli aggiornamenti della posizione. Ho letto da qualche parte nella documentazione (non riesco a trovarlo ora, posterò un aggiornamento quando lo faccio) che un metodo può essere chiamato solo su un ciclo di esecuzione attivo quando l'app è in background. Il delegato dell'app ha un ciclo di esecuzione attivo anche in bg, quindi non è necessario crearne uno proprio per farlo funzionare. [Non sono sicuro che questa sia la spiegazione corretta, ma è così che ho capito da quello che ho letto]

Prima di tutto, aggiungi l' locationoggetto per la chiave UIBackgroundModesnella info.plist della tua app. Ora, ciò che devi fare è avviare gli aggiornamenti della posizione ovunque nell'app:

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

Quindi, scrivi un metodo per gestire gli aggiornamenti della posizione, ad esempio -(void)didUpdateToLocation:(CLLocation*)location, nel delegato dell'app. Quindi implementare il metodo locationManager:didUpdateLocation:fromLocationdi CLLocationManagerDelegatenella classe in cui è stato avviato il location manager (dal momento che abbiamo impostato la location manager delegato al 'sé'). All'interno di questo metodo è necessario verificare se è trascorso l'intervallo di tempo dopo il quale è necessario gestire gli aggiornamenti della posizione. Puoi farlo salvando l'ora corrente ogni volta. Se è trascorso questo tempo, chiama il metodo UpdateLocation dal delegato dell'app:

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

Questo chiamerà il tuo metodo ogni 5 minuti anche quando l'app è in background. Imp: questa implementazione scarica la batteria, se la precisione dei dati sulla tua posizione non è critica, dovresti usarla[locationManager startMonitoringSignificantLocationChanges]

Prima di aggiungere questo alla tua app, leggi la Guida alla programmazione della consapevolezza della posizione

Ora che iOS6 è il modo migliore per avere servizi di localizzazione sempre attivi è ...

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

}

Ho appena provato in questo modo:

Ho avviato l'app, sono passato in background e mi sono spostato in macchina per alcuni minuti. Poi torno a casa per 1 ora e ricomincio a spostarmi (senza riaprire l'app). Posizioni ricominciate. Quindi si fermò per due ore e ricominciò. Tutto ok di nuovo ...

NON DIMENTICARE DI USARE i nuovi servizi di localizzazione in iOS6

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

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

A qualcun altro che ha un incubo capire questo. Ho una soluzione semplice.

1. guarda questo esempio da raywenderlich.com -> avere un codice di esempio, questo funziona perfettamente, ma sfortunatamente nessun timer durante la posizione in background. questo funzionerà indefinitamente.

2. Aggiungi timer usando:

   -(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. Non dimenticare di aggiungere "Registri app per gli aggiornamenti di posizione" in info.plist.

Ecco cosa uso:

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

Comincio il monitoraggio in AppDelegate in questo modo:

BackgroundLocationManager.instance.start()

Sfortunatamente, tutte le tue assunzioni sembrano corrette e non penso che ci sia un modo per farlo. Al fine di risparmiare la durata della batteria, i servizi di localizzazione dell'iPhone si basano sul movimento. Se il telefono si trova in un punto, è invisibile ai servizi di localizzazione.

L' CLLocationManagerchiamerà solamente locationManager:didUpdateToLocation:fromLocation:quando il telefono riceve un aggiornamento di posizione, che avviene solo se uno dei tre servizi di localizzazione (torre di cella, gps, wifi) percepisce un cambiamento.

Alcune altre cose che potrebbero aiutare a informare ulteriori soluzioni:

• L'avvio e l'arresto dei servizi provoca la didUpdateToLocationchiamata del metodo delegato, ma newLocationpotrebbe avere un vecchio timestamp.

• Il monitoraggio della regione potrebbe essere d'aiuto

• Quando si esegue in background, tenere presente che potrebbe essere difficile ottenere il supporto "completo" di LocationServices approvato da Apple. Da quello che ho visto, hanno progettato specificamente startMonitoringSignificantLocationChangescome alternativa a basso consumo per le app che richiedono il supporto della posizione in background e incoraggiano fortemente gli sviluppatori a usarlo a meno che l'app non ne abbia assolutamente bisogno.

In bocca al lupo!

AGGIORNAMENTO: Questi pensieri potrebbero essere obsoleti ormai. Sembra che le persone stiano avendo successo con la risposta @wjans, sopra.

Ho scritto un'app utilizzando i servizi di localizzazione, l'app deve inviare la posizione ogni 10 secondi. E ha funzionato molto bene.

Usa semplicemente il metodo " allowDeferredLocationUpdatesUntilTraveled: timeout ", seguendo il documento di Apple.

Quello che ho fatto sono:

Obbligatorio: registra la modalità in background per la posizione di aggiornamento.

1. Crea LocationMangere startUpdatingLocation, con accuracye filteredDistancecome vuoi:

-(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. Per mantenere l'app in esecuzione per sempre utilizzando il allowDeferredLocationUpdatesUntilTraveled:timeoutmetodo in background, è necessario riavviare updatingLocationcon un nuovo parametro quando l'app passa allo sfondo, in questo modo:

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

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

3. L' app viene aggiornata Posizione normalmente con locationManager:didUpdateLocations:callback:

-(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. Ma dovresti gestire i dati e poi locationManager:didFinishDeferredUpdatesWithError:richiamare per il tuo scopo

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

     _deferringUpdates = NO;

     //do something 
}

5. NOTA: penso che dovremmo ripristinare i parametri di LocationManagerogni volta che l'app passa dalla modalità background / forground.

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

Ciò è necessario per il tracciamento della posizione in background da iOS 9.

Ho usato il metodo di xs2bush per ottenere un intervallo (usando timeIntervalSinceDate) e vi ho ampliato un po '. Volevo assicurarmi di ottenere la precisione richiesta di cui avevo bisogno e anche di non scaricare la batteria mantenendo la radio GPS più del necessario.

Mantengo la posizione in esecuzione continuamente con le seguenti impostazioni:

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

questo è un consumo relativamente basso della batteria. Quando sono pronto per ottenere la mia prossima lettura periodica della posizione, per prima cosa controllo se la posizione è nella precisione desiderata, se lo è, quindi uso la posizione. In caso contrario, aumento la precisione con questo:

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

ottenere la mia posizione e quindi, una volta trovata la posizione, abbassare nuovamente la precisione per ridurre al minimo il consumo della batteria. Ho scritto un esempio di lavoro completo di questo e ho anche scritto l'origine per il codice lato server per raccogliere i dati sulla posizione, archiviarli in un database e consentire agli utenti di visualizzare i dati GPS in tempo reale o recuperare e visualizzare percorsi precedentemente memorizzati. Ho client per iOS, Android, Windows Phone e Java Me. Tutti i client sono scritti in modo nativo e funzionano tutti correttamente in background. Il progetto è concesso in licenza dal MIT.

Il progetto iOS è mirato per iOS 6 utilizzando un SDK di base di iOS 7. Puoi ottenere il codice qui .

Si prega di presentare un problema su Github se si riscontrano problemi con esso. Grazie.

Sembra che stopUpdatingLocation sia ciò che attiva il timer watchdog in background, quindi l'ho sostituito in didUpdateLocation con:

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

che sembra spegnere efficacemente il GPS. Il selettore per lo sfondo NSTimer diventa quindi:

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

Tutto quello che sto facendo è alternare periodicamente l'accuratezza per ottenere una coordinata ad alta precisione ogni pochi minuti e poiché il locationManager non è stato arrestato, backgroundTimeRemaining rimane al suo valore massimo. Ciò ha ridotto il consumo della batteria da ~ 10% all'ora (con kCLLocationAccuracyBest costante in background) a ~ 2% all'ora sul mio dispositivo

Esiste un cocoapod APScheduledLocationManager che consente di ottenere aggiornamenti sulla posizione in background ogni n secondi con l'accuratezza della posizione desiderata.

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

Il repository contiene anche un'app di esempio scritta in Swift 3.

In iOS 9 e watchOS 2.0 c'è un nuovo metodo su CLLocationManager che ti consente di richiedere la posizione corrente: CLLocationManager: requestLocation (). Questo si completa immediatamente e quindi restituisce la posizione al delegato CLLocationManager.

È possibile utilizzare un NSTimer per richiedere una posizione ogni minuto con questo metodo ora e non è necessario lavorare con i metodi startUpdatingLocation e stopUpdatingLocation.

Tuttavia, se si desidera acquisire posizioni basate su una modifica di X metri dall'ultima posizione, è sufficiente impostare la proprietà distanceFilter di CLLocationManger e su X call startUpdatingLocation ().

In allegato è una soluzione Swift basata su:

Definire App registers for location updatesnella info.plist

Mantieni il locationManager sempre in esecuzione

Passare kCLLocationAccuracyda BestForNavigation(per 5 secondi per ottenere la posizione) e ThreeKilometersper il resto del periodo di attesa per evitare il consumo della batteria

Questo esempio aggiorna la posizione ogni 1 minuto in primo piano e ogni 15 minuti in background.

L'esempio funziona perfettamente con Xcode 6 Beta 6, in esecuzione su un dispositivo iOS 7.

Nel delegato dell'app (mapView è un facoltativo che punta al controller 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
}

In mapView (locationManager punta all'oggetto in 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")
        }
    }