UITableView veri istemeyi bitirdiğinde bildirim alın.

UITableViewVeri kaynağından veri istemenin ne zaman bittiğini öğrenmenin bir yolu var mı ?

İlişkili görünüm denetleyicisinin viewDidLoad/ viewWillAppear/ viewDidAppearyöntemlerinden hiçbiri (UITableViewController ) burada kullanılmaz, çünkü hepsi çok erken tetiklenir. Bunların hiçbiri (tamamen anlaşılır bir şekilde), veri kaynağına yapılan sorguların şimdilik (örneğin, görünüm kaydırılıncaya kadar) bittiğini garanti etmez.

Bir buldum çağırmaktır var Geçici çözüm reloadDatade viewDidAppearzaman, çünkü reloadDatadöner, tablo görünümünde olduğu zamanı varlık için için ihtiyacı olduğu gibi veri kaynağını sorgulama bitirdikten garantilidir.

Bununla birlikte, veri kaynağından aynı bilgilerin iki kez sorulmasına neden olduğunu varsaydığım için bu oldukça çirkin görünüyor (bir kez otomatik olarak ve bir kez reloadData ilk yüklendiğinde arama ) .

Bunu kesinlikle yapmak istememin nedeni, kaydırma konumunu korumak istememdir UITableView- ancak sadece en yakın satıra değil, piksel seviyesine kadar.

Kaydırma konumu (kullanarak geri yüklerken scrollRectToVisible:animated:), Ben zaten yeterli veriye sahip çocukları ya da tablo görünümü gerek scrollRectToVisible:animated:yöntem çağrısı (eğer herhangi kendi başına aramayı eğer böyle olur hiçbir şey yapmaz viewDidLoad, viewWillAppearya da viewDidAppear).

Cevap yazıldıktan sonra UITableView uygulamasında yapılan bazı değişiklikler nedeniyle, bu yanıt artık işe yaramıyor gibi görünüyor. Bu yoruma bakın: UITableView veri istemeyi bitirdiğinde bildirim alın?

Ben birkaç gün boyunca bu sorunla oynayan ve o subclassing düşünmek oldum UITableView'in reloadDataen iyi yaklaşımdır:

- (void)reloadData {

    NSLog(@"BEGIN reloadData");

    [super reloadData];

    NSLog(@"END reloadData");

}

reloadDatatablonun verilerini yeniden yüklemesi bitmeden bitmez. Bu nedenle, ikincisi çalıştırıldığında NSLog, tablo görünümü aslında veri istemeyi bitirmiştir.

UITableViewTemsilciye önce ve sonra yöntemler göndermek için alt sınıflara girdim reloadData. Mucizevi şekilde çalışır.

Uygulamamda da aynı bir senaryoya sahiptim ve cevabımı size göndereceğimi düşündüm, çünkü burada bahsedilen diğer cevaplar iOS7 ve sonrası için benim için çalışmıyor

Sonunda benim için işe yarayan tek şey buydu.

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

Swift Güncellemesi:

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)

})

Peki bu nasıl işliyor.

Temel olarak, bir yeniden yükleme yaptığınızda ana iş parçacığı meşgul olur, bu nedenle eşzamansız bir iş parçacığı gönderirken, blok ana iş parçacığı bitene kadar bekleyecektir. Dolayısıyla, tablo görünümü tamamen yüklendikten sonra ana iş parçacığı bitecek ve böylece yöntem bloğumuzu gönderecektir.

İOS7 ve iOS8'de test edildi ve harika çalışıyor;)

İOS9 için güncelleme: Bu sadece iyi çalışıyor iOS9 da. Github'da POC olarak örnek bir proje oluşturdum. https://github.com/ipraba/TableReloadingNotifier

Testimin ekran görüntüsünü buraya ekliyorum.

Test Edilen Ortam: Xcode7'den iOS9 iPhone6 ​​simülatörü

DÜZENLEME: Bu cevap aslında bir çözüm değil. Muhtemelen ilk başta işe yarıyor gibi görünüyor çünkü yeniden yükleme oldukça hızlı gerçekleşebilir, ancak aslında tamamlama bloğu, verilerin yeniden yüklenmesi tamamen bittikten sonra mutlaka çağrılmaz - çünkü reloadData engellemez. Muhtemelen daha iyi bir çözüm aramalısınız.

@Eric MORAND'ın cevabını genişletmek için, bir tamamlama bloğu koyalım. Kim bir bloğu sevmez?

@interface DUTableView : UITableView

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

@end

ve...

#import "DUTableView.h"

@implementation DUTableView

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

@end

Kullanımı:

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

reloadData sadece görünen hücreler için veri ister. Diyor ki, tablonuzun belirli bir bölümü yüklendiğinde haberdar olmak için, lütfen tableView: willDisplayCell:yöntemi bağlayın.

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

Benim çözümüm bu. % 100 çalışır ve birçok projede kullanılır. Basit bir UITableView alt sınıfıdır.

@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

Bu benzeyen Josh Brown solüsyonu bir istisna dışında. PerformSelector yönteminde gecikmeye gerek yoktur. Ne kadar uzun reloadDatasürerse sürsün. tableViewDidLoadData:her zaman tableViewsormayı bitirdiğinde ateşler dataSource cellForRowAtIndexPath.

Alt sınıfa geçmek istemeseniz bile UITableView, basitçe arayabilir [performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f]ve seçiciniz masanın yeniden yüklenmesi bittikten hemen sonra çağrılır. Ancak, seçicinin her arama için yalnızca bir kez arandığından emin olmalısınız reloadData:

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

Zevk almak. :)

Bu, biraz farklı bir sorunun cevabı: Aramayı ne zaman UITableViewbitirdiğimi de bilmem gerekiyordu cellForRowAtIndexPath(). Alt sınıflandırdım layoutSubviews()(teşekkürler @Eric MORAND) ve bir temsilci geri araması ekledim:

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

Kullanımı:

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

NOTLAR: Bu, bir alt sınıf olduğundan, UITableViewdelege özelliğine işaret eden MyTableViewControllerbaşka bir tane eklemeye gerek yoktur. "@Dinamik temsilci" derleyiciye bu özelliği kullanmasını söyler. (Bunu açıklayan bir bağlantı burada: http://farhadnoorzay.com/2012/01/20/objective-c-how-to-add-delegate-methods-in-a-subclass/ )

Yeni sınıfı kullanmak için içindeki UITableViewözellik MyTableViewControllerdeğiştirilmelidir SDTableView. Bu, Interface Builder Identity Inspector'da yapılır. UITableViewİçini seçin ve UITableViewController"Özel Sınıf" olarak ayarlayın SDTableView.

Ben değişim için bildirim almak için benzer bir şey bulduğunu contentSizearasında TableView. Bunun burada da çalışması gerektiğini düşünüyorum, çünkü contentSize ayrıca veri yüklerken de değişiyor.

Bunu dene:

In viewDidLoadyazma,

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

ve bu yöntemi viewController'ınıza ekleyin:

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


    }
}

Değişiklik kontrolünde küçük değişikliklere ihtiyacınız olabilir. Bu benim için işe yaradı.

Şerefe! :)

İşte bir hack olsa da olası bir çözüm:

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

Nerede -scrollTableViewyöntemi ile tablo görünümü kayar -scrollRectToVisible:animated:. Ve tabii ki, yukarıdaki koddaki gecikmeyi 0.3'ten sizin için işe yarayan herhangi bir şeye kadar yapılandırabilirsiniz. Evet, gülünç derecede karmaşık, ama benim için iPhone 5 ve 4S'de çalışıyor ...

İnandığım benzer bir şey vardı. Örnek değişkeni olarak, ofsetin geri yüklenip yüklenmediğini ve bunu kontrol edip etmediğini söyleyen bir BOOL ekledim -viewWillAppear:. Geri yüklenmediğinde, bu yöntemle geri yüklerim ve BOOL'u ofseti kurtardığımı belirtecek şekilde ayarlıyorum.

Bu bir tür hack ve muhtemelen daha iyi yapılabilir, ancak bu şu anda benim için çalışıyor.

Hücre içeriğini güncellemek istiyormuşsunuz gibi görünüyor, ancak hücre eklemelerine ve silmelerine eşlik edebilecek ani atlamalar olmadan.

Bunu yapmakla ilgili birkaç makale var. Bu bir.

Bir kaydırma görünümünün piksel açısından mükemmel ayarları için scrollRectToVisible: animated: yerine setContentOffset: animated: kullanmanızı öneririm.

Aşağıdaki mantığı deneyebilirsiniz:

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

ReloadData öğesini çağırmadan önce prevIndexPath öğesini nil olarak ayarlayın. Sevmek:

prevIndexPath = nil;
[mainTableView reloadData];

NSLogs ile test ettim ve bu mantık iyi görünüyor. Gerektiği gibi özelleştirebilir / geliştirebilirsiniz.

sonunda kodumun bununla çalışmasını sağladım -

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

halledilmesi gereken birkaç şey vardı -

1. " - (UITableViewCell *)MyTableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath" içinde ara
2. sadece "scrollToRowAtIndexPath" mesajının, bu durumda kesinlikle MyTableview olan UITableView'in ilgili örneğine gönderildiğinden emin olun.
3. Benim durumumda UIView, UITableView örneğini içeren görünümdür
4. Ayrıca, bu her hücre yükü için çağrılacaktır. Bu nedenle, "scrollToRowAtIndexPath" öğesini birden çok kez çağırmamak için "cellForRowAtIndexPath" içine bir mantık koyun.

Tüm veriler yüklendiğinde bu yöntemde tablo görünümünüzü yeniden boyutlandırabilir veya içerik boyutunu ayarlayabilirsiniz:

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

Yinelenen zamanlayıcıyı çalıştırıyorum ve yalnızca tableHeaderView yüksekliği olduğunda tablonun contentSize daha büyük olduğunda geçersiz kılıyorum (tabloda satır içeriği olduğu anlamına gelir). C # kodunda (monotouch), ancak umarım fikir açıktır:

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

UITableView layoutSubviewsTablo görünümü içeriğini görüntülemeden hemen önce çağrılmaz mı ? Tablo görünümü verilerini yüklemeyi bitirdiğinde çağrıldığını fark ettim, belki bu yönde araştırmalısınız.

İOS 6'dan itibaren UITableviewdelege yöntemi şunları çağırdı:

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

tablonuz başarıyla yeniden yüklendiğinde çalıştırılacaktır. Bu yöntemde gerektiği gibi özelleştirme yapabilirsiniz.

Swift'de bulduğum en iyi çözüm

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

Neden uzatmıyorsun?

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

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

sona kaydır:

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

Çok fazla veri ile test edilmedi