mirror of
https://github.com/Ranchero-Software/NetNewsWire.git
synced 2024-12-22 07:34:09 +01:00
475 lines
14 KiB
Swift
475 lines
14 KiB
Swift
//
|
|
// AppDelegate.swift
|
|
// NetNewsWire
|
|
//
|
|
// Created by Maurice Parker on 4/8/19.
|
|
// Copyright © 2019 Ranchero Software. All rights reserved.
|
|
//
|
|
|
|
import UIKit
|
|
import Web
|
|
import Account
|
|
@preconcurrency import BackgroundTasks
|
|
import os.log
|
|
import WidgetKit
|
|
import Core
|
|
import Images
|
|
import libxml2
|
|
|
|
@MainActor var appDelegate: AppDelegate!
|
|
|
|
@UIApplicationMain
|
|
final class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate, UnreadCountProvider {
|
|
|
|
private var bgTaskDispatchQueue = DispatchQueue.init(label: "BGTaskScheduler")
|
|
|
|
private var waitBackgroundUpdateTask = UIBackgroundTaskIdentifier.invalid
|
|
private var syncBackgroundUpdateTask = UIBackgroundTaskIdentifier.invalid
|
|
|
|
var syncTimer: ArticleStatusSyncTimer?
|
|
|
|
var shuttingDown = false {
|
|
didSet {
|
|
if shuttingDown {
|
|
syncTimer?.shuttingDown = shuttingDown
|
|
syncTimer?.invalidate()
|
|
}
|
|
}
|
|
}
|
|
|
|
nonisolated(unsafe) let log = OSLog(subsystem: Bundle.main.bundleIdentifier!, category: "Application")
|
|
|
|
var userNotificationManager: UserNotificationManager!
|
|
var extensionContainersFile: ExtensionContainersFile!
|
|
var extensionFeedAddRequestFile: ExtensionFeedAddRequestFile!
|
|
|
|
var unreadCount = 0 {
|
|
didSet {
|
|
if unreadCount != oldValue {
|
|
handleUnreadCountDidChange()
|
|
}
|
|
}
|
|
}
|
|
|
|
var isSyncArticleStatusRunning = false
|
|
var isWaitingForSyncTasks = false
|
|
|
|
override init() {
|
|
|
|
xmlInitParser()
|
|
|
|
super.init()
|
|
|
|
appDelegate = self
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(unreadCountDidChange(_:)), name: .UnreadCountDidChange, object: nil)
|
|
NotificationCenter.default.addObserver(self, selector: #selector(accountRefreshDidFinish(_:)), name: .AccountRefreshDidFinish, object: nil)
|
|
}
|
|
|
|
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
|
|
|
|
AppDefaults.registerDefaults()
|
|
if AppDefaults.shared.isFirstRun {
|
|
os_log(.debug, "Is first run.")
|
|
}
|
|
|
|
FaviconGenerator.faviconTemplateImage = AppAsset.faviconTemplateImage
|
|
|
|
importFeedsIfNeeded()
|
|
|
|
registerBackgroundTasks()
|
|
CacheCleaner.purgeIfNecessary()
|
|
initializeDownloaders()
|
|
initializeHomeScreenQuickActions()
|
|
|
|
Task { @MainActor in
|
|
self.unreadCount = AccountManager.shared.unreadCount
|
|
}
|
|
|
|
UNUserNotificationCenter.current().requestAuthorization(options:[.badge, .sound, .alert]) { (granted, error) in
|
|
if granted {
|
|
Task { @MainActor in
|
|
UIApplication.shared.registerForRemoteNotifications()
|
|
}
|
|
}
|
|
}
|
|
|
|
UNUserNotificationCenter.current().delegate = self
|
|
userNotificationManager = UserNotificationManager()
|
|
|
|
extensionContainersFile = ExtensionContainersFile()
|
|
extensionFeedAddRequestFile = ExtensionFeedAddRequestFile()
|
|
|
|
syncTimer = ArticleStatusSyncTimer()
|
|
|
|
#if DEBUG
|
|
syncTimer!.update()
|
|
#endif
|
|
|
|
return true
|
|
}
|
|
|
|
func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any]) async -> UIBackgroundFetchResult {
|
|
|
|
resumeDatabaseProcessingIfNecessary()
|
|
await AccountManager.shared.receiveRemoteNotification(userInfo: userInfo)
|
|
suspendApplication()
|
|
return .newData
|
|
}
|
|
|
|
func applicationWillTerminate(_ application: UIApplication) {
|
|
shuttingDown = true
|
|
}
|
|
|
|
func applicationDidEnterBackground(_ application: UIApplication) {
|
|
|
|
ArticleStringFormatter.emptyCaches()
|
|
MultilineUILabelSizer.emptyCache()
|
|
SingleLineUILabelSizer.emptyCache()
|
|
IconImageCache.shared.emptyCache()
|
|
AccountManager.shared.emptyCaches()
|
|
|
|
Task.detached {
|
|
await DownloadWithCacheManager.shared.cleanupCache()
|
|
}
|
|
}
|
|
|
|
// MARK: Notifications
|
|
|
|
@objc func unreadCountDidChange(_ note: Notification) {
|
|
if note.object is AccountManager {
|
|
unreadCount = AccountManager.shared.unreadCount
|
|
}
|
|
}
|
|
|
|
@objc func accountRefreshDidFinish(_ note: Notification) {
|
|
AppDefaults.shared.lastRefresh = Date()
|
|
}
|
|
|
|
// MARK: - API
|
|
|
|
func manualRefresh(errorHandler: @escaping (Error) -> ()) {
|
|
|
|
let sceneDelegates = UIApplication.shared.connectedScenes.compactMap{ $0.delegate as? SceneDelegate }
|
|
for sceneDelegate in sceneDelegates {
|
|
sceneDelegate.cleanUp(conditional: true)
|
|
}
|
|
|
|
Task { @MainActor in
|
|
await AccountManager.shared.refreshAll(errorHandler: errorHandler)
|
|
}
|
|
}
|
|
|
|
func resumeDatabaseProcessingIfNecessary() {
|
|
if AccountManager.shared.isSuspended {
|
|
AccountManager.shared.resumeAll()
|
|
os_log("Application processing resumed.", log: self.log, type: .info)
|
|
}
|
|
}
|
|
|
|
func prepareAccountsForBackground() {
|
|
extensionFeedAddRequestFile.suspend()
|
|
syncTimer?.invalidate()
|
|
scheduleBackgroundFeedRefresh()
|
|
syncArticleStatus()
|
|
waitForSyncTasksToFinish()
|
|
}
|
|
|
|
func prepareAccountsForForeground() {
|
|
extensionFeedAddRequestFile.resume()
|
|
syncTimer?.update()
|
|
|
|
Task { @MainActor in
|
|
if let lastRefresh = AppDefaults.shared.lastRefresh {
|
|
if Date() > lastRefresh.addingTimeInterval(15 * 60) {
|
|
await AccountManager.shared.refreshAll(errorHandler: ErrorHandler.log)
|
|
} else {
|
|
await AccountManager.shared.syncArticleStatusAll()
|
|
}
|
|
} else {
|
|
await AccountManager.shared.refreshAll(errorHandler: ErrorHandler.log)
|
|
}
|
|
}
|
|
}
|
|
|
|
nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
|
|
|
|
completionHandler([.list, .banner, .badge, .sound])
|
|
}
|
|
|
|
nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
|
|
|
|
MainActor.assumeIsolated {
|
|
defer { completionHandler() }
|
|
|
|
let userInfo = response.notification.request.content.userInfo
|
|
|
|
switch response.actionIdentifier {
|
|
case "MARK_AS_READ":
|
|
handleMarkAsRead(userInfo: userInfo)
|
|
case "MARK_AS_STARRED":
|
|
handleMarkAsStarred(userInfo: userInfo)
|
|
default:
|
|
if let sceneDelegate = response.targetScene?.delegate as? SceneDelegate {
|
|
sceneDelegate.handle(response)
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5, execute: {
|
|
sceneDelegate.coordinator.dismissIfLaunchingFromExternalAction()
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: App Initialization
|
|
|
|
private extension AppDelegate {
|
|
|
|
private func initializeHomeScreenQuickActions() {
|
|
let unreadTitle = NSLocalizedString("First Unread", comment: "First Unread")
|
|
let unreadIcon = UIApplicationShortcutIcon(systemImageName: "chevron.down.circle")
|
|
let unreadItem = UIApplicationShortcutItem(type: "com.ranchero.NetNewsWire.FirstUnread", localizedTitle: unreadTitle, localizedSubtitle: nil, icon: unreadIcon, userInfo: nil)
|
|
|
|
let searchTitle = NSLocalizedString("Search", comment: "Search")
|
|
let searchIcon = UIApplicationShortcutIcon(systemImageName: "magnifyingglass")
|
|
let searchItem = UIApplicationShortcutItem(type: "com.ranchero.NetNewsWire.ShowSearch", localizedTitle: searchTitle, localizedSubtitle: nil, icon: searchIcon, userInfo: nil)
|
|
|
|
let addTitle = NSLocalizedString("Add Feed", comment: "Add Feed")
|
|
let addIcon = UIApplicationShortcutIcon(systemImageName: "plus")
|
|
let addItem = UIApplicationShortcutItem(type: "com.ranchero.NetNewsWire.ShowAdd", localizedTitle: addTitle, localizedSubtitle: nil, icon: addIcon, userInfo: nil)
|
|
|
|
UIApplication.shared.shortcutItems = [addItem, searchItem, unreadItem]
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: Go To Background
|
|
|
|
private extension AppDelegate {
|
|
|
|
func waitForSyncTasksToFinish() {
|
|
guard !isWaitingForSyncTasks && UIApplication.shared.applicationState == .background else { return }
|
|
|
|
isWaitingForSyncTasks = true
|
|
|
|
self.waitBackgroundUpdateTask = UIApplication.shared.beginBackgroundTask { [weak self] in
|
|
guard let self = self else { return }
|
|
self.completeProcessing(true)
|
|
os_log("Accounts wait for progress terminated for running too long.", log: self.log, type: .info)
|
|
}
|
|
|
|
DispatchQueue.main.async { [weak self] in
|
|
self?.waitToComplete() { [weak self] suspend in
|
|
self?.completeProcessing(suspend)
|
|
}
|
|
}
|
|
}
|
|
|
|
func waitToComplete(completion: @escaping (Bool) -> Void) {
|
|
guard UIApplication.shared.applicationState == .background else {
|
|
os_log("App came back to foreground, no longer waiting.", log: self.log, type: .info)
|
|
completion(false)
|
|
return
|
|
}
|
|
|
|
if AccountManager.shared.refreshInProgress || isSyncArticleStatusRunning {
|
|
os_log("Waiting for sync to finish...", log: self.log, type: .info)
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
|
|
self?.waitToComplete(completion: completion)
|
|
}
|
|
} else {
|
|
os_log("Refresh progress complete.", log: self.log, type: .info)
|
|
completion(true)
|
|
}
|
|
}
|
|
|
|
func completeProcessing(_ suspend: Bool) {
|
|
if suspend {
|
|
suspendApplication()
|
|
}
|
|
UIApplication.shared.endBackgroundTask(self.waitBackgroundUpdateTask)
|
|
self.waitBackgroundUpdateTask = UIBackgroundTaskIdentifier.invalid
|
|
isWaitingForSyncTasks = false
|
|
}
|
|
|
|
func syncArticleStatus() {
|
|
guard !isSyncArticleStatusRunning else { return }
|
|
|
|
isSyncArticleStatusRunning = true
|
|
|
|
let completeProcessing = { [unowned self] in
|
|
self.isSyncArticleStatusRunning = false
|
|
UIApplication.shared.endBackgroundTask(self.syncBackgroundUpdateTask)
|
|
self.syncBackgroundUpdateTask = UIBackgroundTaskIdentifier.invalid
|
|
}
|
|
|
|
self.syncBackgroundUpdateTask = UIApplication.shared.beginBackgroundTask {
|
|
completeProcessing()
|
|
os_log("Accounts sync processing terminated for running too long.", log: self.log, type: .info)
|
|
}
|
|
|
|
Task { @MainActor in
|
|
await AccountManager.shared.syncArticleStatusAll()
|
|
completeProcessing()
|
|
}
|
|
}
|
|
|
|
func suspendApplication() {
|
|
guard UIApplication.shared.applicationState == .background else { return }
|
|
|
|
AccountManager.shared.suspendNetworkAll()
|
|
AccountManager.shared.suspendDatabaseAll()
|
|
ArticleThemeDownloader.cleanUp()
|
|
|
|
CoalescingQueue.standard.performCallsImmediately()
|
|
for scene in UIApplication.shared.connectedScenes {
|
|
if let sceneDelegate = scene.delegate as? SceneDelegate {
|
|
sceneDelegate.suspend()
|
|
}
|
|
}
|
|
|
|
os_log("Application processing suspended.", log: self.log, type: .info)
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: Background Tasks
|
|
|
|
private extension AppDelegate {
|
|
|
|
/// Register all background tasks.
|
|
func registerBackgroundTasks() {
|
|
// Register background feed refresh.
|
|
BGTaskScheduler.shared.register(forTaskWithIdentifier: "com.ranchero.NetNewsWire.FeedRefresh", using: nil) { (task) in
|
|
self.performBackgroundFeedRefresh(with: task as! BGAppRefreshTask)
|
|
}
|
|
}
|
|
|
|
/// Schedules a background app refresh based on `AppDefaults.refreshInterval`.
|
|
func scheduleBackgroundFeedRefresh() {
|
|
let request = BGAppRefreshTaskRequest(identifier: "com.ranchero.NetNewsWire.FeedRefresh")
|
|
request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
|
|
|
|
// We send this to a dedicated serial queue because as of 11/05/19 on iOS 13.2 the call to the
|
|
// task scheduler can hang indefinitely.
|
|
bgTaskDispatchQueue.async {
|
|
do {
|
|
try BGTaskScheduler.shared.submit(request)
|
|
} catch {
|
|
Task { @MainActor in
|
|
os_log(.error, log: self.log, "Could not schedule app refresh: %@", error.localizedDescription)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Performs background feed refresh.
|
|
/// - Parameter task: `BGAppRefreshTask`
|
|
/// - Warning: As of Xcode 11 beta 2, when triggered from the debugger this doesn't work.
|
|
func performBackgroundFeedRefresh(with task: BGAppRefreshTask) {
|
|
|
|
scheduleBackgroundFeedRefresh() // schedule next refresh
|
|
|
|
os_log("Woken to perform account refresh.", log: self.log, type: .info)
|
|
|
|
Task { @MainActor in
|
|
if AccountManager.shared.isSuspended {
|
|
AccountManager.shared.resumeAll()
|
|
}
|
|
await AccountManager.shared.refreshAll(errorHandler: ErrorHandler.log)
|
|
if !AccountManager.shared.isSuspended {
|
|
try? WidgetDataEncoder.shared.encodeWidgetData()
|
|
self.suspendApplication()
|
|
os_log("Account refresh operation completed.", log: self.log, type: .info)
|
|
task.setTaskCompleted(success: true)
|
|
}
|
|
}
|
|
|
|
// set expiration handler
|
|
task.expirationHandler = { [weak task] in
|
|
DispatchQueue.main.sync {
|
|
self.suspendApplication()
|
|
}
|
|
os_log("Accounts refresh processing terminated for running too long.", log: self.log, type: .info)
|
|
task?.setTaskCompleted(success: false)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Handle Notification Actions
|
|
|
|
private extension AppDelegate {
|
|
|
|
@MainActor func handleMarkAsRead(userInfo: [AnyHashable: Any]) {
|
|
|
|
guard let articlePathInfo = ArticlePathInfo(userInfo: userInfo) else {
|
|
return
|
|
}
|
|
|
|
resumeDatabaseProcessingIfNecessary()
|
|
|
|
guard let accountID = articlePathInfo.accountID, let account = AccountManager.shared.existingAccount(with: accountID) else {
|
|
os_log(.debug, "No account found from notification.")
|
|
return
|
|
}
|
|
guard let articleID = articlePathInfo.articleID else {
|
|
os_log(.debug, "No articleID found from notification.")
|
|
return
|
|
}
|
|
|
|
Task { @MainActor in
|
|
guard let articles = try? await account.articles(for: .articleIDs([articleID])) else {
|
|
os_log(.debug, "No article found from search using %@", articleID)
|
|
return
|
|
}
|
|
|
|
try? await account.markArticles(articles, statusKey: .read, flag: true)
|
|
|
|
self.prepareAccountsForBackground()
|
|
|
|
try? await account.syncArticleStatus()
|
|
if !AccountManager.shared.isSuspended {
|
|
try? WidgetDataEncoder.shared.encodeWidgetData()
|
|
self.prepareAccountsForBackground()
|
|
self.suspendApplication()
|
|
}
|
|
}
|
|
}
|
|
|
|
@MainActor func handleMarkAsStarred(userInfo: [AnyHashable: Any]) {
|
|
|
|
guard let articlePathInfo = ArticlePathInfo(userInfo: userInfo) else {
|
|
return
|
|
}
|
|
|
|
resumeDatabaseProcessingIfNecessary()
|
|
|
|
guard let accountID = articlePathInfo.accountID, let account = AccountManager.shared.existingAccount(with: accountID) else {
|
|
os_log(.debug, "No account found from notification.")
|
|
return
|
|
}
|
|
guard let articleID = articlePathInfo.articleID else {
|
|
os_log(.debug, "No articleID found from notification.")
|
|
return
|
|
}
|
|
|
|
Task { @MainActor in
|
|
|
|
guard let articles = try? await account.articles(for: .articleIDs([articleID])) else {
|
|
os_log(.debug, "No article found from search using %@", articleID)
|
|
return
|
|
}
|
|
|
|
try? await account.markArticles(articles, statusKey: .starred, flag: true)
|
|
|
|
try? await account.syncArticleStatus()
|
|
if !AccountManager.shared.isSuspended {
|
|
try? WidgetDataEncoder.shared.encodeWidgetData()
|
|
self.prepareAccountsForBackground()
|
|
self.suspendApplication()
|
|
}
|
|
}
|
|
}
|
|
}
|