Receba uma notificação quando NSOperationQueue terminar todas as tarefas

NSOperationQueuetem waitUntilAllOperationsAreFinished, mas não quero esperar sincronizadamente por isso. Eu só quero ocultar o indicador de progresso na interface do usuário quando a fila terminar.

Qual é a melhor maneira de fazer isso?

Não posso enviar notificações do meu NSOperations, porque não sei qual vai ser a última, e [queue operations]posso não estar vazio ainda (ou pior - preenchido novamente) quando a notificação for recebida.

Use KVO para observar a operationspropriedade de sua fila, então você pode saber se sua fila foi concluída verificando [queue.operations count] == 0.

Em algum lugar do arquivo em que você está fazendo o KVO, declare um contexto para o KVO como este ( mais informações ):

static NSString *kQueueOperationsChanged = @"kQueueOperationsChanged";

Ao configurar sua fila, faça o seguinte:

[self.queue addObserver:self forKeyPath:@"operations" options:0 context:&kQueueOperationsChanged];

Então faça isso no seu observeValueForKeyPath:

- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object 
                         change:(NSDictionary *)change context:(void *)context
{
    if (object == self.queue && [keyPath isEqualToString:@"operations"] && context == &kQueueOperationsChanged) {
        if ([self.queue.operations count] == 0) {
            // Do something here when your queue has completed
            NSLog(@"queue has completed");
        }
    }
    else {
        [super observeValueForKeyPath:keyPath ofObject:object 
                               change:change context:context];
    }
}

(Isso pressupõe que você NSOperationQueueestá em uma propriedade chamada queue)

Em algum ponto antes de seu objeto ser totalmente desalocado (ou quando ele parar de se preocupar com o estado da fila), você precisará cancelar o registro do KVO desta forma:

[self.queue removeObserver:self forKeyPath:@"operations" context:&kQueueOperationsChanged];

Adendo: iOS 4.0 possui uma NSOperationQueue.operationCountpropriedade que, de acordo com os documentos, é compatível com KVO. Essa resposta ainda funcionará no iOS 4.0, portanto, ainda é útil para compatibilidade com versões anteriores.

Se você está esperando (ou deseja) algo que corresponda a este comportamento:

t=0 add an operation to the queue.  queueucount increments to 1
t=1 add an operation to the queue.  queueucount increments to 2
t=2 add an operation to the queue.  queueucount increments to 3
t=3 operation completes, queuecount decrements to 2
t=4 operation completes, queuecount decrements to 1
t=5 operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>

Você deve estar ciente de que, se várias operações "curtas" estiverem sendo adicionadas a uma fila, você poderá ver este comportamento (porque as operações são iniciadas como parte da adição à fila):

t=0  add an operation to the queue.  queuecount == 1
t=1  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>
t=2  add an operation to the queue.  queuecount == 1
t=3  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>
t=4  add an operation to the queue.  queuecount == 1
t=5  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>

Em meu projeto, eu precisava saber quando a última operação foi concluída, depois que um grande número de operações foi adicionado a um NSOperationQueue serial (ou seja, maxConcurrentOperationCount = 1) e somente quando todas foram concluídas.

Pesquisando no Google, encontrei esta declaração de um desenvolvedor da Apple em resposta à pergunta "is a serial NSoperationQueue FIFO?" -

Se todas as operações têm a mesma prioridade (que não é alterada depois que a operação é adicionada a uma fila) e todas as operações são sempre - isReady == YES no momento em que são colocadas na fila de operações, então um NSOperationQueue serial é FIFO.

Chris Kane Cocoa Frameworks, Apple

No meu caso é possível saber quando a última operação foi adicionada à fila. Então, depois que a última operação é adicionada, eu adiciono outra operação à fila, de menor prioridade, que não faz nada além de enviar a notificação de que a fila foi esvaziada. De acordo com a declaração da Apple, isso garante que apenas um único aviso seja enviado somente após a conclusão de todas as operações.

Se as operações estão sendo adicionadas de uma maneira que não permite detectar a última (ou seja, não determinística), então eu acho que você deve ir com as abordagens KVO mencionadas acima, com lógica de guarda adicional adicionada para tentar detectar se mais operações podem ser adicionadas.

:)

Que tal adicionar uma operação NSO que é dependente de todas as outras para que seja executada por último?

Uma alternativa é usar o GCD. Consulte isso como referência.

dispatch_queue_t queue = dispatch_get_global_queue(0,0);
dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group,queue,^{
 NSLog(@"Block 1");
 //run first NSOperation here
});

dispatch_group_async(group,queue,^{
 NSLog(@"Block 2");
 //run second NSOperation here
});

//or from for loop
for (NSOperation *operation in operations)
{
   dispatch_group_async(group,queue,^{
      [operation start];
   });
}

dispatch_group_notify(group,queue,^{
 NSLog(@"Final block");
 //hide progress indicator here
});

É assim que eu faço.

Configure a fila e registre-se para alterações na propriedade de operações:

myQueue = [[NSOperationQueue alloc] init];
[myQueue addObserver: self forKeyPath: @"operations" options: NSKeyValueObservingOptionNew context: NULL];

... e o observador (neste caso self) implementa:

- (void) observeValueForKeyPath:(NSString *) keyPath ofObject:(id) object change:(NSDictionary *) change context:(void *) context {

    if (
        object == myQueue
        &&
        [@"operations" isEqual: keyPath]
    ) {

        NSArray *operations = [change objectForKey:NSKeyValueChangeNewKey];

        if ( [self hasActiveOperations: operations] ) {
            [spinner startAnimating];
        } else {
            [spinner stopAnimating];
        }
    }
}

- (BOOL) hasActiveOperations:(NSArray *) operations {
    for ( id operation in operations ) {
        if ( [operation isExecuting] && ! [operation isCancelled] ) {
            return YES;
        }
    }

    return NO;
}

Neste exemplo, "spinner" UIActivityIndicatorViewmostra que algo está acontecendo. Obviamente, você pode mudar para se adequar ...

Estou usando uma categoria para fazer isso.

NSOperationQueue + Completion.h

//
//  NSOperationQueue+Completion.h
//  QueueTest
//
//  Created by Artem Stepanenko on 23.11.13.
//  Copyright (c) 2013 Artem Stepanenko. All rights reserved.
//

typedef void (^NSOperationQueueCompletion) (void);

@interface NSOperationQueue (Completion)

/**
 * Remarks:
 *
 * 1. Invokes completion handler just a single time when previously added operations are finished.
 * 2. Completion handler is called in a main thread.
 */

- (void)setCompletion:(NSOperationQueueCompletion)completion;

@end

NSOperationQueue + Completion.m

//
//  NSOperationQueue+Completion.m
//  QueueTest
//
//  Created by Artem Stepanenko on 23.11.13.
//  Copyright (c) 2013 Artem Stepanenko. All rights reserved.
//

#import "NSOperationQueue+Completion.h"

@implementation NSOperationQueue (Completion)

- (void)setCompletion:(NSOperationQueueCompletion)completion
{
    NSOperationQueueCompletion copiedCompletion = [completion copy];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self waitUntilAllOperationsAreFinished];

        dispatch_async(dispatch_get_main_queue(), ^{
            copiedCompletion();
        });
    });
}

@end

Uso :

NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    // ...
}];

NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    // ...
}];

[operation2 addDependency:operation1];

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperations:@[operation1, operation2] waitUntilFinished:YES];

[queue setCompletion:^{
    // handle operation queue's completion here (launched in main thread!)
}];

Fonte: https://gist.github.com/artemstepanenko/7620471

Como de iOS 13,0 , o operationCount e operação propriedades estão obsoletos. É muito simples controlar o número de operações em sua fila e disparar uma Notificação quando todas elas forem concluídas. Este exemplo também funciona com uma subclasse assíncrona de Operation .

class MyOperationQueue: OperationQueue {
            
    public var numberOfOperations: Int = 0 {
        didSet {
            if numberOfOperations == 0 {
                print("All operations completed.")
                
                NotificationCenter.default.post(name: .init("OperationsCompleted"), object: nil)
            }
        }
    }
    
    public var isEmpty: Bool {
        return numberOfOperations == 0
    }
    
    override func addOperation(_ op: Operation) {
        super.addOperation(op)
        
        numberOfOperations += 1
    }
    
    override func addOperations(_ ops: [Operation], waitUntilFinished wait: Bool) {
        super.addOperations(ops, waitUntilFinished: wait)
        
        numberOfOperations += ops.count
    }
    
    public func decrementOperationCount() {
        numberOfOperations -= 1
    }
}

Abaixo está uma subclasse de Operação para operações assíncronas fáceis

class AsyncOperation: Operation {
    
    let queue: MyOperationQueue

enum State: String {
    case Ready, Executing, Finished
    
    fileprivate var keyPath: String {
        return "is" + rawValue
    }
}

var state = State.Ready {
    willSet {
        willChangeValue(forKey: newValue.keyPath)
        willChangeValue(forKey: state.keyPath)
    }
    
    didSet {
        didChangeValue(forKey: oldValue.keyPath)
        didChangeValue(forKey: state.keyPath)
        
        if state == .Finished {
            queue.decrementOperationCount()
        }
    }
}

override var isReady: Bool {
    return super.isReady && state == .Ready
}

override var isExecuting: Bool {
    return state == .Executing
}

override var isFinished: Bool {
    return state == .Finished
}

override var isAsynchronous: Bool {
    return true
}

public init(queue: MyOperationQueue) {
    self.queue = queue
    super.init()
}

override func start() {
    if isCancelled {
        state = .Finished
        return
    }
    
    main()
    state = .Executing
}

override func cancel() {
    state = .Finished
}

override func main() {
    fatalError("Subclasses must override main without calling super.")
}

}

Que tal usar KVO para observar a operationCountpropriedade da fila? Então, você ouviria quando a fila esvaziasse e também quando ela parasse de esvaziar. Lidar com o indicador de progresso pode ser tão simples quanto fazer algo como:

[indicator setHidden:([queue operationCount]==0)]

Adicione a última operação como:

NSInvocationOperation *callbackOperation = [[NSInvocationOperation alloc] initWithTarget:object selector:selector object:nil];

Assim:

- (void)method:(id)object withSelector:(SEL)selector{
     NSInvocationOperation *callbackOperation = [[NSInvocationOperation alloc] initWithTarget:object selector:selector object:nil];
     [callbackOperation addDependency: ...];
     [operationQueue addOperation:callbackOperation]; 

}

Com ReactiveObjC acho que isso funciona muito bem:

// skip 1 time here to ignore the very first call which occurs upon initialization of the RAC block
[[RACObserve(self.operationQueue, operationCount) skip:1] subscribeNext:^(NSNumber *operationCount) {
    if ([operationCount integerValue] == 0) {
         // operations are done processing
         NSLog(@"Finished!");
    }
}];

Para sua informação, você pode conseguir isso com GCD dispatch_group no swift 3 . Você pode ser notificado quando todas as tarefas forem concluídas.

let group = DispatchGroup()

    group.enter()
    run(after: 6) {
      print(" 6 seconds")
      group.leave()
    }

    group.enter()
    run(after: 4) {
      print(" 4 seconds")
      group.leave()
    }

    group.enter()
    run(after: 2) {
      print(" 2 seconds")
      group.leave()
    }

    group.enter()
    run(after: 1) {
      print(" 1 second")
      group.leave()
    }


    group.notify(queue: DispatchQueue.global(qos: .background)) {
      print("All async calls completed")
}

Você pode criar um novo NSThreadou executar um seletor em segundo plano e aguardar lá. Quando NSOperationQueueterminar, você mesmo pode enviar uma notificação.

Estou pensando em algo como:

- (void)someMethod {
    // Queue everything in your operationQueue (instance variable)
    [self performSelectorInBackground:@selector(waitForQueue)];
    // Continue as usual
}

...

- (void)waitForQueue {
    [operationQueue waitUntilAllOperationsAreFinished];
    [[NSNotificationCenter defaultCenter] postNotification:@"queueFinished"];
}

Se você usar esta Operação como sua classe base, poderá passar o whenEmpty {}bloco para OperationQueue :

let queue = OOperationQueue()
queue.addOperation(op)
queue.addOperation(delayOp)

queue.addExecution { finished in
    delay(0.5) { finished() }
}

queue.whenEmpty = {
    print("all operations finished")
}

Sem KVO

private let queue = OperationQueue()

private func addOperations(_ operations: [Operation], completionHandler: @escaping () -> ()) {
    DispatchQueue.global().async { [unowned self] in
        self.queue.addOperations(operations, waitUntilFinished: true)
        DispatchQueue.main.async(execute: completionHandler)
    }
}

Se você chegou aqui procurando uma solução com combine - acabei ouvindo apenas meu próprio objeto de estado.

@Published var state: OperationState = .ready
var sub: Any?

sub = self.$state.sink(receiveValue: { (state) in
 print("state updated: \(state)")
})