Uso adecuado de beginBackgroundTaskWithExpirationHandler

Estoy un poco confundido acerca de cómo y cuándo usarlo beginBackgroundTaskWithExpirationHandler.

Apple muestra en sus ejemplos usarlo en applicationDidEnterBackgrounddelegado, para tener más tiempo para completar alguna tarea importante, generalmente una transacción de red.

Al mirar mi aplicación, parece que la mayoría de las cosas de mi red son importantes, y cuando se inicia una, me gustaría completarla si el usuario presionó el botón de inicio.

Entonces, ¿es aceptado / una buena práctica envolver cada transacción de red (y no estoy hablando de descargar una gran cantidad de datos, en su mayoría un XML corto) beginBackgroundTaskWithExpirationHandlerpara estar seguro?

Si desea que su transacción de red continúe en segundo plano, deberá envolverla en una tarea en segundo plano. También es muy importante que llame endBackgroundTaskcuando haya terminado; de lo contrario, la aplicación se eliminará una vez que haya expirado el tiempo asignado.

Los míos tienden a verse así:

- (void) doUpdate 
{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        [self beginBackgroundUpdateTask];

        NSURLResponse * response = nil;
        NSError  * error = nil;
        NSData * responseData = [NSURLConnection sendSynchronousRequest: request returningResponse: &response error: &error];

        // Do something with the result

        [self endBackgroundUpdateTask];
    });
}
- (void) beginBackgroundUpdateTask
{
    self.backgroundUpdateTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
        [self endBackgroundUpdateTask];
    }];
}

- (void) endBackgroundUpdateTask
{
    [[UIApplication sharedApplication] endBackgroundTask: self.backgroundUpdateTask];
    self.backgroundUpdateTask = UIBackgroundTaskInvalid;
}

Tengo una UIBackgroundTaskIdentifierpropiedad para cada tarea en segundo plano.

Código equivalente en Swift

func doUpdate () {

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), {

        let taskID = beginBackgroundUpdateTask()

        var response: URLResponse?, error: NSError?, request: NSURLRequest?

        let data = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: &error)

        // Do something with the result

        endBackgroundUpdateTask(taskID)

        })
}

func beginBackgroundUpdateTask() -> UIBackgroundTaskIdentifier {
    return UIApplication.shared.beginBackgroundTask(expirationHandler: ({}))
}

func endBackgroundUpdateTask(taskID: UIBackgroundTaskIdentifier) {
    UIApplication.shared.endBackgroundTask(taskID)
}

La respuesta aceptada es muy útil y debería estar bien en la mayoría de los casos, sin embargo, me molestaron dos cosas:

1. Como han señalado varias personas, almacenar el identificador de la tarea como una propiedad significa que se puede sobrescribir si el método se llama varias veces, lo que lleva a una tarea que nunca terminará correctamente hasta que el sistema operativo la obligue a finalizar en el momento de vencimiento. .

2. Este patrón requiere una propiedad única para cada llamada, lo beginBackgroundTaskWithExpirationHandlerque parece engorroso si tiene una aplicación más grande con muchos métodos de red.

Para resolver estos problemas, escribí un singleton que se encarga de todas las tuberías y rastrea las tareas activas en un diccionario. No se necesitan propiedades para realizar un seguimiento de los identificadores de tareas. Parece funcionar bien. El uso se simplifica a:

//start the task
NSUInteger taskKey = [[BackgroundTaskManager sharedTasks] beginTask];

//do stuff

//end the task
[[BackgroundTaskManager sharedTasks] endTaskWithKey:taskKey];

De manera opcional, si desea proporcionar un bloque de finalización que haga algo más que finalizar la tarea (que está integrada), puede llamar a:

NSUInteger taskKey = [[BackgroundTaskManager sharedTasks] beginTaskWithCompletionHandler:^{
    //do stuff
}];

El código fuente relevante está disponible a continuación (el material singleton se excluye por brevedad). Comentarios / retroalimentación bienvenidos.

- (id)init
{
    self = [super init];
    if (self) {

        [self setTaskKeyCounter:0];
        [self setDictTaskIdentifiers:[NSMutableDictionary dictionary]];
        [self setDictTaskCompletionBlocks:[NSMutableDictionary dictionary]];

    }
    return self;
}

- (NSUInteger)beginTask
{
    return [self beginTaskWithCompletionHandler:nil];
}

- (NSUInteger)beginTaskWithCompletionHandler:(CompletionBlock)_completion;
{
    //read the counter and increment it
    NSUInteger taskKey;
    @synchronized(self) {

        taskKey = self.taskKeyCounter;
        self.taskKeyCounter++;

    }

    //tell the OS to start a task that should continue in the background if needed
    NSUInteger taskId = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
        [self endTaskWithKey:taskKey];
    }];

    //add this task identifier to the active task dictionary
    [self.dictTaskIdentifiers setObject:[NSNumber numberWithUnsignedLong:taskId] forKey:[NSNumber numberWithUnsignedLong:taskKey]];

    //store the completion block (if any)
    if (_completion) [self.dictTaskCompletionBlocks setObject:_completion forKey:[NSNumber numberWithUnsignedLong:taskKey]];

    //return the dictionary key
    return taskKey;
}

- (void)endTaskWithKey:(NSUInteger)_key
{
    @synchronized(self.dictTaskCompletionBlocks) {

        //see if this task has a completion block
        CompletionBlock completion = [self.dictTaskCompletionBlocks objectForKey:[NSNumber numberWithUnsignedLong:_key]];
        if (completion) {

            //run the completion block and remove it from the completion block dictionary
            completion();
            [self.dictTaskCompletionBlocks removeObjectForKey:[NSNumber numberWithUnsignedLong:_key]];

        }

    }

    @synchronized(self.dictTaskIdentifiers) {

        //see if this task has been ended yet
        NSNumber *taskId = [self.dictTaskIdentifiers objectForKey:[NSNumber numberWithUnsignedLong:_key]];
        if (taskId) {

            //end the task and remove it from the active task dictionary
            [[UIApplication sharedApplication] endBackgroundTask:[taskId unsignedLongValue]];
            [self.dictTaskIdentifiers removeObjectForKey:[NSNumber numberWithUnsignedLong:_key]];

        }

    }
}

Aquí hay una clase Swift que encapsula la ejecución de una tarea en segundo plano:

class BackgroundTask {
    private let application: UIApplication
    private var identifier = UIBackgroundTaskInvalid

    init(application: UIApplication) {
        self.application = application
    }

    class func run(application: UIApplication, handler: (BackgroundTask) -> ()) {
        // NOTE: The handler must call end() when it is done

        let backgroundTask = BackgroundTask(application: application)
        backgroundTask.begin()
        handler(backgroundTask)
    }

    func begin() {
        self.identifier = application.beginBackgroundTaskWithExpirationHandler {
            self.end()
        }
    }

    func end() {
        if (identifier != UIBackgroundTaskInvalid) {
            application.endBackgroundTask(identifier)
        }

        identifier = UIBackgroundTaskInvalid
    }
}

La forma más sencilla de utilizarlo:

BackgroundTask.run(application) { backgroundTask in
   // Do something
   backgroundTask.end()
}

Si necesita esperar una devolución de llamada de delegado antes de finalizar, use algo como esto:

class MyClass {
    backgroundTask: BackgroundTask?

    func doSomething() {
        backgroundTask = BackgroundTask(application)
        backgroundTask!.begin()
        // Do something that waits for callback
    }

    func callback() {
        backgroundTask?.end()
        backgroundTask = nil
    } 
}

Como se indica aquí y en las respuestas a otras preguntas de SO, NO desea usar beginBackgroundTasksolo cuando su aplicación pasará a segundo plano; por el contrario, se debe utilizar una tarea de fondo para cualquier operación que consume tiempo cuya finalización desea asegurarse incluso si la aplicación no entra en el fondo.

Por lo tanto, es probable que su código termine salpicado de repeticiones del mismo código repetitivo para llamar beginBackgroundTasky de forma endBackgroundTaskcoherente. Para evitar esta repetición, es ciertamente razonable querer empaquetar el texto estándar en una sola entidad encapsulada.

Me gustan algunas de las respuestas existentes para hacer eso, pero creo que la mejor manera es usar una subclase de Operación:

• Puede poner la operación en cola en cualquier OperationQueue y manipular esa cola como mejor le parezca. Por ejemplo, puede cancelar prematuramente cualquier operación existente en la cola.

• Si tiene más de una cosa que hacer, puede encadenar varias operaciones de tareas en segundo plano. Dependencias de soporte de operaciones.

• Operation Queue puede (y debe) ser una cola en segundo plano; por lo tanto, no hay necesidad de preocuparse por realizar código asincrónico dentro de su tarea, porque la Operación es el código asincrónico. (De hecho, no tiene sentido ejecutar otro nivel de código asincrónico dentro de una Operación, ya que la Operación terminaría antes de que ese código pudiera siquiera comenzar. Si necesitara hacer eso, usaría otra Operación).

Aquí hay una posible subclase de Operación:

class BackgroundTaskOperation: Operation {
    var whatToDo : (() -> ())?
    var cleanup : (() -> ())?
    override func main() {
        guard !self.isCancelled else { return }
        guard let whatToDo = self.whatToDo else { return }
        var bti : UIBackgroundTaskIdentifier = .invalid
        bti = UIApplication.shared.beginBackgroundTask {
            self.cleanup?()
            self.cancel()
            UIApplication.shared.endBackgroundTask(bti) // cancellation
        }
        guard bti != .invalid else { return }
        whatToDo()
        guard !self.isCancelled else { return }
        UIApplication.shared.endBackgroundTask(bti) // completion
    }
}

Debería ser obvio cómo usar esto, pero en caso de que no lo sea, imagine que tenemos una OperationQueue global:

let backgroundTaskQueue : OperationQueue = {
    let q = OperationQueue()
    q.maxConcurrentOperationCount = 1
    return q
}()

Entonces, para un lote de código típico que consume mucho tiempo, diríamos:

let task = BackgroundTaskOperation()
task.whatToDo = {
    // do something here
}
backgroundTaskQueue.addOperation(task)

Si su lote de código que consume mucho tiempo se puede dividir en etapas, es posible que desee retirarse antes si se cancela su tarea. En ese caso, simplemente regrese prematuramente del cierre. Tenga en cuenta que su referencia a la tarea desde dentro del cierre debe ser débil o obtendrá un ciclo de retención. Aquí hay una ilustración artificial:

let task = BackgroundTaskOperation()
task.whatToDo = { [weak task] in
    guard let task = task else {return}
    for i in 1...10000 {
        guard !task.isCancelled else {return}
        for j in 1...150000 {
            let k = i*j
        }
    }
}
backgroundTaskQueue.addOperation(task)

En caso de que tenga que hacer una limpieza en caso de que la tarea en segundo plano se cancele prematuramente, proporcioné una cleanuppropiedad de controlador opcional (no se usa en los ejemplos anteriores). Algunas otras respuestas fueron criticadas por no incluir eso.

Implementé la solución de Joel. Aquí está el código completo:

Archivo .h:

#import <Foundation/Foundation.h>

@interface VMKBackgroundTaskManager : NSObject

+ (id) sharedTasks;

- (NSUInteger)beginTask;
- (NSUInteger)beginTaskWithCompletionHandler:(CompletionBlock)_completion;
- (void)endTaskWithKey:(NSUInteger)_key;

@end

Archivo .m:

#import "VMKBackgroundTaskManager.h"

@interface VMKBackgroundTaskManager()

@property NSUInteger taskKeyCounter;
@property NSMutableDictionary *dictTaskIdentifiers;
@property NSMutableDictionary *dictTaskCompletionBlocks;

@end


@implementation VMKBackgroundTaskManager

+ (id)sharedTasks {
    static VMKBackgroundTaskManager *sharedTasks = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedTasks = [[self alloc] init];
    });
    return sharedTasks;
}

- (id)init
{
    self = [super init];
    if (self) {

        [self setTaskKeyCounter:0];
        [self setDictTaskIdentifiers:[NSMutableDictionary dictionary]];
        [self setDictTaskCompletionBlocks:[NSMutableDictionary dictionary]];
    }
    return self;
}

- (NSUInteger)beginTask
{
    return [self beginTaskWithCompletionHandler:nil];
}

- (NSUInteger)beginTaskWithCompletionHandler:(CompletionBlock)_completion;
{
    //read the counter and increment it
    NSUInteger taskKey;
    @synchronized(self) {

        taskKey = self.taskKeyCounter;
        self.taskKeyCounter++;

    }

    //tell the OS to start a task that should continue in the background if needed
    NSUInteger taskId = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{
        [self endTaskWithKey:taskKey];
    }];

    //add this task identifier to the active task dictionary
    [self.dictTaskIdentifiers setObject:[NSNumber numberWithUnsignedLong:taskId] forKey:[NSNumber numberWithUnsignedLong:taskKey]];

    //store the completion block (if any)
    if (_completion) [self.dictTaskCompletionBlocks setObject:_completion forKey:[NSNumber numberWithUnsignedLong:taskKey]];

    //return the dictionary key
    return taskKey;
}

- (void)endTaskWithKey:(NSUInteger)_key
{
    @synchronized(self.dictTaskCompletionBlocks) {

        //see if this task has a completion block
        CompletionBlock completion = [self.dictTaskCompletionBlocks objectForKey:[NSNumber numberWithUnsignedLong:_key]];
        if (completion) {

            //run the completion block and remove it from the completion block dictionary
            completion();
            [self.dictTaskCompletionBlocks removeObjectForKey:[NSNumber numberWithUnsignedLong:_key]];

        }

    }

    @synchronized(self.dictTaskIdentifiers) {

        //see if this task has been ended yet
        NSNumber *taskId = [self.dictTaskIdentifiers objectForKey:[NSNumber numberWithUnsignedLong:_key]];
        if (taskId) {

            //end the task and remove it from the active task dictionary
            [[UIApplication sharedApplication] endBackgroundTask:[taskId unsignedLongValue]];
            [self.dictTaskIdentifiers removeObjectForKey:[NSNumber numberWithUnsignedLong:_key]];

            NSLog(@"Task ended");
        }

    }
}

@end