// // SceneDelegate.swift // Reader // // Created by Shadowfacts on 10/29/21. // @preconcurrency import Foundation import UIKit import OSLog class SceneDelegate: UIResponder, UIWindowSceneDelegate { var window: UIWindow? private(set) var fervorController: FervorController! private(set) var toggleReadBarButtonItem: UIBarButtonItem? private let logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "SceneDelegate") func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) { // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`. // If using a storyboard, the `window` property will automatically be initialized and attached to the scene. // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead). guard let windowScene = (scene as? UIWindowScene) else { return } window = UIWindow(windowScene: windowScene) window!.tintColor = .appTintColor var activity = connectionOptions.userActivities.first var account = LocalData.mostRecentAccount() if activity?.activityType == NSUserActivity.addAccountType { account = nil } else if let id = activity?.accountID() { account = LocalData.account(with: id) if account == nil { activity = nil logger.log("Missing account for activity, not restoring") } } if let account = account { Task { @MainActor [activity] in fervorController = await FervorController(account: account) syncFromServer() createAppUI() if let activity = activity { setupUI(from: activity) } setupSceneActivationConditions() } } else { createLoginUI() } #if targetEnvironment(macCatalyst) if let titlebar = windowScene.titlebar { titlebar.toolbarStyle = .unifiedCompact titlebar.toolbar = NSToolbar(identifier: .init("ReaderToolbar")) titlebar.toolbar!.delegate = self titlebar.toolbar!.allowsUserCustomization = false } #endif window!.makeKeyAndVisible() NotificationCenter.default.addObserver(self, selector: #selector(updateAppearance), name: .appearanceChanged, object: nil) updateAppearance() } func sceneDidDisconnect(_ scene: UIScene) { // Called as the scene is being released by the system. // This occurs shortly after the scene enters the background, or when its session is discarded. // Release any resources associated with this scene that can be re-created the next time the scene connects. // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions` instead). } func sceneDidBecomeActive(_ scene: UIScene) { // Called when the scene has moved from an inactive state to an active state. // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive. UIMenuSystem.main.setNeedsRebuild() syncFromServer() } func sceneWillResignActive(_ scene: UIScene) { // Called when the scene will move from an active state to an inactive state. // This may occur due to temporary interruptions (ex. an incoming phone call). if let fervorController = fervorController { Task(priority: .userInitiated) { await fervorController.syncReadToServer() } } } func sceneWillEnterForeground(_ scene: UIScene) { // Called as the scene transitions from the background to the foreground. // Use this method to undo the changes made on entering the background. } func sceneDidEnterBackground(_ scene: UIScene) { // Called as the scene transitions from the foreground to the background. // Use this method to save data, release shared resources, and store enough scene-specific state information // to restore the scene back to its current state. } func scene(_ scene: UIScene, continue userActivity: NSUserActivity) { setupUI(from: userActivity) } private func setupUI(from activity: NSUserActivity) { guard let split = window?.rootViewController as? AppSplitViewController else { logger.error("Failed to setup UI for user activity: missing split VC") return } switch activity.activityType { case NSUserActivity.readUnreadType: split.selectHomeItem(.unread) case NSUserActivity.readAllType: split.selectHomeItem(.all) default: break } } private func createLoginUI() { let vc = LoginViewController() vc.delegate = self window!.rootViewController = vc } private func createAppUI() { window!.rootViewController = AppSplitViewController(fervorController: fervorController) } private func setupSceneActivationConditions() { guard let account = fervorController?.account else { return } let scene = self.window!.windowScene! // todo: why the fuck doesn't this work // it always picks the most recently focused window scene.activationConditions.prefersToActivateForTargetContentIdentifierPredicate = NSPredicate(format: "self == '\(account.id.base64EncodedString())'") scene.activationConditions.canActivateForTargetContentIdentifierPredicate = NSPredicate(value: false) } private func syncFromServer() { guard let fervorController = fervorController else { return } Task(priority: .userInitiated) { do { try await fervorController.syncAll() } catch { logger.error("Unable to sync from server: \(String(describing: error), privacy: .public)") } } } @objc private func updateAppearance() { switch Preferences.shared.appearance { case .unspecified: window!.overrideUserInterfaceStyle = .unspecified case .light: window!.overrideUserInterfaceStyle = .light case .dark: window!.overrideUserInterfaceStyle = .dark } } func switchToAccount(_ account: LocalData.Account) async { LocalData.mostRecentAccountID = account.id fervorController = await FervorController(account: account) createAppUI() syncFromServer() } } extension SceneDelegate: LoginViewControllerDelegate { func didLogin(with controller: FervorController) { Task { @MainActor in let account = LocalData.Account(instanceURL: controller.instanceURL, clientID: await controller.clientID!, clientSecret: await controller.clientSecret!, token: await controller.token!) LocalData.accounts.append(account) LocalData.mostRecentAccountID = account.id fervorController = await FervorController(account: account) createAppUI() syncFromServer() setupSceneActivationConditions() UIMenuSystem.main.setNeedsRebuild() } } } #if targetEnvironment(macCatalyst) extension NSToolbarItem.Identifier { static let toggleItemRead = NSToolbarItem.Identifier("ToggleItemRead") static let shareItem = NSToolbarItem.Identifier("ShareItem") } extension SceneDelegate: NSToolbarDelegate { func toolbar(_ toolbar: NSToolbar, itemForItemIdentifier itemIdentifier: NSToolbarItem.Identifier, willBeInsertedIntoToolbar flag: Bool) -> NSToolbarItem? { if itemIdentifier == .toggleItemRead { // need an item bar button item to make the size of the image match the share button let item = NSToolbarItem(itemIdentifier: .toggleItemRead, barButtonItem: UIBarButtonItem(image: nil, style: .plain, target: nil, action: nil)) item.image = UIImage(systemName: "checkmark.circle") item.target = nil item.action = #selector(ReadViewController.toggleItemRead(_:)) return item } else if itemIdentifier == .shareItem { return NSSharingServicePickerToolbarItem(itemIdentifier: .shareItem) } else { return nil } } func toolbarAllowedItemIdentifiers(_ toolbar: NSToolbar) -> [NSToolbarItem.Identifier] { return [.shareItem, .toggleItemRead] } func toolbarDefaultItemIdentifiers(_ toolbar: NSToolbar) -> [NSToolbarItem.Identifier] { return [.shareItem, .toggleItemRead] } } #endif