Comment savoir que UICollectionView a été complètement chargé?

Je dois faire une opération chaque fois que UICollectionView a été complètement chargé, c'est-à-dire qu'à ce moment-là, toutes les méthodes de source de données / disposition de UICollectionView doivent être appelées. Comment sais-je ça ?? Existe-t-il une méthode déléguée pour connaître l'état chargé de 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];
}

Cela a fonctionné pour moi:

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

Syntaxe Swift 4:

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

C'est en fait plutôt très simple.

Lorsque vous appelez par exemple la méthode reloadData de UICollectionView ou la méthode invalidateLayout de la disposition, vous procédez comme suit:

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

Pourquoi cela fonctionne:

Le thread principal (où nous devons faire toutes les mises à jour de l'interface utilisateur) héberge la file d'attente principale, qui est de nature série, c'est-à-dire qu'elle fonctionne à la manière FIFO. Ainsi, dans l'exemple ci-dessus, le premier bloc est appelé, ce qui fait que notre reloadDataméthode est invoquée, suivi de tout autre élément dans le deuxième bloc.

Maintenant, le thread principal se bloque également. Donc, si vous prenez reloadData3s pour s'exécuter, le traitement du deuxième bloc sera différé de ces 3s.

Juste pour ajouter à une excellente réponse @dezinezync:

Swift 3+

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

Fais-le comme ça:

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

Essayez de forcer une mise en page synchrone via layoutIfNeeded () juste après l'appel reloadData (). Semble fonctionner à la fois pour UICollectionView et UITableView sur iOS 12.

collectionView.reloadData()
collectionView.layoutIfNeeded() 

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

Comme dezinezync a répondu, ce dont vous avez besoin est d'envoyer à la file d'attente principale un bloc de code après reloadDataun UITableViewou UICollectionView, puis ce bloc sera exécuté après le retrait des cellules.

Afin de rendre cela plus clair lors de l'utilisation, j'utiliserais une extension comme celle-ci:

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

Il peut également être mis en œuvre à un UITableViewaussi bien

Une approche différente en utilisant RxSwift / RxCocoa:

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

Cela fonctionne pour moi:

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

J'avais besoin d'une action à faire sur toutes les cellules visibles lorsque la vue de la collection est chargée avant qu'elle ne soit visible pour l'utilisateur, j'ai utilisé:

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

Faites attention que cela sera appelé lors du défilement dans la vue de la collection, donc pour éviter cette surcharge, j'ai ajouté:

private var souldPerformAction: Bool = true

et dans l'action elle-même:

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

L'action sera toujours exécutée plusieurs fois, comme le nombre de cellules visibles à l'état initial. mais sur tous ces appels, vous aurez le même nombre de cellules visibles (toutes). Et l'indicateur booléen l'empêchera de s'exécuter à nouveau une fois que l'utilisateur a commencé à interagir avec la vue de collection.

J'ai juste fait ce qui suit pour effectuer quoi que ce soit après le rechargement de la vue de collection. Vous pouvez utiliser ce code même dans la réponse API.

self.collectionView.reloadData()

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

La meilleure solution que j'ai trouvée jusqu'à présent est de l'utiliser CATransactionpour gérer l'achèvement.

Swift 5 :

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

collectionView.reloadData()

CATransaction.commit()

Def faites ceci:

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

}

Puis appelez comme ça dans votre VC

let collection = MyCollectionView()

self.collection.reloadData(completion: {

})

Assurez-vous que vous utilisez la sous-classe !!

Ce travail pour moi:

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

}

Rechargez simplement collectionView à l'intérieur des mises à jour par lots, puis vérifiez dans le bloc de complétion s'il est terminé ou non à l'aide du booléen "finish".

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

Voici la seule approche qui a fonctionné pour moi.

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

Voici comment j'ai résolu le problème avec Swift 3.0:

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

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

Essaye ça:

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

Vous pouvez faire comme ça ...

  - (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.

    }