performSegueWithIdentifier very slow when segue is modal

Question

I have a simple table view where I handle the select action on the table view. This action follows a segue.

If the segue is a push segue, the next view shows immediately. If the segue is a modal segue, the next view either:

• takes 6 seconds or so to display
• shows immediately if I tap again (second tap)

I tried looking around for some ideas, but none seem applicable to my situation. In particular:

• I'm performing the segue on the main UI thread
• My view is very simple (so there's no issue in viewDidLoad). Plus the fact that it shows up near instantaneous when the segue is push indicates that there is no problem loading the target view
• I tried passing nil to the sender; same effect.

Does anyone have any ideas on this?

Answer 1

Trust me and try this. I have run into this problem a few times.

In Swift 2:

dispatch_async(dispatch_get_main_queue(),{
    self.performSegue(withIdentifier:mysegueIdentifier,sender: self)
})

or for Swift 3:

DispatchQueue.main.async {
    self.performSegue(withIdentifier: mysegueIdentifier,sender: self)
}

As discussed here and here.

Answer 2

It seems (to me...) that this problem happens only when the cell selectionType is not .none.

You may change it to any other option (at the storyboard Attribute inspector, set the Selection field) and it will work fine (working for me...). The cons is that it messing up the cell UI.

You can call the segue in DispatchQueue.main.async{} block at the didSelect delegate function of UITableViewDelegate as people mention before.

I used the first solution and added at the cell itself -

override func setSelected(_ selected: Bool, animated: Bool) {
    super.setSelected(false, animated: false)
}

This will make the cell 'highlight' at the tap, but it will return to its usual UI immediately and it fine for me...

Answer 3

There seem to be various situations when performing a segue will not work properly. For example, if you call performSegue from the action handler of an unwind segue, you will run into various issues, even though you are on the main thread. On my current project, I am calling performSegue from the didSelectRowAt method of a table view. This is one of the most basic segues there is and of course I am on the main thread, yet I was seeing the exact symptoms that the OP described.

I do not know why this happens in some cases and not others, but I have found that deferring the performSegue call using async fixes any potential issues. This used to seem like a hack and made me nervous, but at this point I have several mature projects using this approach and it now seems like the "right" way to do a manual segue.

Here is the Swift 3 version of the code (see the other posts for Swift 2 and Obj-C versions):

DispatchQueue.main.async {
    self.performSegue(withIdentifier: "theIdentifier", sender: theSender)
}

Answer 4

The accepted solution worked for me. Code updated for Swift 2.0 below:

dispatch_async(dispatch_get_main_queue(),{
     self.performSegueWithIdentifier(mysegueIdentifier, sender:self)
})

Answer 5

Hope help this yo can create programatically modal transition like this in Swift:

       let myStoryboard: UIStoryboard = UIStoryboard(name: "Main", bundle: nil)
        let modalViewController = myStoryboard.instantiateViewControllerWithIdentifier("myModalViewController") as! myModalViewController
        modalViewController.modalTransitionStyle = UIModalTransitionStyle.CoverVertical
        let navController = UINavigationController(rootViewController: accountManager)
        dispatch_async(dispatch_get_main_queue(),{
            self.presentViewController(navController, animated: true, completion: nil)
        })

Answer 6

For developers organizing their code through subclassing, I've come to quite simple a solution I'd like to share (Swift 4):

import UIKit

class ABCViewController: UIViewController {

  // ... Other useful methods like overriding deinit and didReceiveMemoryWarning

  // Performs a segue on the main thread to ensure it will 
  // transition once a UI-slot is available
  func performSegueOnMainThread(with identifier: String, sender: Any?) {
    DispatchQueue.main.async {
      self.performSegue(with: identifier, sender: sender)
    }
  }
}

Then, simply call it from your implementation:

myViewController.performSegueOnMainThread(with: "ShowDetailsSegue", sender: self)

Answer 7

For me it was the that I had too many "Clear" colored views in my next view, so when the segue was animated, it seemed like it was delaying because of this. I went through the view controller's UI hierarchy looking for clear colors and replacing them with solid black or white, and making sure the alpha is 1 (if it didn't need to be otherwise). My delay is now gone and my modal presentation is smooth.

Answer 8

I tried fixing this multiple ways including moving it to the main thread above. This worked for me:

In storyboard, select the table view in question, (select it in document outline to make sure you've got the right thing. Then in attributes inspector you will be able to see the attributes for the table view as well as the containing scrollview underneath it (all table views are based on scroll view). There is this stupid little box there called "delays content touches". Uncheck it. There is also one "allows cancellable touches" which I'll imagine you want to make sure is unchecked as well, as I think double touches were messing mine up.