How to access and refresh a UITableView from another class in Swift

Question

I have a tab bar application and a tab whose view controller is controlled by a UITableView class. I have a class that is used to download data from the server that then saves it to NSDefaults. From there I want the class to be able to update the table view, but am not sure how to access the table view's class to update it.

class updates {

func checkForUpdates() {
    //start on background thread
    dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)) { [unowned self] in
        //start contacting database:
        UIApplication.sharedApplication().networkActivityIndicatorVisible = true
        let actualVersion = self.contactForUpdates()
        UIApplication.sharedApplication().networkActivityIndicatorVisible = false
        if actualVersion > self.defaults.objectForKey("version") as! Int {
            //update data
            if self.downloadUpdates() {
                //update version number
                self.defaults.setObject(actualVersion, forKey: "version")
                //Indicates progress finished
                //self.stopSpinner()
            }
        }//end updates
        else {
            //Indicates progress finished
            //self.stopSpinner()

        }
    }//end background queue
}

}

There are two areas commented //Indicates progress finished where I want to run tableView from the class:

class connectTableVC: UITableViewController {
    ...
}

Alaeddine · Answer 1 · 2016-05-27T21:42:37.263

You can use protocol or NSNotificationCenter

Example of NSNotificationCenter :

From the UIViewController that downloads the data, you can post a notification after finishing downloading the data and tell other objects that there is new data:

NSNotificationCenter.defaultCenter().
                    postNotificationName("newDataNotif", object: nil)

And any other object that wants to listen to this notification should register to observe (in your case the UITableViewController):

NSNotificationCenter.defaultCenter().
                     addObserver(self, #selector(shouldReload), 
                     name:"newDataNotif", object: nil)

and then you need to implement the method to be called when receive the notification:

func shouldReload() {
  self.tableView.reloadData()
}

Note that the notification can send data also of type [NSObject : AnyObject]? example:

NSNotificationCenter.defaultCenter().
                     postNotificationName("newDataNotif", 
                     object: nil, userInfo: ["data":[dataArray]])

And the observer will be like:

NSNotificationCenter.defaultCenter().
                     addObserver(self, #selector( shouldReload(_:)),
                     name:"newDataNotif", object: nil)

And the method like:

func shouldReload(notification:NSNotification) {
  println(notification.userInfo)
}

and finally in your deinit you should remove observer :

deinit {
    NSNotificationCenter.defaultCenter().removeObserver(self)
}

I had trouble implementing the delegates because the update class is called from the UITabController's view controller instead of an individual tabs. This was simple and quick. Thank you. — Alec O, May 28 '16 at 00:26
I am using this code to update my NSCollectionView. Its working perfectly as wanted but only the data updates, there no change or update in the collectionView. — Jay Mehta, Jan 14 '17 at 17:34

score 7 · Accepted Answer · answered May 27 '16 at 21:24

I think the easiest way to do what you want to do is use a delegate.

protocol UpdateDelegate {
    func didUpdate(sender: Updates)
}

So in your updates class, where you want to refresh the table view you would call the delegates didUpdate function. (You will have to set the delegate before it starts the update for the method to be called.) The weak keyword is important, if it isn't there, neither of the classes will be GC'd, which will lead to memory leaks.

class Updates {
   weak var delegate: UpdateDelegate?

   ...

    //Indicates progress finished
    self.delegate.didUpdate(self)

In your tableView class you would subscribe to that delegate by adding UpdateDelegate to the top of the class

class ConnectTableVC: UITableViewController, UpdateDelegate {
    ...

    let updates = Updates()
    updates.delegate = self

    ...
    func didUpdate(sender: updates) {
       dispatch_async(dispatch_get_main_queue()) {
          self.tableView.reloadData()
       }
    }
 }

I would recommend against using the NSNotificationCenter, the biggest reason is anyone anywhere can listen to the notification (which might be unlikely in your case, but it is still worth noting).

This was very helpful and make delegates easier to understand. I am implementing it now. — Alec O, May 27 '16 at 22:47
I like to put everything in separate files. So I would put the protocol in its own file. — SeanRobinson159, May 28 '16 at 04:37

score 4 · Answer 3 · edited Jun 10 '17 at 20:18

4

For Swift 3

NotificationCenter.default.post(name: NSNotification.Name(rawValue: "newDataNotificationForItemEdit"), object: nil)

NotificationCenter.default.addObserver(self, selector: #selector(self.shouldReload), name: NSNotification.Name(rawValue: "newDataNotificationForItemEdit"), object: nil)

func shouldReload() {
    self.tableView.reloadData()
}

edited Jun 10 '17 at 20:18

Code-Apprentice

81,660
23
145
268

answered Jun 07 '17 at 00:33

Jignesh

310
3
12

score 2 · Answer 4 · answered May 27 '16 at 21:19

There are many ways you can do this. The most standard way is to use delegation. Delegation is a very common pattern in iOS, you are using it with UITableViewDataSource. Your view controller is the delegate of the UITableView, meaning it conforms to the UITableViewDataSource protocol. So what you should do is create a protocol for your Updates class like this:

protocol UpdatesDelegate {
    func didFinishUpdates(finished: Bool)
}

Your Updates class would have a delegate property that conforms to this protocol:

class Updates {
    var delegate: UpdatesDelegate?

Then you put this line where the //indicates progress finished comment was:

self.delegate?.didFinishUpdates(finished: true)

Your ConnectTableViewController would conform to the protocol and reload the table view from there:

extension ConnectTableViewController: UpdatesDelegate {
    func didFinishUpdates(finished: Bool) {
        guard finished else {
            // Handle the unfinished state
            return 
        }
        self.tableView.reloadData()
    }
}

Where ever you created your instance of the Updates class, be sure to set the delegate property to your ConnectTableViewController.

P.S. Your classes need to start with an uppercase letter. I've edited your question to reflect this.

How to access and refresh a UITableView from another class in Swift

4 Answers4

Linked