UICollectionView aktueller Index der sichtbaren Zellen

Ich verwende zum UICollectionViewersten Mal in meiner iPad-Anwendung. Ich habe so eingestellt UICollectionView, dass Größe und Zellengröße gleich sind, dh nur einmal eine Zelle gleichzeitig angezeigt wird.

Problem: Wenn der Benutzer jetzt UICollectionView scrollt, muss ich wissen, welche Zelle sichtbar ist. Ich muss andere UI-Elemente bei Änderungen aktualisieren. Ich habe dafür keine Delegatenmethode gefunden. Wie kann ich das erreichen?

Code:

[self.mainImageCollection setTag:MAIN_IMAGE_COLLECTION_VIEW];
[self.mainImageCollection registerClass:[InspirationMainImageCollectionCell class] forCellWithReuseIdentifier:@"cellIdentifier"];
[self.mainImageFlowLayout setScrollDirection:UICollectionViewScrollDirectionHorizontal];
[self.mainImageFlowLayout setMinimumInteritemSpacing:0.0f];
[self.mainImageFlowLayout setMinimumLineSpacing:0.0f];
self.mainImageFlowLayout.minimumLineSpacing = 0;
[self.mainImageCollection setPagingEnabled:YES];
[self.mainImageCollection setShowsHorizontalScrollIndicator:NO];
[self.mainImageCollection setCollectionViewLayout:self.mainImageFlowLayout];

Was ich versucht habe:

Als UICollectionViewkonform zu UIScrollView, bekam ich, wenn der Benutzer- Bildlauf mit der UIScrollViewDelegateMethode endet

-(void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView

Aber wie kann ich innerhalb der obigen Funktion den aktuellen Index der sichtbaren Zellen von UICollectionView???

Die Methode [collectionView sichtbare Zellen] gibt Ihnen alle gewünschten sichtbaren Zellen Array. Verwenden Sie es, wenn Sie erhalten möchten

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{
    for (UICollectionViewCell *cell in [self.mainImageCollection visibleCells]) {
        NSIndexPath *indexPath = [self.mainImageCollection indexPathForCell:cell];
        NSLog(@"%@",indexPath);
    }
}

Update auf Swift 5:

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    for cell in yourCollectionView.visibleCells {
        let indexPath = yourCollectionView.indexPath(for: cell)
        print(indexPath)
    }
}

indexPathsForVisibleItemsfunktioniert möglicherweise in den meisten Situationen, gibt jedoch manchmal ein Array mit mehr als einem Indexpfad zurück und es kann schwierig sein, den gewünschten Pfad zu finden. In diesen Situationen können Sie Folgendes tun:

CGRect visibleRect = (CGRect){.origin = self.collectionView.contentOffset, .size = self.collectionView.bounds.size};
CGPoint visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect));
NSIndexPath *visibleIndexPath = [self.collectionView indexPathForItemAtPoint:visiblePoint];

Dies funktioniert besonders gut, wenn jedes Element in Ihrer Sammlungsansicht den gesamten Bildschirm einnimmt.

Schnelle Version

let visibleRect = CGRect(origin: collectionView.contentOffset, size: collectionView.bounds.size)
let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)
let visibleIndexPath = collectionView.indexPathForItem(at: visiblePoint)

Swift 5 :

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
    var visibleRect = CGRect()

    visibleRect.origin = collectionView.contentOffset
    visibleRect.size = collectionView.bounds.size

    let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)

    guard let indexPath = collectionView.indexPathForItem(at: visiblePoint) else { return } 

    print(indexPath)
}

In Swift 2.2 kombinierte Arbeitsantworten:

 func scrollViewDidEndDecelerating(scrollView: UIScrollView) {

        var visibleRect = CGRect()

        visibleRect.origin = self.collectionView.contentOffset
        visibleRect.size = self.collectionView.bounds.size

        let visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect))

        let visibleIndexPath: NSIndexPath = self.collectionView.indexPathForItemAtPoint(visiblePoint)

        guard let indexPath = visibleIndexPath else { return } 
        print(indexPath)

    }

Der Vollständigkeit halber ist dies die Methode, die für mich funktioniert hat. Es war eine Kombination der Methoden von @Anthony & @ iAn.

- (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
      CGRect visibleRect = (CGRect){.origin = self.collectionView.contentOffset, .size = self.collectionView.bounds.size};
      CGPoint visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect));
      NSIndexPath *visibleIndexPath = [self.collectionView indexPathForItemAtPoint:visiblePoint];
      NSLog(@"%@",visibleIndexPath);
}

Es ist wahrscheinlich am besten, UICollectionViewDelegate-Methoden zu verwenden: (Swift 3)

// Called before the cell is displayed    
func collectionView(_ collectionView: UICollectionView, willDisplay cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    print(indexPath.row)
}

// Called when the cell is displayed
func collectionView(_ collectionView: UICollectionView, didEndDisplaying cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    print(indexPath.row)
}

Ich möchte nur für andere hinzufügen: Aus irgendeinem Grund habe ich die Zelle, die für den Benutzer sichtbar war, nicht erhalten, als ich mit pagingEnabled zur vorherigen Zelle in collectionView gescrollt habe.

Also füge ich den Code in dispatch_async ein, um ihm etwas "Luft" zu geben, und das funktioniert für mich.

-(void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView
{
    dispatch_async(dispatch_get_main_queue(), ^{
            UICollectionViewCell * visibleCell= [[self.collectionView visibleCells] objectAtIndex:0];


            [visibleCell doSomthing];
        });
}

Für Swift 3.0

func scrollViewDidScroll(_ scrollView: UIScrollView) {
    let visibleRect = CGRect(origin: colView.contentOffset, size: colView.bounds.size)
    let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)
    let indexPath = colView.indexPathForItem(at: visiblePoint)
}

Swift 3.0

Einfachste Lösung, mit der Sie indexPath für sichtbare Zellen erhalten.

yourCollectionView.indexPathsForVisibleItems 

gibt das Array des Indexpfads zurück.

Nehmen Sie einfach das erste Objekt aus diesem Array.

yourCollectionView.indexPathsForVisibleItems.first

Ich denke, es sollte auch mit Objective - C gut funktionieren.

UICollectionView aktueller Index der sichtbaren Zellen: Swift 3

var visibleCurrentCellIndexPath: IndexPath? {
    for cell in self.collectionView.visibleCells {
        let indexPath = self.collectionView.indexPath(for: cell)
        return indexPath
     }

     return nil
}

Die Konvertierung von @ Anthonys Antwort auf Swift 3.0 hat für mich perfekt funktioniert:

func scrollViewDidScroll(_ scrollView: UIScrollView) {

    var visibleRect = CGRect()
    visibleRect.origin = yourCollectionView.contentOffset
    visibleRect.size = yourCollectionView.bounds.size
    let visiblePoint = CGPoint(x: CGFloat(visibleRect.midX), y: CGFloat(visibleRect.midY))
    let visibleIndexPath: IndexPath? = yourCollectionView.indexPathForItem(at: visiblePoint)
    print("Visible cell's index is : \(visibleIndexPath?.row)!")
}

Sie können scrollViewDidEndDecelerating: dafür verwenden

//@property (strong, nonatomic) IBOutlet UICollectionView *collectionView;

   - (void)scrollViewDidEndDecelerating:(UIScrollView *)scrollView{

        for (UICollectionViewCell *cell in [self.collectionView visibleCells]) {
            NSIndexPath *indexPath = [self.collectionView indexPathForCell:cell];
            NSUInteger lastIndex = [indexPath indexAtPosition:[indexPath length] - 1];
            NSLog(@"visible cell value %d",lastIndex);
        }

    }

Das ist eine alte Frage, aber in meinem Fall ...

- (void) scrollViewWillBeginDragging:(UIScrollView *)scrollView {

    _m_offsetIdx = [m_cv indexPathForCell:m_cv.visibleCells.firstObject].row;
}

- (void) scrollViewDidEndDecelerating:(UIScrollView *)scrollView {
    _m_offsetIdx = [m_cv indexPathForCell:m_cv.visibleCells.lastObject].row;
}

Überprüfen Sie auch dieses Snippet

let isCellVisible = collectionView.visibleCells.map { collectionView.indexPath(for: $0) }.contains(inspectingIndexPath)

In diesem Thread gibt es so viele Lösungen, die gut funktionieren, wenn die Zelle im Vollbildmodus angezeigt wird, aber die Grenzen der Sammlungsansicht und die Mittelpunkte von Visible Rect verwenden. Es gibt jedoch eine einfache Lösung für dieses Problem

    DispatchQueue.main.async {
        let visibleCell = self.collImages.visibleCells.first
        print(self.collImages.indexPath(for: visibleCell))
    }

Auf diese Weise können Sie den Indexpfad der sichtbaren Zelle abrufen. Ich habe DispatchQueue hinzugefügt, weil, wenn Sie schneller wischen und für einen kurzen Moment die nächste Zelle angezeigt wird, ohne dispactchQueue der Indexpfad der kurz angezeigten Zelle angezeigt wird, nicht die Zelle, die auf dem Bildschirm angezeigt wird.

versuchen Sie dies, es funktioniert. (Im folgenden Beispiel habe ich zum Beispiel 3 Zellen.)

    func scrollViewDidEndDecelerating(scrollView: UIScrollView) {
    let visibleRect = CGRect(origin: self.collectionView.contentOffset, size: self.collectionView.bounds.size)
    let visiblePoint = CGPointMake(CGRectGetMidX(visibleRect), CGRectGetMidY(visibleRect))
    let visibleIndexPath = self.collectionView.indexPathForItemAtPoint(visiblePoint)
    if let v = visibleIndexPath {
        switch v.item {
        case 0: setImageDescription()
            break
        case 1: setImageConditions()
            break
        case 2: setImageResults()
            break
        default: break
        }
    }

Swift 3 & Swift 4:

func scrollViewDidEndDecelerating(_ scrollView: UIScrollView) {
   var visibleRect = CGRect()

   visibleRect.origin = collectionView.contentOffset
   visibleRect.size = collectionView.bounds.size

   let visiblePoint = CGPoint(x: visibleRect.midX, y: visibleRect.midY)

   guard let indexPath = collectionView.indexPathForItem(at: visiblePoint) else { return } 

   print(indexPath[1])
}

Wenn Sie die tatsächliche Anzahl anzeigen möchten, können Sie +1 hinzufügen