Ser notificado quando UITableView terminar de solicitar dados?

Existe alguma maneira de descobrir quando um UITableViewterminou de solicitar dados de sua fonte de dados?

Nenhum dos métodos viewDidLoad/ viewWillAppear/ viewDidAppeardo controlador de visualização associado ( UITableViewController) é útil aqui, pois todos eles disparam muito cedo. Nenhum deles (de forma totalmente compreensível) garante que as consultas à fonte de dados tenham terminado por enquanto (por exemplo, até que a exibição seja rolada).

Uma solução que eu encontrei é para chamar reloadDataem viewDidAppear, uma vez que, quando reloadDataretorna, a exibição de tabela é garantida para terminar de consultar a fonte de dados, tanto quanto ele precisa para o momento.

No entanto, isso parece bastante desagradável, pois suponho que esteja fazendo com que a fonte de dados seja solicitada as mesmas informações duas vezes (uma vez automaticamente e uma vez por causa da reloadDatachamada) quando é carregada pela primeira vez.

O motivo pelo qual quero fazer isso é que desejo preservar a posição de rolagem do UITableView- mas até o nível de pixel, não apenas para a linha mais próxima.

Ao restaurar a posição de rolagem (usando scrollRectToVisible:animated:), preciso que o table view já tenha dados suficientes, ou então a scrollRectToVisible:animated:chamada do método não fará nada (que é o que acontece se você colocar a chamada sozinha em qualquer um de viewDidLoad, viewWillAppearou viewDidAppear).

Esta resposta parece não estar mais funcionando, devido a algumas alterações feitas na implementação de UITableView desde que a resposta foi escrita. Veja este comentário: Ser notificado quando UITableView terminar de solicitar dados?

Eu tenho jogado com esse problema por um par de dias e acho que subclasses UITableView's reloadDataé a melhor abordagem:

- (void)reloadData {

    NSLog(@"BEGIN reloadData");

    [super reloadData];

    NSLog(@"END reloadData");

}

reloadDatanão termina antes que a tabela termine de recarregar seus dados. Portanto, quando o segundo NSLogé disparado, a visualização da tabela acabou de solicitar os dados.

Criei uma subclasse UITableViewpara enviar métodos ao delegado antes e depois reloadData. Ele funciona como um encanto.

Eu tive o mesmo cenário em meu aplicativo e pensei em postar minha resposta para vocês, já que outras respostas mencionadas aqui não funcionam para mim para iOS7 e posterior

Finalmente, esta é a única coisa que funcionou para mim.

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

Atualização rápida:

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)

})

Então, como isso funciona.

Basicamente, quando você faz uma recarga, a thread principal fica ocupada, então, no momento em que fazemos um thread de despacho assíncrono, o bloco irá esperar até que a thread principal seja concluída. Assim que o tableview for carregado completamente, a thread principal será concluída e enviará nosso bloco de métodos

Testado em iOS7 e iOS8 e funciona muito bem;)

Atualização para iOS9: Funciona bem no iOS9 também. Eu criei um projeto de amostra no github como um POC. https://github.com/ipraba/TableReloadingNotifier

Estou anexando a captura de tela do meu teste aqui.

Ambiente testado: simulador iOS9 iPhone6 ​​da Xcode7

EDIT: Esta resposta não é realmente uma solução. Provavelmente parece funcionar a princípio porque o recarregamento pode acontecer muito rápido, mas, na verdade, o bloco de conclusão não é necessariamente chamado depois que o recarregamento completo dos dados - porque reloadData não bloqueia. Você provavelmente deve procurar uma solução melhor.

Para expandir a resposta de @Eric MORAND, vamos colocar um bloco de conclusão. Quem não ama um bloco?

@interface DUTableView : UITableView

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

@end

e...

#import "DUTableView.h"

@implementation DUTableView

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

@end

Uso:

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

reloadData apenas pedindo dados para as células visíveis. Diz que, para ser notificado quando uma parte específica de sua tabela for carregada, conecte o tableView: willDisplayCell:método.

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

Essa é a minha solução. 100% funciona e é usado em muitos projetos. É uma subclasse UITableView simples.

@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

É semelhante à solução de Josh Brown, com uma exceção. Nenhum atraso é necessário no método performSelector. Não importa o quanto reloadDatademore. tableViewDidLoadData:sempre dispara quando tableViewacaba de perguntar dataSource cellForRowAtIndexPath.

Mesmo se você não quiser uma subclasse, UITableViewvocê pode simplesmente chamar [performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f]e seu seletor será chamado assim que a tabela terminar de recarregar. Mas você deve garantir que o seletor seja chamado apenas uma vez por chamada para reloadData:

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

Aproveitar. :)

Esta é uma resposta a uma pergunta um pouco diferente: eu precisava saber quando UITableViewtambém havia terminado de ligar cellForRowAtIndexPath(). Eu layoutSubviews()criei uma subclasse (obrigado @Eric MORAND) e adicionei um retorno de chamada delegado:

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

Uso:

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

NOTAS: Como esta é uma subclasse da UITableViewqual já possui uma propriedade delegate apontando para, MyTableViewControllernão há necessidade de adicionar outra. O "delegado @dynamic" diz ao compilador para usar esta propriedade. (Aqui está um link que descreve isso: http://farhadnoorzay.com/2012/01/20/objective-c-how-to-add-delegate-methods-in-a-subclass/ )

A UITableViewpropriedade em MyTableViewControllerdeve ser alterada para usar a nova SDTableViewclasse. Isso é feito no Interface Builder Identity Inspector. Selecione o UITableViewinterior de UITableViewControllere defina sua "Classe personalizada" como SDTableView.

Eu tinha encontrado algo semelhante para receber notificação de mudança contentSizede TableView. Acho que deve funcionar aqui também, já que contentSize também muda com o carregamento de dados.

Experimente isto:

Por viewDidLoadescrito,

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

e adicione este método ao seu viewController:

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


    }
}

Você pode precisar de pequenas modificações na verificação de mudança. Isso funcionou para mim, no entanto.

Felicidades! :)

Aqui está uma solução possível, embora seja um hack:

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

Onde seu -scrollTableViewmétodo rola a visualização da tabela -scrollRectToVisible:animated:. E, claro, você pode configurar o atraso no código acima de 0.3 para o que parece funcionar para você. Sim, é ridiculamente hacky, mas funciona para mim no meu iPhone 5 e 4S ...

Eu tinha algo semelhante, eu acredito. Eu adicionei um BOOL como variável de instância que me diz se o deslocamento foi restaurado e verifique isso -viewWillAppear:. Quando não foi restaurado, eu o restauro nesse método e defino o BOOL para indicar que recuperei o deslocamento.

É uma espécie de hack e provavelmente pode ser feito melhor, mas funciona para mim no momento.

Parece que você deseja atualizar o conteúdo da célula, mas sem os saltos repentinos que podem acompanhar as inserções e exclusões de células.

Existem vários artigos sobre como fazer isso. Isso é um.

Eu sugiro usar setContentOffset: animated: em vez de scrollRectToVisible: animated: para configurações perfeitas de pixel de uma visualização de rolagem.

Você pode tentar a seguinte lógica:

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

E antes de chamar reloadData, defina prevIndexPath como nil. Gostar:

prevIndexPath = nil;
[mainTableView reloadData];

Testei com NSLogs, e essa lógica parece ok. Você pode personalizar / melhorar conforme necessário.

finalmente fiz meu código funcionar com isso -

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

havia poucas coisas que precisavam ser cuidadas -

1. chame-o dentro de " - (UITableViewCell *)MyTableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath"
2. apenas certifique-se de que a mensagem "scrollToRowAtIndexPath" seja enviada para a instância relevante de UITableView, que é definitivamente MyTableview neste caso.
3. No meu caso, UIView é a visão que contém uma instância de UITableView
4. Além disso, isso será chamado para cada carga de célula. Portanto, coloque uma lógica dentro de "cellForRowAtIndexPath" para evitar chamar "scrollToRowAtIndexPath" mais de uma vez.

Você pode redimensionar o tableview ou definir o tamanho do conteúdo neste método quando todos os dados forem carregados:

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

Acabei de executar o cronômetro programado de repetição e invalidá-lo apenas quando o contentSize da tabela for maior quando a altura da tableHeaderView (significa que há conteúdo de linhas na tabela). O código em C # (monotouch), mas espero que a ideia seja clara:

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

Não é UITableView layoutSubviewschamado pouco antes de a visualização da tabela exibir seu conteúdo? Percebi que ele é chamado assim que a table view termina de carregar seus dados, talvez você deva investigar nessa direção.

Desde o iOS 6 em diante, o UITableviewmétodo delegado chamou:

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

será executado assim que sua tabela for recarregada com sucesso. Você pode fazer a personalização conforme necessário neste método.

A melhor solução que encontrei em Swift

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

Por que não apenas estender?

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

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

role até o final:

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

Não testado com muitos dados