UI state restoration for a scene in iOS 13 while still supporting iOS 12. No storyboards

Question

This is a little long but it's not trivial and it takes a lot to demonstrate this issue.

I'm trying to figure out how to update a little sample app from iOS 12 to iOS 13. This sample app doesn't use any storyboards (other than the launch screen). It's a simple app that shows one view controller with a label that is updated by a timer. It uses state restoration so the counter starts from where it left off. I want to be able to support iOS 12 and iOS 13. In iOS 13 I want to update to the new scene architecture.

Under iOS 12 the app works just fine. On a fresh install the counter starts at 0 and goes up. Put the app in the background and then restart the app and the counter continues from where it left off. The state restoration all works.

Now I'm trying to get that working under iOS 13 using a scene. The problem I'm having is figuring out the correct way to initialize the scene's window and restore the navigation controller and the main view controller to the scene.

I've been through as much of the Apple documentation as I can find related to state restoration and scenes. I've watched WWDC videos related to windows and scenes (212 - Introducing Multiple Windows on iPad, 258 - Architecting Your App for Multiple Windows). But I seem to be missing a piece that puts it all together.

When I run the app under iOS 13, all of the expected delegate methods (both AppDelegate and SceneDelegate) are being called. The state restoration is restoring the nav controller and the main view controller but I can't figure out how to set the rootViewController of the scene's window since all of the UI state restoration is in the AppDelegate.

There also seems to be something related to an NSUserTask that should be used but I can't connect the dots.

The missing pieces seem to be in the willConnectTo method of SceneDelegate. I'm sure I also need some changes in stateRestorationActivity of SceneDelegate. There may also need to be changes in the AppDelegate. I doubt anything in ViewController needs to be changed.

---

To replicate what I'm doing, create a new iOS project with Xcode 11 (beta 4 at the moment) using the Single View App template. Set the Deployment Target to iOS 11 or 12.

Delete the main storyboard. Remove the two references in the Info.plist to Main (one at the top level and one deep inside the Application Scene Manifest. Update the 3 swift files as follows.

AppDelegate.swift:

import UIKit  @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate {     var window: UIWindow?      func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {         print("AppDelegate willFinishLaunchingWithOptions")          // This probably shouldn't be run under iOS 13?         self.window = UIWindow(frame: UIScreen.main.bounds)          return true     }      func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {         print("AppDelegate didFinishLaunchingWithOptions")          if #available(iOS 13.0, *) {             // What needs to be here?         } else {             // If the root view controller wasn't restored, create a new one from scratch             if (self.window?.rootViewController == nil) {                 let vc = ViewController()                 let nc = UINavigationController(rootViewController: vc)                 nc.restorationIdentifier = "RootNC"                  self.window?.rootViewController = nc             }              self.window?.makeKeyAndVisible()         }          return true     }      func application(_ application: UIApplication, viewControllerWithRestorationIdentifierPath identifierComponents: [String], coder: NSCoder) -> UIViewController? {         print("AppDelegate viewControllerWithRestorationIdentifierPath")          // If this is for the nav controller, restore it and set it as the window's root         if identifierComponents.first == "RootNC" {             let nc = UINavigationController()             nc.restorationIdentifier = "RootNC"             self.window?.rootViewController = nc              return nc         }          return nil     }      func application(_ application: UIApplication, willEncodeRestorableStateWith coder: NSCoder) {         print("AppDelegate willEncodeRestorableStateWith")          // Trigger saving of the root view controller         coder.encode(self.window?.rootViewController, forKey: "root")     }      func application(_ application: UIApplication, didDecodeRestorableStateWith coder: NSCoder) {         print("AppDelegate didDecodeRestorableStateWith")     }      func application(_ application: UIApplication, shouldSaveApplicationState coder: NSCoder) -> Bool {         print("AppDelegate shouldSaveApplicationState")          return true     }      func application(_ application: UIApplication, shouldRestoreApplicationState coder: NSCoder) -> Bool {         print("AppDelegate shouldRestoreApplicationState")          return true     }      // The following four are not called in iOS 13     func applicationWillEnterForeground(_ application: UIApplication) {         print("AppDelegate applicationWillEnterForeground")     }      func applicationDidEnterBackground(_ application: UIApplication) {         print("AppDelegate applicationDidEnterBackground")     }      func applicationDidBecomeActive(_ application: UIApplication) {         print("AppDelegate applicationDidBecomeActive")     }      func applicationWillResignActive(_ application: UIApplication) {         print("AppDelegate applicationWillResignActive")     }      // MARK: UISceneSession Lifecycle      @available(iOS 13.0, *)     func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {         print("AppDelegate configurationForConnecting")          return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)     }      @available(iOS 13.0, *)     func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {         print("AppDelegate didDiscardSceneSessions")     } } 

SceneDelegate.swift:

import UIKit  @available(iOS 13.0, *) class SceneDelegate: UIResponder, UIWindowSceneDelegate {     var window: UIWindow?      func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {         print("SceneDelegate willConnectTo")          guard let winScene = (scene as? UIWindowScene) else { return }          // Got some of this from WWDC2109 video 258         window = UIWindow(windowScene: winScene)         if let activity = connectionOptions.userActivities.first ?? session.stateRestorationActivity {             // Now what? How to connect the UI restored in the AppDelegate to this window?         } else {             // Create the initial UI if there is nothing to restore             let vc = ViewController()             let nc = UINavigationController(rootViewController: vc)             nc.restorationIdentifier = "RootNC"              self.window?.rootViewController = nc             window?.makeKeyAndVisible()         }     }      func stateRestorationActivity(for scene: UIScene) -> NSUserActivity? {         print("SceneDelegate stateRestorationActivity")          // What should be done here?         let activity = NSUserActivity(activityType: "What?")         activity.persistentIdentifier = "huh?"          return activity     }      func scene(_ scene: UIScene, didUpdate userActivity: NSUserActivity) {         print("SceneDelegate didUpdate")     }      func sceneDidDisconnect(_ scene: UIScene) {         print("SceneDelegate sceneDidDisconnect")     }      func sceneDidBecomeActive(_ scene: UIScene) {         print("SceneDelegate sceneDidBecomeActive")     }      func sceneWillResignActive(_ scene: UIScene) {         print("SceneDelegate sceneWillResignActive")     }      func sceneWillEnterForeground(_ scene: UIScene) {         print("SceneDelegate sceneWillEnterForeground")     }      func sceneDidEnterBackground(_ scene: UIScene) {         print("SceneDelegate sceneDidEnterBackground")     } } 

ViewController.swift:

import UIKit  class ViewController: UIViewController, UIViewControllerRestoration {     var label: UILabel!     var count: Int = 0     var timer: Timer?      static func viewController(withRestorationIdentifierPath identifierComponents: [String], coder: NSCoder) -> UIViewController? {         print("ViewController withRestorationIdentifierPath")          return ViewController()     }      override init(nibName nibNameOrNil: String? = nil, bundle nibBundleOrNil: Bundle? = nil) {         print("ViewController init")          super.init(nibName: nibNameOrNil, bundle: nibBundleOrNil)          restorationIdentifier = "ViewController"         restorationClass = ViewController.self     }      required init?(coder: NSCoder) {         print("ViewController init(coder)")          super.init(coder: coder)     }      override func viewDidLoad() {         print("ViewController viewDidLoad")          super.viewDidLoad()          view.backgroundColor = .green // be sure this vc is visible          label = UILabel(frame: .zero)         label.translatesAutoresizingMaskIntoConstraints = false         label.text = "\(count)"         view.addSubview(label)         NSLayoutConstraint.activate([             label.centerXAnchor.constraint(equalTo: view.centerXAnchor),             label.centerYAnchor.constraint(equalTo: view.centerYAnchor),         ])     }      override func viewWillAppear(_ animated: Bool) {         print("ViewController viewWillAppear")          super.viewWillAppear(animated)          timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true, block: { (timer) in             self.count += 1             self.label.text = "\(self.count)"         })     }      override func viewDidDisappear(_ animated: Bool) {         print("ViewController viewDidDisappear")          super.viewDidDisappear(animated)          timer?.invalidate()         timer = nil     }      override func encodeRestorableState(with coder: NSCoder) {         print("ViewController encodeRestorableState")          super.encodeRestorableState(with: coder)          coder.encode(count, forKey: "count")     }      override func decodeRestorableState(with coder: NSCoder) {         print("ViewController decodeRestorableState")          super.decodeRestorableState(with: coder)          count = coder.decodeInteger(forKey: "count")         label.text = "\(count)"     } } 

Run this under iOS 11 or 12 and it works just fine.

You can run this under iOS 13 and on a fresh install of the app you get the UI. But any subsequent run of the app gives a black screen because the UI restored via state restoration isn't connected to the scene's window.

What am I missing? Is this just missing a line or two of code or is my entire approach to iOS 13 scene state restoration wrong?

Keep in mind that once I get this figured out the next step will be supporting multiple windows. So the solution should work for multiple scenes, not just one.

Answer 1

This, it seems to me, is the major flaw in the structure of the answers presented so far:

You would also want to chain calls to updateUserActivityState

That misses the whole point of updateUserActivityState, which is that it is called for you, automatically, for all view controllers whose userActivity is the same as the NSUserActivity returned by the scene delegate's stateRestorationActivity.

Thus, we automatically have a state-saving mechanism, and it remains only to devise a state-restoration mechanism to match. I will illustrate an entire architecture I've come up with.

NOTE: This discussion ignores multiple windows and it also ignores the original requirement of the question, that we be compatible with iOS 12 view controller-based state saving and restoration. My goal here is only to show how to do state saving and restoration in iOS 13 using NSUserActivity. However, only minor modifications are needed in order to fold this into a multiple-window app, so I think it answers the original question adequately.

Saving

Let's start with state-saving. This is entirely boilerplate. The scene delegate either creates the scene userActivity or passes the received restoration activity into it, and returns that as its own user activity:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {     guard let scene = (scene as? UIWindowScene) else { return }     scene.userActivity =         session.stateRestorationActivity ??         NSUserActivity(activityType: "restoration") } func stateRestorationActivity(for scene: UIScene) -> NSUserActivity? {     return scene.userActivity } 

Every view controller must use its own viewDidAppear to share that user activity object. That way, its own updateUserActivityState will be called automatically when we go into the background, and it has a chance to contribute to the global pool of the user info:

override func viewDidAppear(_ animated: Bool) {     super.viewDidAppear(animated)     self.userActivity = self.view.window?.windowScene?.userActivity } // called automatically at saving time! override func updateUserActivityState(_ activity: NSUserActivity) {     super.updateUserActivityState(activity)     // gather info into `info`     activity.addUserInfoEntries(from: info) } 

That's all! If every view controller does that, then every view controller that is alive at the time we go into background gets a chance to contribute to the user info of the user activity that will arrive next time we launch.

Restoration

This part is harder. The restoration info will arrive as session.stateRestorationActivity into the scene delegate. As the original question rightly asks: now what?

There's more than one way to skin this cat, and I've tried most of them and settled on this one. My rule is this:

• Every view controller must have a restorationInfo property which is a dictionary. When any view controller is created during restoration, its creator (parent) must set that restorationInfo to the userInfo that arrived from session.stateRestorationActivity.

• This userInfo must be copied out right at the start, because it will be wiped out from the saved activity the first time updateUserActivityState is called (that is the part that really drove me crazy working out this architecture).

The cool part is that if we do this right, the restorationInfo is set before viewDidLoad, and so the view controller can configure itself based on the info it put into the dictionary on saving.

Each view controller must also delete its own restorationInfo when it is done with it, lest it use it again during the app's lifetime. It must be used only the once, on launch.

So we must change our boilerplate:

var restorationInfo :  [AnyHashable : Any]? override func viewDidAppear(_ animated: Bool) {     super.viewDidAppear(animated)     self.userActivity = self.view.window?.windowScene?.userActivity     self.restorationInfo = nil } 

So now the only problem is the chain of how the restorationInfo of each view controller is set. The chain starts with the scene delegate, which is responsible for setting this property in the root view controller:

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {     guard let scene = (scene as? UIWindowScene) else { return }     scene.userActivity =         session.stateRestorationActivity ??         NSUserActivity(activityType: "restoration")     if let rvc = window?.rootViewController as? RootViewController {         rvc.restorationInfo = scene.userActivity?.userInfo     } } 

Each view controller is then responsible not only for configuring itself in its viewDidLoad based on the restorationInfo, but also for looking to see whether it was the parent / presenter of any further view controller. If so, it must create and present / push / whatever that view controller, making sure to pass on the restorationInfo before that child view controller's viewDidLoad runs.

If every view controller does this correctly, the whole interface and state will be restored!

A bit more of an example

Presume we have just two possible view controllers: RootViewController and PresentedViewController. Either RootViewController was presenting PresentedViewController at the time we were backgrounded, or it wasn't. Either way, that information has been written into the info dictionary.

So here is what RootViewController does:

var restorationInfo : [AnyHashable:Any]? override func viewDidLoad() {     super.viewDidLoad()     // configure self, including any info from restoration info }  // this is the earliest we have a window, so it's the earliest we can present // if we are restoring the editing window var didFirstWillLayout = false override func viewWillLayoutSubviews() {     if didFirstWillLayout { return }     didFirstWillLayout = true     let key = PresentedViewController.editingRestorationKey     let info = self.restorationInfo     if let editing = info?[key] as? Bool, editing {         self.performSegue(withIdentifier: "PresentWithNoAnimation", sender: self)     } }  // boilerplate override func viewDidAppear(_ animated: Bool) {     super.viewDidAppear(animated)     self.userActivity = self.view.window?.windowScene?.userActivity     self.restorationInfo = nil }  // called automatically because we share this activity with the scene override func updateUserActivityState(_ activity: NSUserActivity) {     super.updateUserActivityState(activity)     // express state as info dictionary     activity.addUserInfoEntries(from: info) } 

The cool part is that the PresentedViewController does exactly the same thing!

var restorationInfo :  [AnyHashable : Any]? static let editingRestorationKey = "editing"  override func viewDidLoad() {     super.viewDidLoad()     // configure self, including info from restoration info }  // boilerplate override func viewDidAppear(_ animated: Bool) {     super.viewDidAppear(animated)     self.userActivity = self.view.window?.windowScene?.userActivity     self.restorationInfo = nil }  override func updateUserActivityState(_ activity: NSUserActivity) {     super.updateUserActivityState(activity)     let key = Self.editingRestorationKey     activity.addUserInfoEntries(from: [key:true])     // and add any other state info as well } 

I think you can see that at this point it's only a matter of degree. If we have more view controllers to chain during the restoration process, they all work exactly the same way.

Final notes

As I said, this is not the only way to skin the restoration cat. But there are problems of timing and of distribution of responsibilities, and I think this is the most equitable approach.

In particular, I do not hold with the idea that the scene delegate should be responsible for the whole restoration of the interface. It would need to know too much about the details of how to initialize each view controller along the line, and there are serious timing issues that are difficult to overcome in a deterministic way. My approach sort of imitates the old view controller-based restoration, making each view controller responsible for its child in the same way it would normally be.

Answer 2

To support state restoration in iOS 13 you will need to encode enough state into the NSUserActivity:

Use this method to return an NSUserActivity object with information about your scene's data. Save enough information to be able to retrieve that data again after UIKit disconnects and then reconnects the scene. User activity objects are meant for recording what the user was doing, so you don't need to save the state of your scene's UI

The advantage of this approach is that it can make it easier to support handoff, since you are creating the code necessary to persist and restore state via user activities.

Unlike the previous state restoration approach where iOS recreated the view controller hierarchy for you, you are responsible for creating the view hierarchy for your scene in the scene delegate.

If you have multiple active scenes then your delegate will be called multiple times to save the state and multiple times to restore state; Nothing special is needed.

The changes I made to your code are:

AppDelegate.swift

Disable "legacy" state restoration on iOS 13 & later:

func application(_ application: UIApplication, viewControllerWithRestorationIdentifierPath identifierComponents: [String], coder: NSCoder) -> UIViewController? {     if #available(iOS 13, *) {      } else {         print("AppDelegate viewControllerWithRestorationIdentifierPath")          // If this is for the nav controller, restore it and set it as the window's root         if identifierComponents.first == "RootNC" {             let nc = UINavigationController()             nc.restorationIdentifier = "RootNC"             self.window?.rootViewController = nc              return nc         }     }     return nil }  func application(_ application: UIApplication, willEncodeRestorableStateWith coder: NSCoder) {     print("AppDelegate willEncodeRestorableStateWith")     if #available(iOS 13, *) {      } else {     // Trigger saving of the root view controller         coder.encode(self.window?.rootViewController, forKey: "root")     } }  func application(_ application: UIApplication, didDecodeRestorableStateWith coder: NSCoder) {     print("AppDelegate didDecodeRestorableStateWith") }  func application(_ application: UIApplication, shouldSaveApplicationState coder: NSCoder) -> Bool {     print("AppDelegate shouldSaveApplicationState")     if #available(iOS 13, *) {         return false     } else {         return true     } }  func application(_ application: UIApplication, shouldRestoreApplicationState coder: NSCoder) -> Bool {     print("AppDelegate shouldRestoreApplicationState")     if #available(iOS 13, *) {         return false     } else {         return true     } } 

SceneDelegate.swift

Create a user activity when required and use it to recreate the view controller. Note that you are responsible for creating the view hierarchy in both normal and restore cases.

func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {     print("SceneDelegate willConnectTo")      guard let winScene = (scene as? UIWindowScene) else { return }      // Got some of this from WWDC2109 video 258     window = UIWindow(windowScene: winScene)      let vc = ViewController()      if let activity = connectionOptions.userActivities.first ?? session.stateRestorationActivity {         vc.continueFrom(activity: activity)     }      let nc = UINavigationController(rootViewController: vc)     nc.restorationIdentifier = "RootNC"      self.window?.rootViewController = nc     window?.makeKeyAndVisible()   }  func stateRestorationActivity(for scene: UIScene) -> NSUserActivity? {     print("SceneDelegate stateRestorationActivity")      if let nc = self.window?.rootViewController as? UINavigationController, let vc = nc.viewControllers.first as? ViewController {         return vc.continuationActivity     } else {         return nil     }  } 

ViewController.swift

Add support for saving and loading from an NSUserActivity.

var continuationActivity: NSUserActivity {     let activity = NSUserActivity(activityType: "restoration")     activity.persistentIdentifier = UUID().uuidString     activity.addUserInfoEntries(from: ["Count":self.count])     return activity }  func continueFrom(activity: NSUserActivity) {     let count = activity.userInfo?["Count"] as? Int ?? 0     self.count = count }