UICollectionView reloadData ne fonctionne pas correctement sous iOS 7

J'ai mis à jour mes applications pour qu'elles fonctionnent sur iOS 7, ce qui se passe bien pour la plupart. J'ai remarqué dans plus d'une application que la reloadDataméthode de a UICollectionViewControllern'agit pas comme avant.

Je vais charger le UICollectionViewController, remplir le UICollectionViewavec des données comme d'habitude. Cela fonctionne très bien la première fois. Cependant, si je demande de nouvelles données (remplissez le UICollectionViewDataSource), puis que j'appelle reloadData, il interrogera la source de données pour numberOfItemsInSectionet numberOfSectionsInCollectionView, mais il ne semble pas appeler cellForItemAtIndexPathle bon nombre de fois.

Si je change le code pour ne recharger qu'une seule section, cela fonctionnera correctement. Ce n'est pas un problème pour moi de les changer, mais je ne pense pas que je devrais avoir à le faire. reloadDatadevrait recharger toutes les cellules visibles selon la documentation.

Quelqu'un d'autre a-t-il vu cela?

Forcez ceci sur le thread principal:

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

Dans mon cas, le nombre de cellules / sections dans la source de données n'a jamais changé et je voulais juste recharger le contenu visible à l'écran.

J'ai réussi à contourner cela en appelant:

[self.collectionView reloadItemsAtIndexPaths:[self.collectionView indexPathsForVisibleItems]];

puis:

[self.collectionView reloadData];

J'ai eu exactement le même problème, mais j'ai réussi à trouver ce qui n'allait pas. Dans mon cas, j'appelais reloadData à partir de la collectionView: cellForItemAtIndexPath: ce qui ne semble pas être correct.

La distribution de l'appel de reloadData à la file d'attente principale a résolu le problème une fois pour toutes.

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

Le rechargement de certains éléments n'a pas fonctionné pour moi. Dans mon cas, et uniquement parce que la collectionView que j'utilise n'a qu'une seule section, je recharge simplement cette section particulière. Cette fois, le contenu est correctement rechargé. Bizarre que cela ne se produise que sur iOS 7 (7.0.3)

[self.collectionView reloadSections:[NSIndexSet indexSetWithIndex:0]];

J'ai eu le même problème avec reloadData sur iOS 7. Après une longue session de débogage, j'ai trouvé le problème.

Sur iOS7, reloadData sur UICollectionView n'annule pas les mises à jour précédentes qui ne sont pas encore terminées (mises à jour qui ont appelé à l'intérieur de performBatchUpdates: block).

La meilleure solution pour résoudre ce bogue est d'arrêter toutes les mises à jour actuellement traitées et d'appeler reloadData. Je n'ai pas trouvé de moyen d'annuler ou d'arrêter un bloc de performBatchUpdates. Par conséquent, pour résoudre le bogue, j'ai enregistré un indicateur qui indique s'il existe un bloc performBatchUpdates actuellement traité. S'il n'y a pas de bloc de mise à jour actuellement traité, je peux appeler reloadData immédiatement et tout fonctionne comme prévu. S'il y a un bloc de mise à jour qui est actuellement traité, j'appellerai reloadData sur le bloc complet de performBatchUpdates.

Swift 5 - 4 - 3

// GCD    
DispatchQueue.main.async(execute: collectionView.reloadData)

// Operation
OperationQueue.main.addOperation(collectionView.reloadData)

Swift 2

// Operation
NSOperationQueue.mainQueue().addOperationWithBlock(collectionView.reloadData)

J'ai aussi eu ce problème. Par coïncidence, j'ai ajouté un bouton au-dessus de la vue de la collection afin de forcer le rechargement pour les tests - et tout d'un coup, les méthodes ont commencé à être appelées.

Aussi simplement ajouter quelque chose d'aussi simple que

UIView *aView = [UIView new];
[collectionView addSubView:aView];

provoquerait l'appel des méthodes

J'ai aussi joué avec la taille du cadre - et voilà, les méthodes étaient appelées.

Il y a beaucoup de bogues avec iOS7 UICollectionView.

Vous pouvez utiliser cette méthode

[collectionView reloadItemsAtIndexPaths:arayOfAllIndexPaths];

Vous pouvez ajouter tous les indexPathobjets de votre UICollectionViewtableau dans arrayOfAllIndexPathsen itérant la boucle pour toutes les sections et lignes à l'aide de la méthode ci-dessous

[aray addObject:[NSIndexPath indexPathForItem:j inSection:i]];

J'espère que vous avez compris et que cela pourra résoudre votre problème. Si vous avez besoin de plus d'explications, veuillez répondre.

La solution donnée par Shaunti Fondrisi est presque parfaite. Mais un tel morceau de code ou des codes comme mettre en file d'attente l'exécution de UICollectionView's reloadData()à NSOperationQueue' mainQueuemet en effet la synchronisation d'exécution au début de la prochaine boucle d'événement dans la boucle d'exécution, ce qui pourrait rendre leUICollectionView mise à jour d'un simple coup.

Pour résoudre ce problème. Nous devons mettre le timing d'exécution du même morceau de code à la fin de la boucle d'événement en cours mais pas au début de la suivante. Et nous pouvons y parvenir en utilisant CFRunLoopObserver.

CFRunLoopObserver observe toutes les activités d'attente de la source d'entrée et l'activité d'entrée et de sortie de la boucle d'exécution.

public struct CFRunLoopActivity : OptionSetType {
    public init(rawValue: CFOptionFlags)

    public static var Entry: CFRunLoopActivity { get }
    public static var BeforeTimers: CFRunLoopActivity { get }
    public static var BeforeSources: CFRunLoopActivity { get }
    public static var BeforeWaiting: CFRunLoopActivity { get }
    public static var AfterWaiting: CFRunLoopActivity { get }
    public static var Exit: CFRunLoopActivity { get }
    public static var AllActivities: CFRunLoopActivity { get }
}

Parmi ces activités, .AfterWaitingpeut être observée lorsque la boucle d'événements en cours est sur le point de se terminer, et.BeforeWaiting peut être observée lorsque la prochaine boucle d'événements vient de commencer.

Comme il n'y a qu'une seule NSRunLoopinstance par NSThreadet NSRunLooppilote exactement le NSThread, on peut considérer que les accès proviennent du mêmeNSRunLoop instance ne traversent toujours jamais les threads.

Sur la base des points mentionnés précédemment, nous pouvons maintenant écrire le code: un répartiteur de tâches basé sur NSRunLoop:

import Foundation
import ObjectiveC

public struct Weak<T: AnyObject>: Hashable {
    private weak var _value: T?
    public weak var value: T? { return _value }
    public init(_ aValue: T) { _value = aValue }

    public var hashValue: Int {
        guard let value = self.value else { return 0 }
        return ObjectIdentifier(value).hashValue
    }
}

public func ==<T: AnyObject where T: Equatable>(lhs: Weak<T>, rhs: Weak<T>)
    -> Bool
{
    return lhs.value == rhs.value
}

public func ==<T: AnyObject>(lhs: Weak<T>, rhs: Weak<T>) -> Bool {
    return lhs.value === rhs.value
}

public func ===<T: AnyObject>(lhs: Weak<T>, rhs: Weak<T>) -> Bool {
    return lhs.value === rhs.value
}

private var dispatchObserverKey =
"com.WeZZard.Nest.NSRunLoop.TaskDispatcher.DispatchObserver"

private var taskQueueKey =
"com.WeZZard.Nest.NSRunLoop.TaskDispatcher.TaskQueue"

private var taskAmendQueueKey =
"com.WeZZard.Nest.NSRunLoop.TaskDispatcher.TaskAmendQueue"

private typealias DeallocFunctionPointer =
    @convention(c) (Unmanaged<NSRunLoop>, Selector) -> Void

private var original_dealloc_imp: IMP?

private let swizzled_dealloc_imp: DeallocFunctionPointer = {
    (aSelf: Unmanaged<NSRunLoop>,
    aSelector: Selector)
    -> Void in

    let unretainedSelf = aSelf.takeUnretainedValue()

    if unretainedSelf.isDispatchObserverLoaded {
        let observer = unretainedSelf.dispatchObserver
        CFRunLoopObserverInvalidate(observer)
    }

    if let original_dealloc_imp = original_dealloc_imp {
        let originalDealloc = unsafeBitCast(original_dealloc_imp,
            DeallocFunctionPointer.self)
        originalDealloc(aSelf, aSelector)
    } else {
        fatalError("The original implementation of dealloc for NSRunLoop cannot be found!")
    }
}

public enum NSRunLoopTaskInvokeTiming: Int {
    case NextLoopBegan
    case CurrentLoopEnded
    case Idle
}

extension NSRunLoop {

    public func perform(closure: ()->Void) -> Task {
        objc_sync_enter(self)
        loadDispatchObserverIfNeeded()
        let task = Task(self, closure)
        taskQueue.append(task)
        objc_sync_exit(self)
        return task
    }

    public override class func initialize() {
        super.initialize()

        struct Static {
            static var token: dispatch_once_t = 0
        }
        // make sure this isn't a subclass
        if self !== NSRunLoop.self {
            return
        }

        dispatch_once(&Static.token) {
            let selectorDealloc: Selector = "dealloc"
            original_dealloc_imp =
                class_getMethodImplementation(self, selectorDealloc)

            let swizzled_dealloc = unsafeBitCast(swizzled_dealloc_imp, IMP.self)

            class_replaceMethod(self, selectorDealloc, swizzled_dealloc, "@:")
        }
    }

    public final class Task {
        private let weakRunLoop: Weak<NSRunLoop>

        private var _invokeTiming: NSRunLoopTaskInvokeTiming
        private var invokeTiming: NSRunLoopTaskInvokeTiming {
            var theInvokeTiming: NSRunLoopTaskInvokeTiming = .NextLoopBegan
            guard let amendQueue = weakRunLoop.value?.taskAmendQueue else {
                fatalError("Accessing a dealloced run loop")
            }
            dispatch_sync(amendQueue) { () -> Void in
                theInvokeTiming = self._invokeTiming
            }
            return theInvokeTiming
        }

        private var _modes: NSRunLoopMode
        private var modes: NSRunLoopMode {
            var theModes: NSRunLoopMode = []
            guard let amendQueue = weakRunLoop.value?.taskAmendQueue else {
                fatalError("Accessing a dealloced run loop")
            }
            dispatch_sync(amendQueue) { () -> Void in
                theModes = self._modes
            }
            return theModes
        }

        private let closure: () -> Void

        private init(_ runLoop: NSRunLoop, _ aClosure: () -> Void) {
            weakRunLoop = Weak<NSRunLoop>(runLoop)
            _invokeTiming = .NextLoopBegan
            _modes = .defaultMode
            closure = aClosure
        }

        public func forModes(modes: NSRunLoopMode) -> Task {
            if let amendQueue = weakRunLoop.value?.taskAmendQueue {
                dispatch_async(amendQueue) { [weak self] () -> Void in
                    self?._modes = modes
                }
            }
            return self
        }

        public func when(invokeTiming: NSRunLoopTaskInvokeTiming) -> Task {
            if let amendQueue = weakRunLoop.value?.taskAmendQueue {
                dispatch_async(amendQueue) { [weak self] () -> Void in
                    self?._invokeTiming = invokeTiming
                }
            }
            return self
        }
    }

    private var isDispatchObserverLoaded: Bool {
        return objc_getAssociatedObject(self, &dispatchObserverKey) !== nil
    }

    private func loadDispatchObserverIfNeeded() {
        if !isDispatchObserverLoaded {
            let invokeTimings: [NSRunLoopTaskInvokeTiming] =
            [.CurrentLoopEnded, .NextLoopBegan, .Idle]

            let activities =
            CFRunLoopActivity(invokeTimings.map{ CFRunLoopActivity($0) })

            let observer = CFRunLoopObserverCreateWithHandler(
                kCFAllocatorDefault,
                activities.rawValue,
                true, 0,
                handleRunLoopActivityWithObserver)

            CFRunLoopAddObserver(getCFRunLoop(),
                observer,
                kCFRunLoopCommonModes)

            let wrappedObserver = NSAssociated<CFRunLoopObserver>(observer)

            objc_setAssociatedObject(self,
                &dispatchObserverKey,
                wrappedObserver,
                .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    private var dispatchObserver: CFRunLoopObserver {
        loadDispatchObserverIfNeeded()
        return (objc_getAssociatedObject(self, &dispatchObserverKey)
            as! NSAssociated<CFRunLoopObserver>)
            .value
    }

    private var taskQueue: [Task] {
        get {
            if let taskQueue = objc_getAssociatedObject(self,
                &taskQueueKey)
                as? [Task]
            {
                return taskQueue
            } else {
                let initialValue = [Task]()

                objc_setAssociatedObject(self,
                    &taskQueueKey,
                    initialValue,
                    .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

                return initialValue
            }
        }
        set {
            objc_setAssociatedObject(self,
                &taskQueueKey,
                newValue,
                .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

        }
    }

    private var taskAmendQueue: dispatch_queue_t {
        if let taskQueue = objc_getAssociatedObject(self,
            &taskAmendQueueKey)
            as? dispatch_queue_t
        {
            return taskQueue
        } else {
            let initialValue =
            dispatch_queue_create(
                "com.WeZZard.Nest.NSRunLoop.TaskDispatcher.TaskAmendQueue",
                DISPATCH_QUEUE_SERIAL)

            objc_setAssociatedObject(self,
                &taskAmendQueueKey,
                initialValue,
                .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

            return initialValue
        }
    }

    private func handleRunLoopActivityWithObserver(observer: CFRunLoopObserver!,
        activity: CFRunLoopActivity)
        -> Void
    {
        var removedIndices = [Int]()

        let runLoopMode: NSRunLoopMode = currentRunLoopMode

        for (index, eachTask) in taskQueue.enumerate() {
            let expectedRunLoopModes = eachTask.modes
            let expectedRunLoopActivitiy =
            CFRunLoopActivity(eachTask.invokeTiming)

            let runLoopModesMatches = expectedRunLoopModes.contains(runLoopMode)
                || expectedRunLoopModes.contains(.commonModes)

            let runLoopActivityMatches =
            activity.contains(expectedRunLoopActivitiy)

            if runLoopModesMatches && runLoopActivityMatches {
                eachTask.closure()
                removedIndices.append(index)
            }
        }

        taskQueue.removeIndicesInPlace(removedIndices)
    }
}

extension CFRunLoopActivity {
    private init(_ invokeTiming: NSRunLoopTaskInvokeTiming) {
        switch invokeTiming {
        case .NextLoopBegan:        self = .AfterWaiting
        case .CurrentLoopEnded:     self = .BeforeWaiting
        case .Idle:                 self = .Exit
        }
    }
}

Avec le code précédent, nous pouvons maintenant envoyer l'exécution de UICollectionView's reloadData()à la fin de la boucle d'événement actuelle par un tel morceau de code:

NSRunLoop.currentRunLoop().perform({ () -> Void in
     collectionView.reloadData()
    }).when(.CurrentLoopEnded)

En fait, un tel répartiteur de tâches basé sur NSRunLoop a déjà été dans l'un de mes frameworks personnels: Nest. Et voici son référentiel sur GitHub: https://github.com/WeZZard/Nest

 dispatch_async(dispatch_get_main_queue(), ^{

            [collectionView reloadData];
            [collectionView layoutIfNeeded];
            [collectionView reloadData];


        });

cela a fonctionné pour moi.

Merci tout d'abord pour ce fil, très utile. J'ai eu un problème similaire avec Reload Data, sauf que le symptôme était que des cellules spécifiques ne pouvaient plus être sélectionnées de manière permanente alors que d'autres le pouvaient. Aucun appel à la méthode indexPathsForSelectedItems ou équivalent. Le débogage a signalé à recharger les données. J'ai essayé les deux options ci-dessus; et a fini par adopter l'option ReloadItemsAtIndexPaths car les autres options ne fonctionnaient pas dans mon cas ou faisaient clignoter la vue de la collection pendant environ une milli-seconde. Le code ci-dessous fonctionne bien:

NSMutableArray *indexPaths = [[NSMutableArray alloc] init]; 
NSIndexPath *indexPath;
for (int i = 0; i < [self.assets count]; i++) {
         indexPath = [NSIndexPath indexPathForItem:i inSection:0];
         [indexPaths addObject:indexPath];
}
[collectionView reloadItemsAtIndexPaths:indexPaths];`

Cela m'est également arrivé dans iOS 8.1 sdk, mais je l'ai bien compris quand j'ai remarqué que même après la mise à jour, datasourcela méthode numberOfItemsInSection:ne renvoyait pas le nouveau nombre d'éléments. J'ai mis à jour le décompte et je l'ai fait fonctionner.

Définissez-vous UICollectionView.contentInset? supprimer le bord gauche et droitInset, tout va bien après les avoir supprimés, le bogue existe toujours dans iOS8.3.

Vérifiez que chacune des méthodes UICollectionView Delegate fait ce que vous attendez d'elle. Par exemple, si

collectionView:layout:sizeForItemAtIndexPath:

ne renvoie pas une taille valide, le rechargement ne fonctionnera pas ...

essayez ce code.

 NSArray * visibleIdx = [self.collectionView indexPathsForVisibleItems];

    if (visibleIdx.count) {
        [self.collectionView reloadItemsAtIndexPaths:visibleIdx];
    }

Voici comment cela a fonctionné pour moi dans Swift 4

func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {

let cell = campaignsCollection.dequeueReusableCell(withReuseIdentifier: "Cell", for: indexPath) as! Cell

cell.updateCell()

    // TO UPDATE CELLVIEWS ACCORDINGLY WHEN DATA CHANGES
    DispatchQueue.main.async {
        self.campaignsCollection.reloadData()
    }

    return cell
}

inservif (isInsertHead) {
   [self insertItemsAtIndexPaths:tmpPoolIndex];
   NSArray * visibleIdx = [self indexPathsForVisibleItems];
   if (visibleIdx.count) {
       [self reloadItemsAtIndexPaths:visibleIdx];
   }
}else if (isFirstSyncData) {
    [self reloadData];
}else{
   [self insertItemsAtIndexPaths:tmpPoolIndex];
}