iOS Swift 4 - Show Toast (or Activity Indicator) on tableview didSelectRowAt

Question

I'm using the ToastView class from this answer, but I experience the same issue with an activity indicator. I have ToastViews throughout the app but have no qualms switching to an indicator if it will work

My app has a tableview that presents options. After an option is selected, it needs to load a lot of information about the option, like so

class TableController : UITableViewController
{
    override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        index = (indexPath as NSIndexPath).row
        super.performSegue(withIdentifier: "cellSelectedSegue", sender: self)
    }
}

class cellSelectionView : UIViewController
{
    override func viewDidLoad() {
        super.viewDidLoad()

        if let data = parser.getData(...){
            // data processing
        }
    }
}

I'd like to let the user know a loading operation is taking place when they pick a cell. Otherwise a cell gets selected, takes on the cell-selected color, and the app sits still for a second before the segue takes place.

To do so, I've tried

// In the tableview:
override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    // Solution 1: ToastView.showInParent(parentView: self.view, text: "ayy lmao", duration: 1.0)
    // Solution 2: indicator.startAnimating()
   index = (indexPath as NSIndexPath).row
    super.performSegue(withIdentifier: "cellSelectedSegue", sender: self)
}

Neither solution works as the UI event is not fired until the cell selection UI event is complete, which doesn't complete until the data processing has taken place, entirely defeating the point. I've also tried moving the UI calls to willSelectRowAt with no difference. I'd like to know how I can let the user know of a loading task that involves a UI event.

If you're wondering why I don't do the data processing before showing the cells rather than on-selection, it's due to the large amount of processing per row. The tableview would take a very long time to appear if done this way

Answer 1

This should do what you want.

import UIKit

class ExampleTableViewController: UITableViewController {

    var names : [String] = []
    var activityIndicator : UIActivityIndicatorView?

    override func viewDidLoad() {
        super.viewDidLoad()
        configureActivityIndicator()
        retrieveTableViewData()
    }

    func configureActivityIndicator(){
        activityIndicator = UIActivityIndicatorView(activityIndicatorStyle: .gray)
        activityIndicator?.hidesWhenStopped = true
        activityIndicator?.center = self.view.center
        self.view.addSubview(activityIndicator!)
    }

    func retrieveTableViewData(){
        names = ["John", "Will", "Ana"]
        self.tableView.reloadData()
    }

    func retrieveLoadsOfDataAfterSelectingRow(indexPath: IndexPath){
        // Example of slow code. You would replace this by some background processing.
        // Then when it is finished you would call the next screen.
        activityIndicator?.startAnimating()
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 5) {
            self.activityIndicator?.stopAnimating()
        }
    }


    override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return names.count
    }

    override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cellIdentifier = "cell"
        var cell = tableView.dequeueReusableCell(withIdentifier: cellIdentifier)

        if cell == nil {
            cell = UITableViewCell(style: .default, reuseIdentifier: cellIdentifier)
        }
        cell!.textLabel?.text = names[indexPath.row]
        return cell!
    }

    override func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        retrieveLoadsOfDataAfterSelectingRow(indexPath: indexPath)
    }
}

Replace this part:

 func retrieveLoadsOfDataAfterSelectingRow(indexPath: IndexPath){
        // Example of slow code. You would replace this by some background processing.
        // Then when it is finished you would call the next screen.
        activityIndicator?.startAnimating()
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 5) {
            self.activityIndicator?.stopAnimating()
        }
    }

By something like:

func retrieveLoadsOfDataAfterSelectingRow(indexPath: IndexPath){

        activityIndicator?.startAnimating()

        DispatchQueue.global(qos: .background).async {

            // Heavy processing here.
            if let data = parser.getData(...){
                // data processing
            }

            DispatchQueue.main.async {
                self.activityIndicator?.stopAnimating()
               // Call what you want here, to open details screen.
            }


        }

    }

Answer 2

A few different options for you -

1. On your pushed view, put your getData method inside viewDidAppear instead of viewDidLoad. The view won't push until everything's been done inside viewDidLoad. Then you can show your loading indicator on the pushed view.
2. Put a UIActivityIndicator inside the cell and hinge whether to show/animate it on a variable that holds the index of the cell pressed, such as indexLoading. Then set indexLoading to the row of the cell pressed, and call reloadRowsAtIndexPaths on that index path. If the cell's indexPath.row matches indexLoading, show the indicator
3. On didSelectRow... send a notification that a view will be pushed. Listen for that notification from your table view controller and show the loading indicator over your table view.