Ricevi una notifica quando NSOperationQueue termina tutte le attività

NSOperationQueueha waitUntilAllOperationsAreFinished, ma non voglio aspettare in modo sincrono. Voglio solo nascondere l'indicatore di avanzamento nell'interfaccia utente al termine della coda.

Qual è il modo migliore per farlo?

Non posso inviare notifiche dai miei NSOperation, perché non so quale sarà l'ultima e [queue operations]potrebbe non essere ancora vuota (o peggio - ripopolata) quando la notifica viene ricevuta.

Usa KVO per osservare la operationsproprietà della tua coda, quindi puoi sapere se la tua coda è stata completata controllando [queue.operations count] == 0.

Da qualche parte nel file in cui stai eseguendo il KVO, dichiara un contesto per KVO come questo ( maggiori informazioni ):

static NSString *kQueueOperationsChanged = @"kQueueOperationsChanged";

Quando imposti la coda, fai questo:

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

Quindi fallo nel tuo 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];
    }
}

(Questo presuppone che tu NSOperationQueuesia in una proprietà denominata queue)

Ad un certo punto prima che il tuo oggetto si deallochi completamente (o quando smette di preoccuparsi dello stato della coda), dovrai annullare la registrazione da KVO in questo modo:

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

Addendum: iOS 4.0 ha una NSOperationQueue.operationCountproprietà, che secondo i documenti è conforme a KVO. Questa risposta funzionerà comunque in iOS 4.0, quindi è ancora utile per la compatibilità con le versioni precedenti.

Se ti aspetti (o desideri) qualcosa che corrisponda a questo 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>

È necessario essere consapevoli del fatto che se una serie di operazioni "brevi" vengono aggiunte a una coda, è possibile invece vedere questo comportamento (perché le operazioni vengono avviate come parte dell'aggiunta alla coda):

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>

Nel mio progetto avevo bisogno di sapere quando l'ultima operazione è stata completata, dopo che un gran numero di operazioni era stato aggiunto a un NSOperationQueue seriale (cioè, maxConcurrentOperationCount = 1) e solo quando erano state tutte completate.

Cercando su Google ho trovato questa affermazione di uno sviluppatore Apple in risposta alla domanda "is a serial NSoperationQueue FIFO?" -

Se tutte le operazioni hanno la stessa priorità (che non viene modificata dopo che l'operazione è stata aggiunta a una coda) e tutte le operazioni sono sempre - isReady == YES nel momento in cui vengono inserite nella coda delle operazioni, allora una NSOperationQueue seriale è FIFO.

Chris Kane Cocoa Frameworks, Apple

Nel mio caso è possibile sapere quando l'ultima operazione è stata aggiunta alla coda. Quindi, dopo che l'ultima operazione è stata aggiunta, aggiungo un'altra operazione alla coda, di priorità inferiore, che non fa altro che inviare la notifica che la coda è stata svuotata. Data la dichiarazione di Apple, ciò garantisce che venga inviato un solo avviso solo dopo che tutte le operazioni sono state completate.

Se le operazioni vengono aggiunte in un modo che non consente di rilevare l'ultima, (cioè, non deterministica), allora penso che tu debba andare con gli approcci KVO sopra menzionati, con una logica di guardia aggiuntiva aggiunta per provare a rilevare se ulteriormente possono essere aggiunte operazioni.

:)

Che ne dici di aggiungere un'operazione NSO che dipende da tutte le altre in modo che venga eseguita per ultima?

Un'alternativa è usare GCD. Fare riferimento a questo come riferimento.

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

Ecco come lo faccio.

Imposta la coda e registrati per le modifiche nella proprietà delle operazioni:

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

... e l'osservatore (in questo 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;
}

In questo esempio "spinner" UIActivityIndicatorViewmostra che sta succedendo qualcosa. Ovviamente puoi cambiare a tuo piacimento ...

Sto usando una categoria per farlo.

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

Utilizzo :

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

Come di iOS 13.0 , le proprietà operationCount e operation sono deprecate. È altrettanto semplice tenere traccia del numero di operazioni nella coda e attivare una notifica quando sono state completate tutte. Questo esempio funziona anche con una sottoclasse asincrona di 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
    }
}

Di seguito è una sottoclasse di Operazione per operazioni asincrone facili

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

}

Che ne dici di usare KVO per osservare la operationCountproprietà della coda? Allora ne sentiresti parlare quando la coda si è svuotata e anche quando ha smesso di essere vuota. Gestire l'indicatore di progresso potrebbe essere semplice come fare qualcosa come:

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

Aggiungi l'ultima operazione come:

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

Così:

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

}

Con ReactiveObjC trovo che funzioni bene:

// 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!");
    }
}];

Cordiali saluti, puoi raggiungere questo obiettivo con GCD dispatch_group in swift 3 . Puoi ricevere una notifica quando tutte le attività sono terminate.

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

Puoi crearne uno nuovo NSThreado eseguire un selettore in background e attendere lì. Al NSOperationQueuetermine, puoi inviare una tua notifica.

Sto pensando a qualcosa come:

- (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 utilizzi questa operazione come classe base, potresti passare il whenEmpty {}blocco a OperationQueue :

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

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

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

Senza 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 sei arrivato qui alla ricerca di una soluzione con la mietitrebbia, ho finito per ascoltare il mio oggetto di stato.

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

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