Benachrichtigt werden, wenn UITableView die Datenanfrage beendet hat?

Gibt es eine Möglichkeit herauszufinden, wann a UITableViewdie Daten von seiner Datenquelle abgefragt hat?

Keine der viewDidLoad/ viewWillAppear/ viewDidAppearMethoden des zugehörigen View Controllers ( UITableViewController) ist hier von Nutzen, da sie alle zu früh ausgelöst werden. Keiner von ihnen garantiert (völlig verständlich), dass Abfragen an die Datenquelle vorerst abgeschlossen sind (z. B. bis die Ansicht gescrollt wird).

Eine Abhilfe , die ich gefunden habe , ist zu nennen reloadDatain viewDidAppear, da bei der reloadDataRückkehr, die Tabellenansicht ist garantiert beendet zu haben , die Datenquelle so viel abfragt , wie es für den Augenblick braucht.

Dies scheint jedoch ziemlich unangenehm zu sein, da ich davon ausgehe, dass die Datenquelle reloadDatabeim ersten Laden zweimal (einmal automatisch und einmal aufgrund des Aufrufs) nach denselben Informationen gefragt wird.

Der Grund, warum ich dies überhaupt tun möchte, ist, dass ich die Bildlaufposition von UITableView- beibehalten möchte, aber bis auf die Pixelebene, nicht nur bis zur nächsten Zeile.

Wenn die Bildlaufposition Wiederherstellung (mit scrollRectToVisible:animated:), muß ich die Tabellenansicht bereits genügend Daten darin hat, oder aber der scrollRectToVisible:animated:Methodenaufruf tut nichts (was was ist, wenn Sie den Anruf auf seinem eigenen in einem Platz geschieht , ist viewDidLoad, viewWillAppearoder viewDidAppear).

Diese Antwort scheint nicht mehr zu funktionieren, da einige Änderungen an der UITableView-Implementierung vorgenommen wurden, seit die Antwort geschrieben wurde. Siehe diesen Kommentar: Benachrichtigt werden, wenn UITableView die Datenanfrage beendet hat?

Ich habe für ein paar Tage mit diesem Problem gespielt und denke , dass Subclassing UITableView‚s reloadDataist der beste Ansatz:

- (void)reloadData {

    NSLog(@"BEGIN reloadData");

    [super reloadData];

    NSLog(@"END reloadData");

}

reloadDataendet nicht, bevor die Tabelle ihre Daten neu geladen hat. Wenn also die zweite NSLogausgelöst wird, fragt die Tabellenansicht tatsächlich nach Daten.

Ich habe eine Unterklasse erstellt UITableView, um vorher und nachher Methoden an den Delegaten zu senden reloadData. Es wirkt wie ein Zauber.

Ich hatte das gleiche Szenario in meiner App und dachte, ich würde meine Antwort an euch senden, da andere hier erwähnte Antworten für iOS7 und höher nicht funktionieren

Schließlich ist dies das einzige, was für mich geklappt hat.

[yourTableview reloadData];

dispatch_async(dispatch_get_main_queue(),^{
        NSIndexPath *path = [NSIndexPath indexPathForRow:yourRow inSection:yourSection];
        //Basically maintain your logic to get the indexpath
        [yourTableview scrollToRowAtIndexPath:path atScrollPosition:UITableViewScrollPositionTop animated:YES];
 });

Schnelles Update:

yourTableview.reloadData()
dispatch_async(dispatch_get_main_queue(), { () -> Void in
    let path : NSIndexPath = NSIndexPath(forRow: myRowValue, inSection: mySectionValue)
    //Basically maintain your logic to get the indexpath
    yourTableview.scrollToRowAtIndexPath(path, atScrollPosition: UITableViewScrollPosition.Top, animated: true)

})

Also wie das funktioniert.

Grundsätzlich wird der Haupt-Thread beim Neuladen ausgelastet. Wenn wir also einen asynchronen Versand-Thread ausführen, wartet der Block, bis der Haupt-Thread fertig ist. Sobald die Tabellenansicht vollständig geladen wurde, wird der Hauptthread beendet und unser Methodenblock wird versendet

Getestet in iOS7 und iOS8 und es funktioniert super ;)

Update für iOS9: Dies funktioniert gut, auch iOS9. Ich habe ein Beispielprojekt in Github als POC erstellt. https://github.com/ipraba/TableReloadingNotifier

Ich füge hier den Screenshot meines Tests hinzu.

Getestete Umgebung: iOS9 iPhone6 ​​Simulator von Xcode7

EDIT: Diese Antwort ist eigentlich keine Lösung. Es scheint wahrscheinlich zunächst zu funktionieren, da das Neuladen ziemlich schnell erfolgen kann, aber tatsächlich wird der Abschlussblock nicht unbedingt aufgerufen, nachdem die Daten vollständig neu geladen wurden - da reloadData nicht blockiert. Sie sollten wahrscheinlich nach einer besseren Lösung suchen.

Um die Antwort von @Eric MORAND zu erweitern, fügen wir einen Abschlussblock ein. Wer liebt einen Block nicht?

@interface DUTableView : UITableView

   - (void) reloadDataWithCompletion:( void (^) (void) )completionBlock;

@end

und...

#import "DUTableView.h"

@implementation DUTableView

- (void) reloadDataWithCompletion:( void (^) (void) )completionBlock {
    [super reloadData];
    if(completionBlock) {
        completionBlock();
    }
}

@end

Verwendung:

[self.tableView reloadDataWithCompletion:^{
                                            //do your stuff here
                                        }];

reloadData fragt nur nach Daten für die sichtbaren Zellen. Um benachrichtigt zu werden, wenn ein bestimmter Teil Ihrer Tabelle geladen wird, schließen Sie bitte die tableView: willDisplayCell:Methode an.

- (void) reloadDisplayData
{
    isLoading =  YES;
    NSLog(@"Reload display with last index %d", lastIndex);
    [_tableView reloadData];
    if(lastIndex <= 0){
    isLoading = YES;
    //Notify completed
}

- (void) tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath
{
    if(indexPath.row >= lastIndex){
    isLoading = NO;
    //Notify completed
}

Das ist meine Lösung. 100% funktioniert und wird in vielen Projekten verwendet. Es ist eine einfache UITableView-Unterklasse.

@protocol MyTableViewDelegate<NSObject, UITableViewDelegate>
@optional
- (void)tableViewWillReloadData:(UITableView *)tableView;
- (void)tableViewDidReloadData:(UITableView *)tableView;
@end

@interface MyTableView : UITableView {
    struct {
        unsigned int delegateWillReloadData:1;
        unsigned int delegateDidReloadData:1;
        unsigned int reloading:1;
    } _flags;
}
@end

@implementation MyTableView
- (id<MyTableViewDelegate>)delegate {
    return (id<MyTableViewDelegate>)[super delegate];
}

- (void)setDelegate:(id<MyTableViewDelegate>)delegate {
    [super setDelegate:delegate];
    _flags.delegateWillReloadData = [delegate respondsToSelector:@selector(tableViewWillReloadData:)];
    _flags.delegateDidReloadData = [delegate    respondsToSelector:@selector(tableViewDidReloadData:)];
}

- (void)reloadData {
    [super reloadData];
    if (_flags.reloading == NO) {
        _flags.reloading = YES;
        if (_flags.delegateWillReloadData) {
            [(id<MyTableViewDelegate>)self.delegate tableViewWillReloadData:self];
        }
        [self performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f];
    }
}

- (void)finishReload {
    _flags.reloading = NO;
    if (_flags.delegateDidReloadData) {
        [(id<MyTableViewDelegate>)self.delegate tableViewDidReloadData:self];
    }
}

@end

Mit einer Ausnahme ähnelt es der Lösung von Josh Brown . Bei der performSelector-Methode ist keine Verzögerung erforderlich. Egal wie lange es reloadDatadauert. tableViewDidLoadData:Feuert immer, wenn Sie tableViewfertig sind dataSource cellForRowAtIndexPath.

Auch wenn Sie keine Unterklasse möchten, UITableViewkönnen Sie einfach aufrufen [performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f]und Ihr Selektor wird direkt nach dem erneuten Laden der Tabelle aufgerufen. Sie sollten jedoch sicherstellen, dass der Selektor nur einmal pro Aufruf aufgerufen wird, um reloadData:

[self.tableView reloadData];
[self performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f];

Genießen. :) :)

Dies ist eine Antwort auf eine etwas andere Frage: Ich musste wissen, wann UITableViewauch der Anruf beendet war cellForRowAtIndexPath(). Ich habe eine Unterklasse layoutSubviews()(danke @Eric MORAND) erstellt und einen Rückruf für Delegierte hinzugefügt:

SDTableView.h:

@protocol SDTableViewDelegate <NSObject, UITableViewDelegate>
@required
- (void)willReloadData;
- (void)didReloadData;
- (void)willLayoutSubviews;
- (void)didLayoutSubviews;
@end

@interface SDTableView : UITableView

@property(nonatomic,assign) id <SDTableViewDelegate> delegate;

@end;

SDTableView.m:

#import "SDTableView.h"

@implementation SDTableView

@dynamic delegate;

- (void) reloadData {
    [self.delegate willReloadData];

    [super reloadData];

    [self.delegate didReloadData];
}

- (void) layoutSubviews {
    [self.delegate willLayoutSubviews];

    [super layoutSubviews];

    [self.delegate didLayoutSubviews];
}

@end

Verwendung:

MyTableViewController.h:

#import "SDTableView.h"
@interface MyTableViewController : UITableViewController <SDTableViewDelegate>
@property (nonatomic) BOOL reloadInProgress;

MyTableViewController.m:

#import "MyTableViewController.h"
@implementation MyTableViewController
@synthesize reloadInProgress;

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {

    if ( ! reloadInProgress) {
        NSLog(@"---- numberOfSectionsInTableView(): reloadInProgress=TRUE");
        reloadInProgress = TRUE;
    }

    return 1;
}

- (void)willReloadData {}
- (void)didReloadData {}
- (void)willLayoutSubviews {}

- (void)didLayoutSubviews {
    if (reloadInProgress) {
        NSLog(@"---- layoutSubviewsEnd(): reloadInProgress=FALSE");
        reloadInProgress = FALSE;
    }
}

HINWEISE: Da dies eine Unterklasse ist, auf UITableViewdie bereits eine Delegate-Eigenschaft verweist, muss MyTableViewControllerkeine weitere hinzugefügt werden. Der "@dynamic-Delegat" weist den Compiler an, diese Eigenschaft zu verwenden. (Hier ist ein Link diese beschreiben: http://farhadnoorzay.com/2012/01/20/objective-c-how-to-add-delegate-methods-in-a-subclass/ )

Die UITableViewEigenschaft in MyTableViewControllermuss geändert werden, um die neue SDTableViewKlasse zu verwenden. Dies erfolgt im Interface Builder Identity Inspector. Wählen Sie das UITableViewInnere von UITableViewControllerund setzen Sie die "Benutzerdefinierte Klasse" auf SDTableView.

Ich hatte etwas Ähnliches gefunden, um eine Benachrichtigung für die Änderung contentSizevon zu erhalten TableView. Ich denke, das sollte auch hier funktionieren, da sich contentSize auch beim Laden von Daten ändert.

Versuche dies:

In viewDidLoadschreiben,

[self.tableView addObserver:self forKeyPath:@"contentSize" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld | NSKeyValueObservingOptionPrior context:NULL];

und fügen Sie diese Methode Ihrem viewController hinzu:

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if ([keyPath isEqualToString:@"contentSize"]) {
        DLog(@"change = %@", change.description)

        NSValue *new = [change valueForKey:@"new"];
        NSValue *old = [change valueForKey:@"old"];

        if (new && old) {
            if (![old isEqualToValue:new]) {
                // do your stuff
            }
        }


    }
}

Möglicherweise müssen Sie bei der Überprüfung auf Änderungen geringfügige Änderungen vornehmen. Das hatte aber bei mir funktioniert.

Prost! :) :)

Hier ist eine mögliche Lösung, obwohl es ein Hack ist:

[self.tableView reloadData];
[self performSelector:@selector(scrollTableView) withObject:nil afterDelay:0.3];

Wo Ihre -scrollTableViewMethode die Tabellenansicht mit scrollt -scrollRectToVisible:animated:. Und natürlich können Sie die Verzögerung im obigen Code von 0,3 bis zu dem konfigurieren, was für Sie zu funktionieren scheint. Ja, es ist lächerlich hackig, aber es funktioniert für mich auf meinem iPhone 5 und 4S ...

Ich hatte etwas Ähnliches, glaube ich. Ich habe eine BOOL als Instanzvariable hinzugefügt, die mir sagt, ob der Offset wiederhergestellt wurde, und das eincheckt -viewWillAppear:. Wenn es nicht wiederhergestellt wurde, stelle ich es in dieser Methode wieder her und setze BOOL, um anzuzeigen, dass ich den Offset wiederhergestellt habe.

Es ist eine Art Hack und es kann wahrscheinlich besser gemacht werden, aber das funktioniert im Moment für mich.

Es hört sich so an, als ob Sie den Zelleninhalt aktualisieren möchten, aber ohne die plötzlichen Sprünge, die mit dem Einfügen und Löschen von Zellen einhergehen können.

Es gibt mehrere Artikel dazu. Dies ist einer.

Ich empfehle die Verwendung von setContentOffset: animiert: anstelle von scrollRectToVisible: animiert: für pixelgenaue Einstellungen einer Bildlaufansicht.

Sie können die folgende Logik ausprobieren:

-(UITableViewCell *) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"MyIdentifier"];

    if (cell == nil) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:@"MyIdentifier"];
        cell.selectionStyle = UITableViewCellSelectionStyleNone;
    }

    if ( [self chkIfLastCellIndexToCreate:tableView :indexPath]){
        NSLog(@"Created Last Cell. IndexPath = %@", indexPath);
        //[self.activityIndicator hide];
        //Do the task for TableView Loading Finished
    }
    prevIndexPath = indexPath;

    return cell;
}



-(BOOL) chkIfLastCellIndexToCreate:(UITableView*)tableView : (NSIndexPath *)indexPath{

    BOOL bRetVal = NO;
    NSArray *visibleIndices = [tableView indexPathsForVisibleRows];

    if (!visibleIndices || ![visibleIndices count])
        bRetVal = YES;

    NSIndexPath *firstVisibleIP = [visibleIndices objectAtIndex:0];
    NSIndexPath *lastVisibleIP = [visibleIndices objectAtIndex:[visibleIndices count]-1];

    if ((indexPath.row > prevIndexPath.row) && (indexPath.section >= prevIndexPath.section)){
        //Ascending - scrolling up
        if ([indexPath isEqual:lastVisibleIP]) {
            bRetVal = YES;
            //NSLog(@"Last Loading Cell :: %@", indexPath);
        }
    } else if ((indexPath.row < prevIndexPath.row) && (indexPath.section <= prevIndexPath.section)) {
        //Descending - scrolling down
        if ([indexPath isEqual:firstVisibleIP]) {
            bRetVal = YES;
            //NSLog(@"Last Loading Cell :: %@", indexPath);
        }
    }
    return bRetVal;
}

Und bevor Sie reloadData aufrufen, setzen Sie prevIndexPath auf nil. Mögen:

prevIndexPath = nil;
[mainTableView reloadData];

Ich habe mit NSLogs getestet, und diese Logik scheint in Ordnung zu sein. Sie können nach Bedarf anpassen / verbessern.

Endlich habe ich meinen Code damit arbeiten lassen -

[tableView scrollToRowAtIndexPath:scrollToIndex atScrollPosition:UITableViewScrollPositionTop animated:YES];

Es gab nur wenige Dinge, die erledigt werden mussten -

1. nenne es innerhalb von " - (UITableViewCell *)MyTableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath"
2. Stellen Sie einfach sicher, dass die Nachricht "scrollToRowAtIndexPath" an die relevante Instanz von UITableView gesendet wird, in diesem Fall definitiv MyTableview.
3. In meinem Fall ist UIView die Ansicht, die eine Instanz von UITableView enthält
4. Dies wird auch für jede Zellenlast aufgerufen. Erstellen Sie daher eine Logik in "cellForRowAtIndexPath", um zu vermeiden, dass "scrollToRowAtIndexPath" mehrmals aufgerufen wird.

Sie können die Größe Ihrer Tabellenansicht ändern oder die Inhaltsgröße in dieser Methode festlegen, wenn alle Daten geladen sind:

- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath
{
    tableView.frame =CGRectMake(tableView.frame.origin.x, tableView.frame.origin.y, tableView.frame.size.width, tableView.contentSize.height);
}

Ich führe nur das Wiederholen des geplanten Timers aus und mache ihn nur ungültig, wenn die contentSize der Tabelle größer ist, wenn die tableHeaderView-Höhe (dh die Tabelle enthält Zeileninhalt). Der Code in C # (Monotouch), aber ich hoffe die Idee ist klar:

    public override void ReloadTableData()
    {
        base.ReloadTableData();

        // don't do anything if there is no data
        if (ItemsSource != null && ItemsSource.Length > 0)
        {
            _timer = NSTimer.CreateRepeatingScheduledTimer(TimeSpan.MinValue, 
                new NSAction(() => 
                {
                    // make sure that table has header view and content size is big enought
                    if (TableView.TableHeaderView != null &&
                        TableView.ContentSize.Height > 
                            TableView.TableHeaderView.Frame.Height)
                    {
                        TableView.SetContentOffset(
                            new PointF(0, TableView.TableHeaderView.Frame.Height), false);
                        _timer.Invalidate();
                        _timer = null;
                    }
                }));
        }
    }

Wird nicht UITableView layoutSubviewsaufgerufen, bevor die Tabellenansicht den Inhalt anzeigt? Ich habe festgestellt, dass es aufgerufen wird, sobald die Tabellenansicht ihre Daten geladen hat. Vielleicht sollten Sie dies untersuchen.

Seit iOS 6 heißt die UITableviewDelegatenmethode:

-(void)tableView:(UITableView *)tableView willDisplayHeaderView:(UIView *)view forSection:(NSInteger)section

wird ausgeführt, sobald Ihre Tabelle erfolgreich neu geladen wurde. Bei dieser Methode können Sie die erforderlichen Anpassungen vornehmen.

Die beste Lösung, die ich in Swift gefunden habe

extension UITableView {
    func reloadData(completion: ()->()) {
        self.reloadData()
        dispatch_async(dispatch_get_main_queue()) {
            completion()
        }
    }
}

Warum nicht einfach verlängern?

@interface UITableView(reloadComplete)
- (void) reloadDataWithCompletion:( void (^) (void) )completionBlock;
@end

@implementation UITableView(reloadComplete)
- (void) reloadDataWithCompletion:( void (^) (void) )completionBlock {
    [self reloadData];
    if(completionBlock) {
        completionBlock();
    }
}
@end

bis zum Ende scrollen:

[self.table reloadDataWithCompletion:^{
    NSInteger numberOfRows = [self.table numberOfRowsInSection:0];
    if (numberOfRows > 0)
    {
        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:numberOfRows-1 inSection:0];
        [self.table scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionTop animated:NO];
    }
}];

Nicht mit vielen Daten getestet