310 lines
12 KiB
Swift
310 lines
12 KiB
Swift
//
|
|
// SceneDelegate.swift
|
|
// Reader
|
|
//
|
|
// Created by Shadowfacts on 10/29/21.
|
|
//
|
|
|
|
import Foundation
|
|
import UIKit
|
|
import OSLog
|
|
import Persistence
|
|
|
|
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 ?? session.stateRestorationActivity
|
|
|
|
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 !connectionOptions.urlContexts.isEmpty {
|
|
self.scene(scene, openURLContexts: connectionOptions.urlContexts)
|
|
} else if let activity = activity {
|
|
await 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).
|
|
}
|
|
|
|
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.
|
|
|
|
if let fervorController = fervorController {
|
|
Task(priority: .userInitiated) {
|
|
await fervorController.syncReadToServer()
|
|
}
|
|
Task(priority: .userInitiated) {
|
|
await WidgetHelper.updateWidgetData(fervorController: fervorController)
|
|
}
|
|
}
|
|
|
|
BackgroundManager.shared.scheduleRefresh()
|
|
}
|
|
|
|
func stateRestorationActivity(for scene: UIScene) -> NSUserActivity? {
|
|
return (window!.rootViewController as! AppSplitViewController).stateRestorationActivity()
|
|
}
|
|
|
|
func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
|
|
Task { @MainActor in
|
|
await setupUI(from: userActivity)
|
|
}
|
|
}
|
|
|
|
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
|
|
let url = URLContexts.first!.url
|
|
guard url.scheme == "reader",
|
|
url.host == "item",
|
|
let itemID = url.pathComponents.last else {
|
|
logger.error("Launched with unknown URL: \(url.absoluteString, privacy: .public)")
|
|
return
|
|
}
|
|
guard let split = window?.rootViewController as? AppSplitViewController else {
|
|
logger.error("Could not handle URL: missing split VC")
|
|
return
|
|
}
|
|
let req = Item.fetchRequest()
|
|
req.predicate = NSPredicate(format: "id = %@", itemID)
|
|
if let items = try? fervorController.persistentContainer.viewContext.fetch(req),
|
|
let item = items.first {
|
|
split.showItem(item)
|
|
Task {
|
|
await fervorController.markItem(item, read: true)
|
|
}
|
|
} else {
|
|
Task {
|
|
if let item = try? await fervorController.fetchItem(id: itemID) {
|
|
split.showItem(item)
|
|
await fervorController.markItem(item, read: true)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func setupUI(from activity: NSUserActivity) async {
|
|
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.showItemList(.unread)
|
|
case NSUserActivity.readAllType:
|
|
split.showItemList(.all)
|
|
case NSUserActivity.readFeedType:
|
|
guard let feedID = activity.feedID else {
|
|
break
|
|
}
|
|
let req = Feed.fetchRequest()
|
|
req.predicate = NSPredicate(format: "id = %@", feedID)
|
|
if let feed = try? fervorController.persistentContainer.viewContext.fetch(req).first {
|
|
split.showItemList(.feed(feed))
|
|
}
|
|
case NSUserActivity.readGroupType:
|
|
guard let groupID = activity.groupID else {
|
|
break
|
|
}
|
|
let req = Group.fetchRequest()
|
|
req.predicate = NSPredicate(format: "id = %@", groupID)
|
|
if let group = try? fervorController.persistentContainer.viewContext.fetch(req).first {
|
|
split.showItemList(.group(group))
|
|
}
|
|
case NSUserActivity.readItemType:
|
|
guard let itemID = activity.itemID else {
|
|
break
|
|
}
|
|
let req = Item.fetchRequest()
|
|
req.predicate = NSPredicate(format: "id = %@", itemID)
|
|
var read: ReadViewController? = nil
|
|
if let item = try? fervorController.persistentContainer.viewContext.fetch(req).first {
|
|
read = split.showItem(item)
|
|
} else {
|
|
if let item = try? await fervorController.fetchItem(id: itemID) {
|
|
read = split.showItem(item)
|
|
}
|
|
}
|
|
read?.restoreUserActivityState(activity)
|
|
default:
|
|
logger.warning("Unknown user activity type: \(activity.activityType)")
|
|
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: true)
|
|
}
|
|
|
|
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
|