Come faccio a sapere che UICollectionView è stato caricato completamente?

Devo fare qualche operazione ogni volta che UICollectionView è stato caricato completamente, cioè in quel momento dovrebbero essere chiamati tutti i metodi datasource / layout di UICollectionView. Come lo so? Esiste un metodo delegato per conoscere lo stato di caricamento di UICollectionView?

// In viewDidLoad
[self.collectionView addObserver:self forKeyPath:@"contentSize" options:NSKeyValueObservingOptionOld context:NULL];

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary  *)change context:(void *)context
{
    // You will get here when the reloadData finished 
}

- (void)dealloc
{
    [self.collectionView removeObserver:self forKeyPath:@"contentSize" context:NULL];
}

Questo ha funzionato per me:

[self.collectionView reloadData];
[self.collectionView performBatchUpdates:^{}
                              completion:^(BOOL finished) {
                                  /// collection-view finished reload
                              }];

Sintassi di Swift 4:

self.collectionView.reloadData()
self.collectionView.performBatchUpdates(nil, completion: {
    (result) in
    // ready
})

In realtà è piuttosto molto semplice.

Quando ad esempio chiami il metodo reloadData di UICollectionView o il metodo invalidateLayout del layout, fai quanto segue:

dispatch_async(dispatch_get_main_queue(), ^{
    [self.collectionView reloadData];
});

dispatch_async(dispatch_get_main_queue(), ^{
    //your stuff happens here
    //after the reloadData/invalidateLayout finishes executing
});

Perché funziona:

Il thread principale (che è dove dovremmo fare tutti gli aggiornamenti dell'interfaccia utente) ospita la coda principale, che è di natura seriale, cioè funziona in modo FIFO. Quindi, nell'esempio precedente, viene chiamato il primo blocco, che ha il nostro reloadDatametodo invocato, seguito da qualsiasi altra cosa nel secondo blocco.

Ora anche il thread principale si sta bloccando. Quindi, se sono reloadDatanecessari 3 secondi per l'esecuzione, l'elaborazione del secondo blocco verrà differita di quei 3 secondi.

Solo per aggiungere a un'ottima risposta @dezinezync:

Swift 3+

collectionView.collectionViewLayout.invalidateLayout() // or reloadData()
DispatchQueue.main.async {
    // your stuff here executing after collectionView has been layouted
}

Fai cosi:

       UIView.animateWithDuration(0.0, animations: { [weak self] in
                guard let strongSelf = self else { return }

                strongSelf.collectionView.reloadData()

            }, completion: { [weak self] (finished) in
                guard let strongSelf = self else { return }

                // Do whatever is needed, reload is finished here
                // e.g. scrollToItemAtIndexPath
                let newIndexPath = NSIndexPath(forItem: 1, inSection: 0)
                strongSelf.collectionView.scrollToItemAtIndexPath(newIndexPath, atScrollPosition: UICollectionViewScrollPosition.Left, animated: false)
        })

Prova a forzare un passaggio di layout sincrono tramite layoutIfNeeded () subito dopo la chiamata reloadData (). Sembra funzionare sia per UICollectionView che per UITableView su iOS 12.

collectionView.reloadData()
collectionView.layoutIfNeeded() 

// cellForItem/sizeForItem calls should be complete
completion?()

Come ha risposto dezinezync , ciò di cui hai bisogno è inviare alla coda principale un blocco di codice dopo reloadDatada un UITableViewor UICollectionView, e quindi questo blocco verrà eseguito dopo l'annullamento dell'accodamento delle celle

Per renderlo più diretto durante l'utilizzo, utilizzerei un'estensione come questa:

extension UICollectionView {
    func reloadData(_ completion: @escaping () -> Void) {
        reloadData()
        DispatchQueue.main.async { completion() }
    }
}

Può essere implementato anche ad una UITableViewcosì

Un approccio diverso utilizzando RxSwift / RxCocoa:

        collectionView.rx.observe(CGSize.self, "contentSize")
            .subscribe(onNext: { size in
                print(size as Any)
            })
            .disposed(by: disposeBag)

Questo funziona per me:

__weak typeof(self) wself= self;
[self.contentCollectionView performBatchUpdates:^{
    [wself.contentCollectionView reloadData];
} completion:^(BOOL finished) {
    [wself pageViewCurrentIndexDidChanged:self.contentCollectionView];
}];

Avevo bisogno di un'azione da fare su tutte le celle visibili quando la vista della raccolta viene caricata prima che sia visibile all'utente, ho usato:

public func collectionView(_ collectionView: UICollectionView, willDisplay cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    if shouldPerformBatch {
        self.collectionView.performBatchUpdates(nil) { completed in
            self.modifyVisibleCells()
        }
    }
}

Fai attenzione che questo verrà chiamato durante lo scorrimento della visualizzazione della raccolta, quindi per evitare questo sovraccarico, ho aggiunto:

private var souldPerformAction: Bool = true

e nell'azione stessa:

private func modifyVisibleCells() {
    if self.shouldPerformAction {
        // perform action
        ...
        ...
    }
    self.shouldPerformAction = false
}

L'azione verrà comunque eseguita più volte, come il numero di celle visibili nello stato iniziale. ma su tutte queste chiamate, avrai lo stesso numero di celle visibili (tutte). E il flag booleano ne impedirà l'esecuzione di nuovo dopo che l'utente ha iniziato a interagire con la vista della raccolta.

Ho appena fatto quanto segue per eseguire qualsiasi cosa dopo aver ricaricato la visualizzazione della raccolta. Puoi utilizzare questo codice anche nella risposta API.

self.collectionView.reloadData()

DispatchQueue.main.async {
   // Do Task after collection view is reloaded                
}

La soluzione migliore che ho trovato finora è quella di utilizzare CATransactionper gestire il completamento.

Swift 5 :

CATransaction.begin()
CATransaction.setCompletionBlock {
    // UICollectionView is ready
}

collectionView.reloadData()

CATransaction.commit()

Sicuramente fai questo:

//Subclass UICollectionView
class MyCollectionView: UICollectionView {

    //Store a completion block as a property
    var completion: (() -> Void)?

    //Make a custom funciton to reload data with a completion handle
    func reloadData(completion: @escaping() -> Void) {
        //Set the completion handle to the stored property
        self.completion = completion
        //Call super
        super.reloadData()
    }

    //Override layoutSubviews
    override func layoutSubviews() {
        //Call super
        super.layoutSubviews()
        //Call the completion
        self.completion?()
        //Set the completion to nil so it is reset and doesn't keep gettign called
        self.completion = nil
    }

}

Quindi chiama in questo modo all'interno del tuo VC

let collection = MyCollectionView()

self.collection.reloadData(completion: {

})

Assicurati di utilizzare la sottoclasse !!

Questo lavoro per me:

- (void)viewDidLoad {
    [super viewDidLoad];

    int ScrollToIndex = 4;

    [self.UICollectionView performBatchUpdates:^{}
                                    completion:^(BOOL finished) {
                                             NSIndexPath *indexPath = [NSIndexPath indexPathForItem:ScrollToIndex inSection:0];
                                             [self.UICollectionView scrollToItemAtIndexPath:indexPath atScrollPosition:UICollectionViewScrollPositionCenteredHorizontally animated:NO];
                                  }];

}

Ricarica semplicemente collectionView all'interno degli aggiornamenti batch e poi controlla nel blocco di completamento se è finito o meno con l'aiuto di booleano "finish".

self.collectionView.performBatchUpdates({
        self.collectionView.reloadData()
    }) { (finish) in
        if finish{
            // Do your stuff here!
        }
    }

Di seguito è riportato l'unico approccio che ha funzionato per me.

extension UICollectionView {
    func reloadData(_ completion: (() -> Void)? = nil) {
        reloadData()
        guard let completion = completion else { return }
        layoutIfNeeded()
        completion()
    }
}

Ecco come ho risolto il problema con Swift 3.0:

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    if !self.collectionView.visibleCells.isEmpty {
        // stuff
    }
}

Prova questo:

- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section
{
    return _Items.count;
}

- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath
{
    UICollectionViewCell *cell;
    //Some cell stuff here...

    if(indexPath.row == _Items.count-1){
       //THIS IS THE LAST CELL, SO TABLE IS LOADED! DO STUFF!
    }

    return cell;
}

Puoi fare così ...

  - (void)reloadMyCollectionView{

       [myCollectionView reload];
       [self performSelector:@selector(myStuff) withObject:nil afterDelay:0.0];

   }

  - (void)myStuff{
     // Do your stuff here. This will method will get called once your collection view get loaded.

    }