Comment utiliser pull pour rafraîchir dans Swift?

Je construis un lecteur RSS à l'aide de swift et j'ai besoin d'implémenter la fonctionnalité pull to recharger.

Voici comment j'essaye de le faire.

class FirstViewController: UIViewController,
    UITableViewDelegate, UITableViewDataSource {

   @IBOutlet var refresh: UIScreenEdgePanGestureRecognizer
   @IBOutlet var newsCollect: UITableView

   var activityIndicator:UIActivityIndicatorView? = nil

   override func viewDidLoad() {
       super.viewDidLoad()
       self.newsCollect.scrollEnabled = true
      // Do any additional setup after loading the view, typically from a nib.

      if nCollect.news.count <= 2{
          self.collectNews()
       }
      else{
          self.removeActivityIndicator()
       }
      view.addGestureRecognizer(refresh)
   }



@IBAction func reload(sender: UIScreenEdgePanGestureRecognizer) {
    nCollect.news = News[]()
    return newsCollect.reloadData()
}

Je reçois :

La propriété 'self.refresh' n'est pas initialisée lors de l'appel super.init

Veuillez m'aider à comprendre le comportement des reconnaisseurs de gestes. Un exemple de code de travail sera d'une grande aide.

Merci.

Tirer pour actualiser est intégré à iOS. Vous pouvez le faire rapidement comme

var refreshControl = UIRefreshControl()

override func viewDidLoad() {
   super.viewDidLoad()

   refreshControl.attributedTitle = NSAttributedString(string: "Pull to refresh")
   refreshControl.addTarget(self, action: #selector(self.refresh(_:)), for: .valueChanged)
   tableView.addSubview(refreshControl) // not required when using UITableViewController
}

@objc func refresh(_ sender: AnyObject) {
   // Code to refresh table view  
}

À un moment donné, vous pourriez finir par vous rafraîchir.

refreshControl.endRefreshing()

Une solution avec storyboard et rapide ...

1.) Ouvrez votre fichier .storyboard, sélectionnez un TableViewController dans votre storyboard et "Activez" le contrôleur de vue de table - Fonction d'actualisation dans les utilitaires.

2.) Ouvrez la classe UITableViewController associée et ajoutez la ligne suivante dans la méthode viewDidLoad.

self.refreshControl?.addTarget(self, action: "refresh:", forControlEvents: UIControlEvents.ValueChanged)

Modifié pour Swift 5.0:

self.refreshControl?.addTarget(self, action: #selector(refresh), for: UIControl.Event.valueChanged)

OU dans Swift 2.2:

self.refreshControl?.addTarget(self, action: #selector(TestTableViewController.refresh(_:)), forControlEvents: UIControlEvents.ValueChanged)

3.) Ajoutez la méthode suivante au-dessus de la méthode viewDidLoad

func refresh(sender:AnyObject)
{
    // Updating your data here...

    self.tableView.reloadData()
    self.refreshControl?.endRefreshing()
}

Je voudrais mentionner une fonctionnalité PRETTY COOL incluse depuis iOS 10, qui est:

Pour l'instant, UIRefreshControl est directement pris en charge dans chacun d'entre eux UICollectionView, UITableViewet UIScrollView!

Chacune de ces vues a une propriété d'occurrence refreshControl , ce qui signifie qu'il n'est plus nécessaire de l'ajouter en tant que sous-vue dans votre vue de défilement , il vous suffit de:

@IBOutlet weak var collectionView: UICollectionView!

override func viewDidLoad() {
    super.viewDidLoad()

    let refreshControl = UIRefreshControl()
    refreshControl.addTarget(self, action: #selector(doSomething), for: .valueChanged)

    // this is the replacement of implementing: "collectionView.addSubview(refreshControl)"
    collectionView.refreshControl = refreshControl
}

func doSomething(refreshControl: UIRefreshControl) {
    print("Hello World!")

    // somewhere in your code you might need to call:
    refreshControl.endRefreshing()
}

Personnellement, je trouve plus naturel de le traiter comme une propriété pour la vue de défilement plutôt que de l'ajouter comme sous-vue, en particulier parce que la seule vue appropriée à être comme une vue d'ensemble pour un UIRefreshControl est une vue de défilement, c'est-à-dire que la fonctionnalité d'utilisation d'UIRefreshControl n'est que utile lorsque vous travaillez avec une vue de défilement; C'est pourquoi cette approche devrait être plus évidente pour configurer la vue de contrôle de rafraîchissement.

Cependant, vous avez toujours la possibilité d'utiliser le addSubviewbasé sur la version iOS:

if #available(iOS 10.0, *) {
  collectionView.refreshControl = refreshControl
} else {
  collectionView.addSubview(refreshControl)
}

Swift 4

var refreshControl: UIRefreshControl!

override func viewDidLoad() {
    super.viewDidLoad()

    refreshControl = UIRefreshControl()
    refreshControl.attributedTitle = NSAttributedString(string: "Pull to refresh")
    refreshControl.addTarget(self, action: #selector(refresh), for: .valueChanged)
    tableView.addSubview(refreshControl) 
}

@objc func refresh(_ sender: Any) {
    //  your code to reload tableView
}

Et vous pouvez arrêter de vous rafraîchir avec:

refreshControl.endRefreshing()

Dans Swift, utilisez ceci,

Si vous souhaitez que le pull soit actualisé dans WebView,

Essayez donc ce code:

override func viewDidLoad() {
    super.viewDidLoad()
    addPullToRefreshToWebView()
}

func addPullToRefreshToWebView(){
    var refreshController:UIRefreshControl = UIRefreshControl()

    refreshController.bounds = CGRectMake(0, 50, refreshController.bounds.size.width, refreshController.bounds.size.height) // Change position of refresh view
    refreshController.addTarget(self, action: Selector("refreshWebView:"), forControlEvents: UIControlEvents.ValueChanged)
    refreshController.attributedTitle = NSAttributedString(string: "Pull down to refresh...")
    YourWebView.scrollView.addSubview(refreshController)

}

func refreshWebView(refresh:UIRefreshControl){
    YourWebView.reload()
    refresh.endRefreshing()
}

La réponse d'Anhil m'a beaucoup aidé.

Cependant, après avoir expérimenté davantage, j'ai remarqué que la solution suggérée provoque parfois un problème d'interface utilisateur pas si joli .

Au lieu de cela, opter pour cette approche * a fait l'affaire pour moi.

* Swift 2.1

//Create an instance of a UITableViewController. This will host your UITableView.
private let tableViewController = UITableViewController()

//Add tableViewController as a childViewController and set its tableView property to your UITableView.
self.addChildViewController(self.tableViewController)
self.tableViewController.tableView = self.tableView
self.refreshControl.addTarget(self, action: "refreshData:", forControlEvents: .ValueChanged)
self.tableViewController.refreshControl = self.refreshControl

Ce que l'erreur vous dit, c'est que ce refreshn'est pas initialisé. Notez que vous avez choisi de ne refreshpas rendre facultatif, ce qui dans Swift signifie qu'il doit avoir une valeur avant d'appeler super.init(ou il est implicitement appelé, ce qui semble être votre cas). Soit rendre refreshfacultatif (probablement ce que vous voulez) ou l'initialiser d'une manière ou d'une autre.

Je suggérerais de relire la documentation d'introduction de Swift, qui couvre cela en détail.

Une dernière chose, ne faisant pas partie de la réponse, comme l'a souligné @Anil, il existe un pull intégré pour rafraîchir le contrôle dans iOS appelé UIRefresControl, qui pourrait être quelque chose qui mérite d'être étudié .

J'ai créé une application de flux RSS dans laquelle j'ai une fonction d' actualisation Pull To qui avait à l'origine certains des problèmes répertoriés ci-dessus.

Mais pour ajouter aux réponses des utilisateurs ci-dessus, je cherchais partout mon cas d'utilisation et je ne l'ai pas trouvé. Je téléchargeais des données sur le Web (RSSFeed) et je voulais dérouler ma tableVoir les histoires à rafraîchir.

Ce qui est mentionné ci-dessus couvre les bons domaines, mais avec certains des problèmes que les gens ont, voici ce que j'ai fait et cela fonctionne un régal:

J'ai adopté l'approche de @Blankarsch et je suis allé sur mon tableau principal et sélectionner la vue de table pour utiliser le rafraîchissement, puis ce qui n'a pas été mentionné est la création d'IBOutlet et d'IBAction pour utiliser le rafraîchissement efficacement

//Created from main.storyboard cntrl+drag refresh from left scene to assistant editor
@IBOutlet weak var refreshButton: UIRefreshControl

override func viewDidLoad() {
  ...... 
  ......
  //Include your code
  ......
  ......
  //Is the function called below, make sure to put this in your viewDidLoad 
  //method or not data will be visible when running the app
  getFeedData()
}

//Function the gets my data/parse my data from the web (if you havnt already put this in a similar function)
//remembering it returns nothing, hence return type is "-> Void"
func getFeedData() -> Void{
  .....
  .....
}

//From main.storyboard cntrl+drag to assistant editor and this time create an action instead of outlet and 
//make sure arguments are set to none and note sender
@IBAction func refresh() {
  //getting our data by calling the function which gets our data/parse our data
  getFeedData()

  //note: refreshControl doesnt need to be declared it is already initailized. Got to love xcode
  refreshControl?.endRefreshing()
}

J'espère que cela aide toute personne dans la même situation que moi

func pullToRefresh(){

    let refresh = UIRefreshControl()
    refresh.addTarget(self, action: #selector(handleTopRefresh(_:)), for: .valueChanged )
    refresh.tintColor = UIColor.appBlack
    self.tblAddressBook.addSubview(refresh)

}
@objc func handleTopRefresh(_ sender:UIRefreshControl){
    self.callAddressBookListApi(isLoaderRequired: false)
    sender.endRefreshing()
}

Détails

• Xcode version 10.3 (10G8), Swift 5

Caractéristiques

• Possibilité de faire "pull to refresh" par programme
• Protection contre les événements multi- "pull to refresh"
• Possibilité de continuer l'animation de l'indicateur d'activité lorsque le contrôleur de vue change (par exemple dans le cas de TabController)

Solution

import UIKit

class RefreshControl: UIRefreshControl {

    private weak var actionTarget: AnyObject?
    private var actionSelector: Selector?
    override init() { super.init() }

    convenience init(actionTarget: AnyObject?, actionSelector: Selector) {
        self.init()
        self.actionTarget = actionTarget
        self.actionSelector = actionSelector
        addTarget()
    }

    private func addTarget() {
        guard let actionTarget = actionTarget, let actionSelector = actionSelector else { return }
        addTarget(actionTarget, action: actionSelector, for: .valueChanged)
    }

    required init?(coder aDecoder: NSCoder) { super.init(coder: aDecoder) }

    func endRefreshing(deadline: DispatchTime? = nil) {
        guard let deadline = deadline else { endRefreshing(); return }
        DispatchQueue.global(qos: .default).asyncAfter(deadline: deadline) { [weak self] in
            DispatchQueue.main.async { self?.endRefreshing() }
        }
    }

    func refreshActivityIndicatorView() {
        guard let selector = actionSelector else { return }
        let _isRefreshing = isRefreshing
        removeTarget(actionTarget, action: selector, for: .valueChanged)
        endRefreshing()
        if _isRefreshing { beginRefreshing() }
        addTarget()
    }

    func generateRefreshEvent() {
        beginRefreshing()
        sendActions(for: .valueChanged)
    }
}

public extension UIScrollView {

    private var _refreshControl: RefreshControl? { return refreshControl as? RefreshControl }

    func addRefreshControll(actionTarget: AnyObject?, action: Selector, replaceIfExist: Bool = false) {
        if !replaceIfExist && refreshControl != nil { return }
        refreshControl = RefreshControl(actionTarget: actionTarget, actionSelector: action)
    }

    func scrollToTopAndShowRunningRefreshControl(changeContentOffsetWithAnimation: Bool = false) {
        _refreshControl?.refreshActivityIndicatorView()
        guard   let refreshControl = refreshControl,
                contentOffset.y != -refreshControl.frame.height else { return }
        setContentOffset(CGPoint(x: 0, y: -refreshControl.frame.height), animated: changeContentOffsetWithAnimation)
    }

    private var canStartRefreshing: Bool {
        guard let refreshControl = refreshControl, !refreshControl.isRefreshing else { return false }
        return true
    }

    func startRefreshing() {
        guard canStartRefreshing else { return }
        _refreshControl?.generateRefreshEvent()
    }

    func pullAndRefresh() {
        guard canStartRefreshing else { return }
        scrollToTopAndShowRunningRefreshControl(changeContentOffsetWithAnimation: true)
        _refreshControl?.generateRefreshEvent()
    }

    func endRefreshing(deadline: DispatchTime? = nil) { _refreshControl?.endRefreshing(deadline: deadline) }
}

Usage

// Add refresh control to UICollectionView / UITableView / UIScrollView
private func setupTableView() {
    let tableView = UITableView()
    // ...
    tableView.addRefreshControll(actionTarget: self, action: #selector(refreshData))
}

@objc func refreshData(_ refreshControl: UIRefreshControl) {
    tableView?.endRefreshing(deadline: .now() + .seconds(3))
}

// Stop refreshing in UICollectionView / UITableView / UIScrollView
tableView.endRefreshing()

// Simulate pull to refresh in UICollectionView / UITableView / UIScrollView
tableView.pullAndRefresh()

Échantillon complet

N'oubliez pas d' ajouter le code de la solution ici

import UIKit

class ViewController: UIViewController {

    private weak var tableView: UITableView?

    override func viewDidLoad() {
        super.viewDidLoad()
        setupTableView()
    }

    private func setupTableView() {
        let tableView = UITableView()
        view.addSubview(tableView)
        tableView.translatesAutoresizingMaskIntoConstraints = false
        tableView.topAnchor.constraint(equalTo: view.topAnchor).isActive = true
        tableView.leftAnchor.constraint(equalTo: view.leftAnchor).isActive = true
        tableView.rightAnchor.constraint(equalTo: view.rightAnchor).isActive = true
        tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
        tableView.dataSource = self
        tableView.delegate = self
        tableView.addRefreshControll(actionTarget: self, action: #selector(refreshData))
        self.tableView = tableView
    }
}

extension ViewController {
    @objc func refreshData(_ refreshControl: UIRefreshControl) {
        print("refreshing")
        tableView?.endRefreshing(deadline: .now() + .seconds(3))
    }
}

extension ViewController: UITableViewDataSource {
    func numberOfSections(in tableView: UITableView) -> Int { return 1 }
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return 20 }
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = UITableViewCell()
        cell.textLabel?.text = "\(indexPath)"
        return cell
    }
}

extension ViewController: UITableViewDelegate {
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        tableView.pullAndRefresh()
    }
}

Swift 5

private var pullControl = UIRefreshControl()

pullControl.attributedTitle = NSAttributedString(string: "Pull to refresh")
        pullControl.addTarget(self, action: #selector(refreshListData(_:)), for: .valueChanged)
        if #available(iOS 10.0, *) {
            tableView.refreshControl = pullControl
        } else {
            tableView.addSubview(pullControl)
        }
// Actions
@objc private func refreshListData(_ sender: Any) {
        self.pullControl.endRefreshing() // You can stop after API Call
        // Call API
    }

Je suggère de faire une extension de pull To Refresh à utiliser dans chaque classe.

1) Créez un fichier Swift vide: Fichier - Nouveau - Fichier - Fichier Swift.

2) Ajoutez les éléments suivants

    //  AppExtensions.swift

    import Foundation
    import UIKit    

    var tableRefreshControl:UIRefreshControl = UIRefreshControl()    

    //MARK:- VIEWCONTROLLER EXTENSION METHODS
    public extension UIViewController
    {
        func makePullToRefreshToTableView(tableName: UITableView,triggerToMethodName: String){

            tableRefreshControl.attributedTitle = NSAttributedString(string: "TEST: Pull to refresh")
            tableRefreshControl.backgroundColor = UIColor.whiteColor()
            tableRefreshControl.addTarget(self, action: Selector(triggerToMethodName), forControlEvents: UIControlEvents.ValueChanged)
            tableName.addSubview(tableRefreshControl)
        }
        func makePullToRefreshEndRefreshing (tableName: String)
        {
            tableRefreshControl.endRefreshing()
//additional codes

        }
    }    

3) Dans votre View Controller, appelez ces méthodes comme suit:

  override func viewWillAppear(animated: Bool) {

self.makePullToRefreshToTableView(bidderListTable, triggerToMethodName: "pullToRefreshBidderTable")
}

4) À un moment donné, vous avez voulu mettre fin à l'actualisation:

  func pullToRefreshBidderTable() {
self.makePullToRefreshEndRefreshing("bidderListTable")    
//Code What to do here.
}
OR    
self.makePullToRefreshEndRefreshing("bidderListTable")

Pour le pull pour rafraîchir j'utilise

DGElasticPullToRefresh

https://github.com/gontovnik/DGElasticPullToRefresh

Installation

pod 'DGElasticPullToRefresh'

import DGElasticPullToRefresh

et mettez cette fonction dans votre fichier rapide et appelez cette fonction depuis votre

remplacer func viewWillAppear (_ animated: Bool)

     func Refresher() {
      let loadingView = DGElasticPullToRefreshLoadingViewCircle()
      loadingView.tintColor = UIColor(red: 255.0/255.0, green: 255.0/255.0, blue: 255.0/255.0, alpha: 1.0)
      self.table.dg_addPullToRefreshWithActionHandler({ [weak self] () -> Void in

          //Completion block you can perfrom your code here.

           print("Stack Overflow")

           self?.table.dg_stopLoading()
           }, loadingView: loadingView)
      self.table.dg_setPullToRefreshFillColor(UIColor(red: 255.0/255.0, green: 57.0/255.0, blue: 66.0/255.0, alpha: 1))
      self.table.dg_setPullToRefreshBackgroundColor(self.table.backgroundColor!)
 }

Et n'oubliez pas de supprimer la référence pendant que la vue disparaît

pour supprimer tirer pour actualiser mettre ce code dans votre

remplacer func viewDidDisappear (_ animated: Bool)

override func viewDidDisappear(_ animated: Bool) {
      table.dg_removePullToRefresh()

 }

Et ça ressemblera

Bon codage :)

Vous pouvez y parvenir en utilisant quelques lignes de code. Alors pourquoi vous allez rester coincé dans une bibliothèque ou une interface utilisateur tierce. Tirer pour actualiser est intégré à iOS. Vous pouvez le faire rapidement comme

var pullControl = UIRefreshControl()

override func viewDidLoad() {
   super.viewDidLoad()

   pullControl.attributedTitle = NSAttributedString(string: "Pull to refresh")
   pullControl.addTarget(self, action: #selector(pulledRefreshControl(_:)), for: UIControl.Event.valueChanged)
   tableView.addSubview(pullControl) // not required when using UITableViewController
}

@objc func pulledRefreshControl(sender:AnyObject) {
   // Code to refresh table view  
}

vous pouvez utiliser cette sous-classe de tableView:

import UIKit

protocol PullToRefreshTableViewDelegate : class {
    func tableViewDidStartRefreshing(tableView: PullToRefreshTableView)
}

class PullToRefreshTableView: UITableView {

    @IBOutlet weak var pullToRefreshDelegate: AnyObject?
    private var refreshControl: UIRefreshControl!
    private var isFirstLoad = true

    override func willMoveToSuperview(newSuperview: UIView?) {
        super.willMoveToSuperview(newSuperview)

        if (isFirstLoad) {
            addRefreshControl()
            isFirstLoad = false
        }
    }

    private func addRefreshControl() {
        refreshControl = UIRefreshControl()
        refreshControl.attributedTitle = NSAttributedString(string: "Pull to refresh")
        refreshControl.addTarget(self, action: "refresh", forControlEvents: .ValueChanged)
        self.addSubview(refreshControl)
    }

    @objc private func refresh() {
       (pullToRefreshDelegate as? PullToRefreshTableViewDelegate)?.tableViewDidStartRefreshing(self)
    }

    func endRefreshing() {
        refreshControl.endRefreshing()
    }

}

1 - dans le générateur d'interface, changez la classe de votre tableView PullToRefreshTableViewou créez un PullToRefreshTableViewprogramme

2 - implémentez le PullToRefreshTableViewDelegatedans votre contrôleur de vue

3 - tableViewDidStartRefreshing(tableView: PullToRefreshTableView)sera appelé dans votre contrôleur de vue lorsque la vue de table commencera à se rafraîchir

4 - appelez yourTableView.endRefreshing()pour terminer le rafraîchissement

C'est ainsi que je l'ai fait fonctionner en utilisant Xcode 7.2 qui, je pense, est un bug majeur. Je l'utilise à l'intérieur de mon UITableViewControllerintérieurviewWillAppear

refreshControl = UIRefreshControl()
refreshControl!.addTarget(self, action: "configureMessages", forControlEvents: .ValueChanged)
refreshControl!.beginRefreshing()

configureMessages()

func configureMessages() {
    // configuring messages logic here

    self.refreshControl!.endRefreshing()
}

Comme vous pouvez le voir, je dois littéralement appeler la configureMessage()méthode après avoir configuré mon UIRefreshControlpuis après cela, les rafraîchissements suivants fonctionneront bien.

D'autres réponses sont correctes, mais pour plus de détails, consultez ce post Pull to Refresh

Activer l'actualisation dans Storyboard

Lorsque vous travaillez avec un UITableViewController, la solution est assez simple: tout d'abord, sélectionnez le contrôleur de vue de table dans votre storyboard, ouvrez l'inspecteur d'attributs et activez l'actualisation:

Un UITableViewController est fourni avec une référence à un UIRefreshControl prêt à l'emploi. Il vous suffit de câbler quelques éléments pour lancer et terminer l'actualisation lorsque l'utilisateur tire vers le bas.

Remplacer viewDidLoad ()

Dans votre remplacement de viewDidLoad (), ajoutez une cible pour gérer l'actualisation comme suit:

override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.
        
    self.refreshControl?.addTarget(self, action: "handleRefresh:", forControlEvents: UIControlEvents.ValueChanged)
}

1. Puisque j'ai spécifié «handleRefresh:» (notez les deux-points!) Comme argument d'action, je dois définir une fonction dans cette classe UITableViewController avec le même nom. De plus, la fonction doit prendre un argument
2. Nous aimerions que cette action soit appelée pour l'UIControlEvent appelé ValueChanged
3. N'oubliez pas d'appeler refreshControl.endRefreshing()

Pour plus d'informations s'il vous plaît aller à mentionner Link et tout le mérite va à ce poste