J'ai configuré un UIRefreshControl dans mon UITableViewController (qui est à l'intérieur d'un UINavigationController) et cela fonctionne comme prévu (c'est-à-dire que le pull down déclenche l'événement correct). Cependant, si j'appelle par programme la beginRefreshingméthode d'instance sur le contrôle d'actualisation comme:

[self.refreshControl beginRefreshing];

Rien ne se passe. Il doit s'animer et afficher le spinner. La endRefreshingméthode fonctionne correctement lorsque j'appelle cela après l'actualisation.

J'ai créé un projet de prototype de base avec ce comportement et cela fonctionne correctement lorsque mon UITableViewController est ajouté directement au contrôleur de vue racine du délégué d'application, par exemple:

self.viewController = tableViewController;
self.window.rootViewController = self.viewController;

Mais si j'ajoute d'abord le tableViewControllerà un UINavigationController, puis ajoute le contrôleur de navigation en tant que rootViewController, la beginRefreshingméthode ne fonctionne plus. Par exemple

UINavigationController *navController = [[UINavigationController alloc] initWithRootViewController:tableViewController];
self.viewController = navController;
self.window.rootViewController = self.viewController;

Mon sentiment est que cela a quelque chose à voir avec les hiérarchies de vues imbriquées dans le contrôleur de navigation qui ne jouent pas bien avec le contrôle de rafraîchissement - des suggestions?

Merci

Il semble que si vous commencez à actualiser par programme, vous devez faire défiler la vue du tableau vous-même, par exemple, en modifiant contentoffset

[self.tableView setContentOffset:CGPointMake(0, -self.refreshControl.frame.size.height) animated:YES];

Je suppose que la raison à cela est qu'il pourrait être indésirable de faire défiler jusqu'au contrôle de rafraîchissement lorsque l'utilisateur est au milieu / en bas de la vue de la table?

Version Swift 2.2 par @muhasturk

self.tableView.setContentOffset(CGPoint(x: 0, y: -refreshControl.frame.size.height), animated: true)

En un mot, pour garder ce portable, ajoutez cette extension

UIRefreshControl + ProgramatelyBeginRefresh.swift

extension UIRefreshControl {
    func programaticallyBeginRefreshing(in tableView: UITableView) {
        beginRefreshing()
        let offsetPoint = CGPoint.init(x: 0, y: -frame.size.height)
        tableView.setContentOffset(offsetPoint, animated: true)        
    }
}

UITableViewController a la propriété automaticAdjustsScrollViewInsets après iOS 7. La vue de table peut déjà avoir contentOffset, généralement (0, -64).

Ainsi, la bonne façon d'afficher refreshControl après le début de l'actualisation par programmation consiste à ajouter la hauteur de refreshControl à contentOffset existant.

 [self.refreshControl beginRefreshing];
 [self.tableView setContentOffset:CGPointMake(0, self.tableView.contentOffset.y-self.refreshControl.frame.size.height) animated:YES];

Voici une extension Swift utilisant les stratégies décrites ci-dessus.

extension UIRefreshControl {
    func beginRefreshingManually() {
        if let scrollView = superview as? UIScrollView {
            scrollView.setContentOffset(CGPoint(x: 0, y: scrollView.contentOffset.y - frame.height), animated: true)
        }
        beginRefreshing()
    }
}

Aucune des autres réponses n'a fonctionné pour moi. Ils feraient apparaître et tourner le spinner, mais l'action de rafraîchissement elle-même ne se produirait jamais. Cela marche:

id target = self;
SEL selector = @selector(example);
// Assuming at some point prior to triggering the refresh, you call the following line:
[self.refreshControl addTarget:target action:selector forControlEvents:UIControlEventValueChanged];

// This line makes the spinner start spinning
[self.refreshControl beginRefreshing];
// This line makes the spinner visible by pushing the table view/collection view down
[self.tableView setContentOffset:CGPointMake(0, -1.0f * self.refreshControl.frame.size.height) animated:YES];
// This line is what actually triggers the refresh action/selector
[self.refreshControl sendActionsForControlEvents:UIControlEventValueChanged];

Notez que cet exemple utilise une vue de table, mais il aurait tout aussi bien pu être une vue de collection.

L'approche déjà mentionnée:

[self.refreshControl beginRefreshing];
 [self.tableView setContentOffset:CGPointMake(0, self.tableView.contentOffset.y-self.refreshControl.frame.size.height) animated:YES];

rendrait le spinner visible. Mais cela n'animerait pas. La seule chose que j'ai changé est l'ordre de ces deux méthodes et tout a fonctionné:

[self.tableView setContentOffset:CGPointMake(0, self.tableView.contentOffset.y-self.refreshControl.frame.size.height) animated:YES];
[self.refreshControl beginRefreshing];

Pour Swift 4 / 4.1

Un mélange de réponses existantes fait le travail pour moi:

refreshControl.beginRefreshing()
tableView.setContentOffset(CGPoint(x: 0, y: tableView.contentOffset.y - (refreshControl.frame.size.height)), animated: true)

J'espère que cela t'aides!

Voici l' extension Swift 3 et ultérieure qui montre le spinner et l'anime.

import UIKit
extension UIRefreshControl {

func beginRefreshingWithAnimation() {

    DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {

        if let scrollView = self.superview as? UIScrollView {
            scrollView.setContentOffset(CGPoint(x: 0, y: scrollView.contentOffset.y - self.frame.height), animated: true)
          }
        self.beginRefreshing()
      }
   }
}

Voir aussi cette question

UIRefreshControl n'affiche pas de spiny lors de l'appel de beginRefreshing et contentOffset est 0

Cela ressemble à un bogue pour moi, car cela ne se produit que lorsque la propriété contentOffset de la tableView est à 0

J'ai corrigé cela avec le code suivant (méthode pour UITableViewController):

- (void)beginRefreshingTableView {

    [self.refreshControl beginRefreshing];

    if (self.tableView.contentOffset.y == 0) {

        [UIView animateWithDuration:0.25 delay:0 options:UIViewAnimationOptionBeginFromCurrentState animations:^(void){

            self.tableView.contentOffset = CGPointMake(0, -self.refreshControl.frame.size.height);

        } completion:^(BOOL finished){

        }];

    }
}

Cela fonctionne parfaitement pour moi:

Swift 3:

self.tableView.setContentOffset(CGPoint(x: 0, y: -self.refreshControl!.frame.size.height - self.topLayoutGuide.length), animated: true)

Pour Swift 5, pour moi, la seule chose qui manquait était d'appeler refreshControl.sendActions(.valueChanged). J'ai fait une extension pour le rendre plus propre.

extension UIRefreshControl {

    func beginRefreshingManually() {
        if let scrollView = superview as? UIScrollView {
            scrollView.setContentOffset(CGPoint(x: 0, y: scrollView.contentOffset.y - frame.height), animated: false)
        }
        beginRefreshing()
        sendActions(for: .valueChanged)
    }

}

En plus de la solution @Dymitry Shevchenko.

J'ai trouvé une bonne solution de contournement à ce problème. Vous pouvez créer une extension pour UIRefreshControlcette méthode de remplacement:

// Adds code forgotten by Apple, that changes content offset of parent scroll view (table view).
- (void)beginRefreshing
{
    [super beginRefreshing];

    if ([self.superview isKindOfClass:[UIScrollView class]]) {
        UIScrollView *view = (UIScrollView *)self.superview;
        [view setContentOffset:CGPointMake(0, view.contentOffset.y - self.frame.size.height) animated:YES];
    }
}

Vous pouvez utiliser une nouvelle classe en définissant une classe personnalisée dans l' Inspecteur d'identité pour le contrôle d'actualisation dans Interface Builder.

Fort Swift 2.2+

    self.tableView.setContentOffset(CGPoint(x: 0, y: -refreshControl.frame.size.height), animated: true)

Si vous utilisez Rxswift pour swift 3.1, vous pouvez utiliser ci-dessous:

func manualRefresh() {
    if let refreshControl = self.tableView.refreshControl {
        self.tableView.setContentOffset(CGPoint(x: 0, y: -refreshControl.height), animated: true)
        self.tableView.refreshControl?.beginRefreshing()
        self.tableView.refreshControl?.sendActions(for: .valueChanged)
    }
}

Cela fonctionne pour swift 3.1, iOS 10.

testé sur Swift 5

utiliser ceci dans viewDidLoad()

fileprivate func showRefreshLoader() {
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
        self.tableView.setContentOffset(CGPoint(x: 0, y: self.tableView.contentOffset.y - (self.refreshControl.frame.size.height)), animated: true)
        self.refreshControl.beginRefreshing() 
    }
}

J'utilise la même technique pour afficher le signe visuel «les données sont mises à jour». Un utilisateur de résultat apportera une application à partir de l'arrière-plan et les flux / listes seront mis à jour avec l'interface utilisateur, comme les utilisateurs tirent des tables pour se rafraîchir. Ma version contient 3 choses

1) Qui envoie "réveiller"

- (void)applicationDidBecomeActive:(UIApplication *)application {
    [[NSNotificationCenter defaultCenter] postNotificationName:kNotificationHaveToResetAllPages object:nil];
}

2) Observateur dans UIViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(forceUpdateData) name:kNotificationHaveToWakeUp:nil];
}

3) Le protocole

#pragma mark - ForcedDataUpdateProtocol

- (void)forceUpdateData {
    self.tableView.contentOffset = CGPointZero;

    if (self.refreshControl) {
        [self.refreshControl beginRefreshing];
        [self.tableView setContentOffset:CGPointMake(0, -self.refreshControl.frame.size.height) animated:YES];
        [self.refreshControl performSelector:@selector(endRefreshing) withObject:nil afterDelay:1];
    }
}