NotificationExtension/NotificationService.swift

@@ -63,7 +63,6 @@ class NotificationService: UNNotificationServiceExtension {
         mutableContent.body = notification.body
         mutableContent.userInfo["notificationID"] = notification.notificationID
         mutableContent.userInfo["accountID"] = accountID
-        mutableContent.targetContentIdentifier = accountID
 
         let task = Task {
             await updateNotificationContent(mutableContent, account: account, push: notification)

Tusker/AppDelegate.swift

@@ -290,18 +290,12 @@ extension AppDelegate: UNUserNotificationCenterDelegate {
             // if the scene is already active, then we animate the account switching if necessary
             delegate.activateAccount(account, animated: scene.activationState == .foregroundActive)
             
-            rootViewController.select(route: .notifications, animated: false) {
+            rootViewController.select(route: .notifications, animated: false)
-                let vc = NotificationLoadingViewController(notificationID: notificationID, mastodonController: mastodonController)
+            let vc = NotificationLoadingViewController(notificationID: notificationID, mastodonController: mastodonController)
-                rootViewController.getNavigationController().pushViewController(vc, animated: false)
+            rootViewController.getNavigationController().pushViewController(vc, animated: false)
-            }
         } else {
             let activity = UserActivityManager.showNotificationActivity(id: notificationID, accountID: accountID)
-            if #available(iOS 17.0, *) {
+            UIApplication.shared.requestSceneSessionActivation(nil, userActivity: activity, options: nil)
-                let request = UISceneSessionActivationRequest(userActivity: activity)
-                UIApplication.shared.activateSceneSession(for: request)
-            } else {
-                UIApplication.shared.requestSceneSessionActivation(nil, userActivity: activity, options: nil)
-            }
         }
         completionHandler()
     }

Tusker/Scenes/AuxiliarySceneDelegate.swift

@@ -32,9 +32,8 @@ class AuxiliarySceneDelegate: UIResponder, UIWindowSceneDelegate, TuskerSceneDel
         }
         launchActivity = activity
         
-        scene.activationConditions.canActivateForTargetContentIdentifierPredicate = NSPredicate(value: false)
-
         let account: UserAccountInfo
+        
         if let activityAccount = UserActivityManager.getAccount(from: activity) {
             account = activityAccount
         } else if let mostRecent = UserAccountsManager.shared.getMostRecentAccount() {

Tusker/Scenes/ComposeSceneDelegate.swift

@@ -29,8 +29,6 @@ class ComposeSceneDelegate: UIResponder, UIWindowSceneDelegate, TuskerSceneDeleg
             return
         }
         
-        scene.activationConditions.canActivateForTargetContentIdentifierPredicate = NSPredicate(value: false)
-
         let account: UserAccountInfo
         let controller: MastodonController
         let draft: Draft?

Tusker/Scenes/MainSceneDelegate.swift

@@ -83,9 +83,7 @@ class MainSceneDelegate: UIResponder, UIWindowSceneDelegate, TuskerSceneDelegate
         } else {
             context = ActiveAccountUserActivityHandlingContext(isHandoff: true, root: rootViewController!)
         }
-        Task(priority: .userInitiated) {
+        _ = userActivity.handleResume(manager: UserActivityManager(scene: scene as! UIWindowScene, context: context))
-            _ = await userActivity.handleResume(manager: UserActivityManager(scene: scene as! UIWindowScene, context: context))
-        }
     }
     
     func windowScene(_ windowScene: UIWindowScene, performActionFor shortcutItem: UIApplicationShortcutItem, completionHandler: @escaping (Bool) -> Void) {
@@ -193,10 +191,8 @@ class MainSceneDelegate: UIResponder, UIWindowSceneDelegate, TuskerSceneDelegate
             
             if let activity = launchActivity {
                 func doRestoreActivity(context: UserActivityHandlingContext) {
-                    Task(priority: .userInitiated) {
+                    _ = activity.handleResume(manager: UserActivityManager(scene: window!.windowScene!, context: context))
-                        _ = await activity.handleResume(manager: UserActivityManager(scene: window!.windowScene!, context: context))
+                    context.finalize(activity: activity)
-                        context.finalize(activity: activity)
-                    }
                 }
                 if activity.isStateRestorationActivity {
                     doRestoreActivity(context: StateRestorationUserActivityHandlingContext(root: rootViewController!))
@@ -229,8 +225,6 @@ class MainSceneDelegate: UIResponder, UIWindowSceneDelegate, TuskerSceneDelegate
             window!.windowScene!.title = account.instanceURL.host!
         }
         
-        window!.windowScene!.activationConditions.prefersToActivateForTargetContentIdentifierPredicate = NSPredicate(format: "self == %@", account.id)
-        
         if let container = window?.rootViewController as? AccountSwitchingContainerViewController {
             let direction: AccountSwitchingContainerViewController.AnimationDirection
             if animated,

Tusker/Screens/Main/AccountSwitchingContainerViewController.swift

@@ -70,12 +70,10 @@ class AccountSwitchingContainerViewController: UIViewController {
                 stateRestorationLogger.debug("AccountSwitchingContainer: reusing existing VC for \(account.id, privacy: .public)")
             } else {
                 newRoot = newRootProvider()
-                Task(priority: .userInitiated) {
+                stateRestorationLogger.debug("AccountSwitchingContainer: restoring \(activity.activityType, privacy: .public) for \(account.id, privacy: .public)")
-                    stateRestorationLogger.debug("AccountSwitchingContainer: restoring \(activity.activityType, privacy: .public) for \(account.id, privacy: .public)")
+                let context = StateRestorationUserActivityHandlingContext(root: newRoot)
-                    let context = StateRestorationUserActivityHandlingContext(root: newRoot)
+                _ = activity.handleResume(manager: UserActivityManager(scene: view.window!.windowScene!, context: context))
-                    _ = await activity.handleResume(manager: UserActivityManager(scene: view.window!.windowScene!, context: context))
+                context.finalize(activity: activity)
-                    context.finalize(activity: activity)
-                }
             }
         } else {
             newRoot = newRootProvider()
@@ -152,9 +150,9 @@ extension AccountSwitchingContainerViewController: TuskerRootViewController {
         root.compose(editing: draft, animated: animated, isDucked: isDucked)
     }
     
-    func select(route: TuskerRoute, animated: Bool, completion: (() -> Void)?) {
+    func select(route: TuskerRoute, animated: Bool) {
         loadViewIfNeeded()
-        root.select(route: route, animated: animated, completion: completion)
+        root.select(route: route, animated: animated)
     }
     
     func getTabController(tab: MainTabBarViewController.Tab) -> UIViewController? {

Tusker/Screens/Main/Duckable+Root.swift

@@ -35,8 +35,8 @@ extension DuckableContainerViewController: AccountSwitchableViewController {
         (child as! TuskerRootViewController).getNavigationController()
     }
     
-    func select(route: TuskerRoute, animated: Bool, completion: (() -> Void)?) {
+    func select(route: TuskerRoute, animated: Bool) {
-        (child as? TuskerRootViewController)?.select(route: route, animated: animated, completion: completion)
+        (child as? TuskerRootViewController)?.select(route: route, animated: animated)
     }
     
     func getTabController(tab: MainTabBarViewController.Tab) -> UIViewController? {

Tusker/Screens/Main/MainSidebarViewController.swift

@@ -13,8 +13,8 @@ import Combine
 @MainActor
 protocol MainSidebarViewControllerDelegate: AnyObject {
     func sidebarRequestPresentCompose(_ sidebarViewController: MainSidebarViewController)
-    func sidebar(_ sidebarViewController: MainSidebarViewController, didSelectItem item: MainSidebarViewController.Item, previousItem: MainSidebarViewController.Item?)
+    func sidebar(_ sidebarViewController: MainSidebarViewController, didSelectItem item: MainSidebarViewController.Item)
-    func sidebar(_ sidebarViewController: MainSidebarViewController, showViewController viewController: UIViewController, previousItem: MainSidebarViewController.Item?)
+    func sidebar(_ sidebarViewController: MainSidebarViewController, showViewController viewController: UIViewController)
     func sidebar(_ sidebarViewController: MainSidebarViewController, scrollToTopFor item: MainSidebarViewController.Item)
 }
 
@@ -57,7 +57,7 @@ class MainSidebarViewController: UIViewController {
         return items
     }
     
-    private var previouslySelectedItem: Item?
+    private(set) var previouslySelectedItem: Item?
     var selectedItem: Item? {
         guard let indexPath = collectionView?.indexPathsForSelectedItems?.first else {
             return nil
@@ -261,21 +261,19 @@ class MainSidebarViewController: UIViewController {
     }
     
     private func returnToPreviousItem() {
-        let oldItem = selectedItem
+        let item = previouslySelectedItem ?? .tab(.timelines)
-        let newItem = previouslySelectedItem ?? .tab(.timelines)
         previouslySelectedItem = nil
-        select(item: newItem, animated: true)
+        select(item: item, animated: true)
-        sidebarDelegate?.sidebar(self, didSelectItem: newItem, previousItem: oldItem)
+        sidebarDelegate?.sidebar(self, didSelectItem: item)
     }
 
     private func showAddList() {
         let service = CreateListService(mastodonController: mastodonController, present: { self.present($0, animated: true
         ) }) { list in
-            let oldItem = self.selectedItem
             self.select(item: .list(list), animated: false)
             let list = ListTimelineViewController(for: list, mastodonController: self.mastodonController)
             list.presentEditOnAppear = true
-            self.sidebarDelegate?.sidebar(self, showViewController: list, previousItem: oldItem)
+            self.sidebarDelegate?.sidebar(self, showViewController: list)
         }
         service.run()
     }
@@ -473,7 +471,7 @@ extension MainSidebarViewController: UICollectionViewDelegate {
                 fatalError("unreachable")
             }
         } else {
-            sidebarDelegate?.sidebar(self, didSelectItem: item, previousItem: previouslySelectedItem)
+            sidebarDelegate?.sidebar(self, didSelectItem: item)
         }
     }
     
@@ -542,9 +540,8 @@ extension MainSidebarViewController: UICollectionViewDragDelegate {
 extension MainSidebarViewController: InstanceTimelineViewControllerDelegate {
     func didSaveInstance(url: URL) {
         dismiss(animated: true) {
-            let oldItem = self.selectedItem
             self.select(item: .savedInstance(url), animated: true)
-            self.sidebarDelegate?.sidebar(self, didSelectItem: .savedInstance(url), previousItem: oldItem)
+            self.sidebarDelegate?.sidebar(self, didSelectItem: .savedInstance(url))
         }
     }
     

Tusker/Screens/Main/MainSplitViewController.swift

@@ -86,7 +86,7 @@ class MainSplitViewController: UISplitViewController {
         // don't unnecesarily construct a content VC unless the we're in actually split mode
         // when we change from compact -> split for the first time, the VC will be transferred anyways
         if traitCollection.horizontalSizeClass != .compact {
-            doSelect(item: .tab(.timelines))
+            select(item: .tab(.timelines))
         }
         
         if UIDevice.current.userInterfaceIdiom != .mac {
@@ -149,15 +149,7 @@ class MainSplitViewController: UISplitViewController {
         self.setViewController(newNav, for: .secondary)
     }
     
-    private func select(newItem: MainSidebarViewController.Item, oldItem: MainSidebarViewController.Item?) {
+    func select(item: MainSidebarViewController.Item) {
-        if let oldItem,
-           newItem != oldItem {
-            navigationStacks[oldItem] = secondaryNavController.viewControllers
-        }
-        doSelect(item: newItem)
-    }
-    
-    private func doSelect(item: MainSidebarViewController.Item) {
         secondaryNavController.viewControllers = getOrCreateNavigationStack(item: item)
     }
     
@@ -188,28 +180,43 @@ class MainSplitViewController: UISplitViewController {
     }
     
     @objc func handleSidebarCommandTimelines() {
+        if let previous = sidebar.selectedItem {
+            navigationStacks[previous] = secondaryNavController.viewControllers
+        }
         sidebar.select(item: .tab(.timelines), animated: false)
-        select(newItem: .tab(.timelines), oldItem: sidebar.selectedItem)
+        select(item: .tab(.timelines))
     }
     
     @objc func handleSidebarCommandNotifications() {
+        if let previous = sidebar.selectedItem {
+            navigationStacks[previous] = secondaryNavController.viewControllers
+        }
         sidebar.select(item: .tab(.notifications), animated: false)
-        select(newItem: .tab(.notifications), oldItem: sidebar.selectedItem)
+        select(item: .tab(.notifications))
     }
     
     @objc func handleSidebarCommandExplore() {
+        if let previous = sidebar.selectedItem {
+            navigationStacks[previous] = secondaryNavController.viewControllers
+        }
         sidebar.select(item: .tab(.explore), animated: false)
-        select(newItem: .tab(.explore), oldItem: sidebar.selectedItem)
+        select(item: .tab(.explore))
     }
     
     @objc func handleSidebarCommandBookmarks() {
+        if let previous = sidebar.selectedItem {
+            navigationStacks[previous] = secondaryNavController.viewControllers
+        }
         sidebar.select(item: .bookmarks, animated: false)
-        select(newItem: .bookmarks, oldItem: sidebar.selectedItem)
+        select(item: .bookmarks)
     }
     
     @objc func handleSidebarCommandMyProfile() {
+        if let previous = sidebar.selectedItem {
+            navigationStacks[previous] = secondaryNavController.viewControllers
+        }
         sidebar.select(item: .tab(.myProfile), animated: false)
-        select(newItem: .tab(.myProfile), oldItem: sidebar.selectedItem)
+        select(item: .tab(.myProfile))
     }
     
     @objc private func sidebarTapped() {
@@ -452,12 +459,12 @@ extension MainSplitViewController: UISplitViewControllerDelegate {
             // These tabs map 1 <-> 1 with sidebar items
             let item = MainSidebarViewController.Item.tab(tabBarViewController.selectedTab)
             sidebar.select(item: item, animated: false)
-            doSelect(item: item)
+            select(item: item)
             
         case .explore:
             // If the explore tab is active, the sidebar item is determined above when transferring the explore VC's nav stack
             sidebar.select(item: exploreItem!, animated: false)
-            doSelect(item: exploreItem!)
+            select(item: exploreItem!)
             
         default:
             return
@@ -482,13 +489,16 @@ extension MainSplitViewController: MainSidebarViewControllerDelegate {
         compose(editing: nil)
     }
     
-    func sidebar(_ sidebarViewController: MainSidebarViewController, didSelectItem item: MainSidebarViewController.Item, previousItem: MainSidebarViewController.Item?) {
+    func sidebar(_ sidebarViewController: MainSidebarViewController, didSelectItem item: MainSidebarViewController.Item) {
-        select(newItem: item, oldItem: previousItem)
+        if let previous = sidebar.previouslySelectedItem {
+            navigationStacks[previous] = secondaryNavController.viewControllers
+        }
+        select(item: item)
     }
     
-    func sidebar(_ sidebarViewController: MainSidebarViewController, showViewController viewController: UIViewController, previousItem: MainSidebarViewController.Item?) {
+    func sidebar(_ sidebarViewController: MainSidebarViewController, showViewController viewController: UIViewController) {
-        if let previousItem {
+        if let previous = sidebar.previouslySelectedItem {
-            navigationStacks[previousItem] = secondaryNavController.viewControllers
+            navigationStacks[previous] = secondaryNavController.viewControllers
         }
         secondaryNavController.viewControllers = [viewController]
     }
@@ -542,14 +552,14 @@ extension MainSplitViewController: StateRestorableViewController {
 }
 
 extension MainSplitViewController: TuskerRootViewController {
-    func select(route: TuskerRoute, animated: Bool, completion: (() -> Void)?) {
+    func select(route: TuskerRoute, animated: Bool) {
         guard traitCollection.horizontalSizeClass != .compact else {
-            tabBarViewController?.select(route: route, animated: animated, completion: completion)
+            tabBarViewController?.select(route: route, animated: animated)
             return
         }
         guard presentedViewController == nil else {
             dismiss(animated: animated) {
-                self.select(route: route, animated: animated, completion: completion)
+                self.select(route: route, animated: animated)
             }
             return
         }
@@ -572,10 +582,8 @@ extension MainSplitViewController: TuskerRootViewController {
                 return
             }
         }
-        let oldItem = sidebar.selectedItem
         sidebar.select(item: item, animated: false)
-        select(newItem: item, oldItem: oldItem)
+        select(item: item)
-        completion?()
     }
     
     func getTabController(tab: MainTabBarViewController.Tab) -> UIViewController? {
@@ -617,7 +625,7 @@ extension MainSplitViewController: TuskerRootViewController {
         }
         
         if sidebar.selectedItem != .explore {
-            select(newItem: .explore, oldItem: sidebar.selectedItem)
+            select(item: .explore)
         }
         
         guard let searchViewController = secondaryNavController.viewControllers.first as? InlineTrendsViewController else {

Tusker/Screens/Main/MainTabBarViewController.swift

@@ -289,7 +289,7 @@ extension MainTabBarViewController: StateRestorableViewController {
 }
 
 extension MainTabBarViewController: TuskerRootViewController {
-    func select(route: TuskerRoute, animated: Bool, completion: (() -> Void)?) {
+    func select(route: TuskerRoute, animated: Bool) {
         switch route {
         case .timelines:
             select(tab: .timelines, dismissPresented: true)
@@ -310,7 +310,6 @@ extension MainTabBarViewController: TuskerRootViewController {
                 nav.pushViewController(ListTimelineViewController(for: list, mastodonController: mastodonController), animated: animated)
             }
         }
-        completion?()
     }
     
     func getNavigationDelegate() -> TuskerNavigationDelegate? {

Tusker/Screens/Main/TuskerRootViewController.swift

@@ -12,7 +12,7 @@ import ComposeUI
 @MainActor
 protocol TuskerRootViewController: UIViewController, StateRestorableViewController, StatusBarTappableViewController {
     func compose(editing draft: Draft?, animated: Bool, isDucked: Bool)
-    func select(route: TuskerRoute, animated: Bool, completion: (() -> Void)?)
+    func select(route: TuskerRoute, animated: Bool)
     func getTabController(tab: MainTabBarViewController.Tab) -> UIViewController?
     func getNavigationDelegate() -> TuskerNavigationDelegate?
     func getNavigationController() -> NavigationControllerProtocol
@@ -21,6 +21,33 @@ protocol TuskerRootViewController: UIViewController, StateRestorableViewControll
     func presentPreferences(completion: (() -> Void)?) -> PreferencesNavigationController?
 }
 
+//extension TuskerRootViewController {
+//    func select(route: NewRoute, animated: Bool) {
+//        doApply(components: route.components, animated: animated)
+//    }
+//
+//    private func doApply(components: ArraySlice<RouteComponent>, animated: Bool) {
+//        guard let first = components.first else {
+//            return
+//        }
+//        doApply(component: first, animated: animated) {
+//            self.doApply(components: components.dropFirst(), animated: animated)
+//        }
+//    }
+//
+//    private func doApply(component: RouteComponent, animated: Bool, completion: @escaping () -> Void) {
+//        switch component {
+//        case .topLevelItem(let rootRoute):
+//            select(route: rootRoute)
+//            completion()
+//        case .popToRoot:
+//            _ = getNavigationController().popToRootViewController(animated: animated)
+//            completion()
+//        case .push(<#T##(MastodonController) -> UIViewController#>)
+//        }
+//    }
+//}
+
 enum TuskerRoute {
     case timelines
     case notifications
@@ -30,6 +57,33 @@ enum TuskerRoute {
     case list(id: String)
 }
 
+//struct NewRoute: ExpressibleByArrayLiteral {
+//    let components: [RouteComponent]
+//
+//    init(arrayLiteral elements: RouteComponent...) {
+//        self.components = elements
+//    }
+//
+//    static var timelines: Self { [.topLevelItem(.timelines)] }
+//    static var explore: Self { [.topLevelItem(.explore)] }
+//    static var myProfile: Self { [.topLevelItem(.myProfile)] }
+//    static var bookmarks: Self { [.topLevelItem(.explore), .push({ BookmarksViewController(mastodonController: $0) })] }
+//    static func profile(accountID: String) -> Self { [.topLevelItem(.timelines), .push({ ProfileViewController(accountID: accountID, mastodonController: $0) })] }
+//}
+//
+//enum RouteComponent {
+//    case topLevelItem(RootRoute)
+//    case popToRoot
+//    case push((MastodonController) -> UIViewController)
+//    case present(UIViewController)
+//}
+//
+//enum RootRoute {
+//    case timelines
+//    case explore
+//    case myProfile
+//}
+//
 @MainActor
 protocol NavigationControllerProtocol: UIViewController {
     var viewControllers: [UIViewController] { get set }

Tusker/Screens/Notifications/NotificationLoadingViewController.swift

@@ -94,14 +94,10 @@ class NotificationLoadingViewController: UIViewController {
             showLoadingError(Error.unknownType)
             return
         }
-//        guard let navigationController else {
+        guard let navigationController else {
-//            fatalError("Don't know how to show notification VC outside of navigation controller")
+            fatalError("Don't know how to show notification VC outside of navigation controller")
-//        }
-        if let navigationController {
-            navigationController.viewControllers[navigationController.viewControllers.count - 1] = vc
-        } else {
-            print("AAAAAAAAAA")
         }
+        navigationController.viewControllers[navigationController.viewControllers.count - 1] = vc
     }
     
     private func showLoadingError(_ error: any Swift.Error) {

Tusker/Shortcuts/AppShortcutItems.swift

@@ -44,9 +44,9 @@ enum AppShortcutItem: String, CaseIterable {
         }
         switch self {
         case .showHomeTimeline:
-            root.select(route: .timelines, animated: false, completion: nil)
+            root.select(route: .timelines, animated: false)
         case .showNotifications:
-            root.select(route: .notifications, animated: false, completion: nil)
+            root.select(route: .notifications, animated: false)
         case .composePost:
             root.compose(editing: nil, animated: false, isDucked: false)
         }

Tusker/Shortcuts/NSUserActivity+Extensions.swift

@@ -39,13 +39,12 @@ extension NSUserActivity {
         self.userInfo = [
             "accountID": accountID
         ]
-        self.targetContentIdentifier = accountID
     }
     
     @MainActor
-    func handleResume(manager: UserActivityManager) async -> Bool {
+    func handleResume(manager: UserActivityManager) -> Bool {
         guard let type = UserActivityType(rawValue: activityType) else { return false }
-        await type.handle(manager)(self)
+        type.handle(manager)(self)
         return true
     }
     

Tusker/Shortcuts/UserActivityHandlingContext.swift

@@ -16,8 +16,7 @@ import ComposeUI
 protocol UserActivityHandlingContext {
     var isHandoff: Bool { get }
     
-    func select(route: TuskerRoute) async
+    func select(route: TuskerRoute)
-    func select(route: TuskerRoute, completion: (() -> Void)?)
     func present(_ vc: UIViewController)
     
     var topViewController: UIViewController? { get }
@@ -29,16 +28,6 @@ protocol UserActivityHandlingContext {
     func finalize(activity: NSUserActivity)
 }
 
-extension UserActivityHandlingContext {
-    func select(route: TuskerRoute) async {
-        await withCheckedContinuation { continuation in
-            select(route: route) {
-                continuation.resume()
-            }
-        }
-    }
-}
-
 struct ActiveAccountUserActivityHandlingContext: UserActivityHandlingContext {
     let isHandoff: Bool
     let root: TuskerRootViewController
@@ -46,8 +35,8 @@ struct ActiveAccountUserActivityHandlingContext: UserActivityHandlingContext {
         root.getNavigationDelegate()!
     }
     
-    func select(route: TuskerRoute, completion: (() -> Void)?) {
+    func select(route: TuskerRoute) {
-        root.select(route: route, animated: true, completion: completion)
+        root.select(route: route, animated: true)
     }
     
     func present(_ vc: UIViewController) {
@@ -82,11 +71,9 @@ class StateRestorationUserActivityHandlingContext: UserActivityHandlingContext {
     
     var isHandoff: Bool { false }
     
-    func select(route: TuskerRoute, completion: (() -> Void)?) {
+    func select(route: TuskerRoute) {
-        root.select(route: route, animated: false) {
+        root.select(route: route, animated: false)
-            self.state = .selectedRoute
+        state = .selectedRoute
-            completion?()
-        }
     }
     
     var topViewController: UIViewController? { root.getNavigationController().topViewController }

Tusker/Shortcuts/UserActivityManager.swift

@@ -133,8 +133,8 @@ class UserActivityManager {
         return activity
     }
     
-    func handleCheckNotifications(activity: NSUserActivity) async {
+    func handleCheckNotifications(activity: NSUserActivity) {
-        await context.select(route: .notifications)
+        context.select(route: .notifications)
         context.popToRoot()
         if let notificationsPageController = context.topViewController as? NotificationsPageViewController {
             notificationsPageController.loadViewIfNeeded()
@@ -204,22 +204,22 @@ class UserActivityManager {
         return (timeline, positionInfo)
     }
     
-    func handleShowTimeline(activity: NSUserActivity) async {
+    func handleShowTimeline(activity: NSUserActivity) {
         guard let (timeline, positionInfo) = Self.getTimeline(from: activity) else { return }
         
         var timelineVC: TimelineViewController?
         if let pinned = PinnedTimeline(timeline: timeline),
            mastodonController.accountPreferences.pinnedTimelines.contains(pinned) {
-            await context.select(route: .timelines)
+            context.select(route: .timelines)
             context.popToRoot()
             let pageController = context.topViewController as! TimelinesPageViewController
             pageController.selectTimeline(pinned, animated: false)
             timelineVC = pageController.currentViewController as? TimelineViewController
         } else if case .list(let id) = timeline {
-            await context.select(route: .list(id: id))
+            context.select(route: .list(id: id))
             timelineVC = context.topViewController as? TimelineViewController
         } else {
-            await context.select(route: .explore)
+            context.select(route: .explore)
             context.popToRoot()
             timelineVC = TimelineViewController(for: timeline, mastodonController: mastodonController)
             context.push(timelineVC!)
@@ -249,11 +249,11 @@ class UserActivityManager {
         return activity.userInfo?["mainStatusID"] as? String
     }
     
-    func handleShowConversation(activity: NSUserActivity) async {
+    func handleShowConversation(activity: NSUserActivity) {
         guard let mainStatusID = Self.getConversationStatus(from: activity) else {
             return
         }
-        await context.select(route: .timelines)
+        context.select(route: .timelines)
         context.push(ConversationViewController(for: mainStatusID, state: .unknown, mastodonController: mastodonController))
     }
     
@@ -274,8 +274,8 @@ class UserActivityManager {
         return activity.userInfo?["query"] as? String
     }
     
-    func handleSearch(activity: NSUserActivity) async {
+    func handleSearch(activity: NSUserActivity) {
-        await context.select(route: .explore)
+        context.select(route: .explore)
         context.popToRoot()
         
         let searchController: UISearchController
@@ -311,8 +311,8 @@ class UserActivityManager {
         return activity
     }
     
-    func handleBookmarks(activity: NSUserActivity) async {
+    func handleBookmarks(activity: NSUserActivity) {
-        await context.select(route: .bookmarks)
+        context.select(route: .bookmarks)
     }
     
     // MARK: - My Profile
@@ -325,8 +325,8 @@ class UserActivityManager {
         return activity
     }
     
-    func handleMyProfile(activity: NSUserActivity) async {
+    func handleMyProfile(activity: NSUserActivity) {
-        await context.select(route: .myProfile)
+        context.select(route: .myProfile)
     }
     
     // MARK: - Show Profile
@@ -344,11 +344,11 @@ class UserActivityManager {
         return activity.userInfo?["profileID"] as? String
     }
     
-    func handleShowProfile(activity: NSUserActivity) async {
+    func handleShowProfile(activity: NSUserActivity) {
         guard let accountID = Self.getProfile(from: activity) else {
             return
         }
-        await context.select(route: .timelines)
+        context.select(route: .timelines)
         context.push(ProfileViewController(accountID: accountID, mastodonController: mastodonController))
     }
     
@@ -361,11 +361,11 @@ class UserActivityManager {
         return activity
     }
     
-    func handleShowNotification(activity: NSUserActivity) async {
+    func handleShowNotification(activity: NSUserActivity) {
         guard let notificationID = activity.userInfo?["notificationID"] as? String else {
             return
         }
-        await context.select(route: .notifications)
+        context.select(route: .notifications)
         context.push(NotificationLoadingViewController(notificationID: notificationID, mastodonController: mastodonController))
     }
     

Tusker/Shortcuts/UserActivityType.swift

@@ -23,7 +23,7 @@ enum UserActivityType: String {
 
 extension UserActivityType {
     @MainActor
-    var handle: (UserActivityManager) -> @MainActor (NSUserActivity) async -> Void {
+    var handle: (UserActivityManager) -> @MainActor (NSUserActivity) -> Void {
         switch self {
         case .mainScene:
             fatalError("cannot handle main scene activity")