Introduce an AppMediator which will:

- combine multiple services to handle app wide requests
- remove direct UIApplication access from everywhere
- fix #2703 by combining UIApplication.applicationState with the WindowManager's main window appearance
- leave the door open for more app control in the future (especiall for the mac)

ElementX/Sources/Application/AppCoordinator.swift

@@ -24,6 +24,7 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
     private let stateMachine: AppCoordinatorStateMachine
     private let navigationRootCoordinator: NavigationRootCoordinator
     private let userSessionStore: UserSessionStoreProtocol
+    private let appMediator: AppMediator
     private let appSettings: AppSettings
     private let appDelegate: AppDelegate
 
@@ -65,6 +66,8 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
 
     init(appDelegate: AppDelegate) {
         windowManager = WindowManager(appDelegate: appDelegate)
+        appMediator = AppMediator(windowManager: windowManager)
+        
         Self.setupEnvironmentVariables()
         
         let appSettings = AppSettings()
@@ -100,9 +103,7 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
                 
         navigationRootCoordinator.setRootCoordinator(SplashScreenCoordinator())
 
-        backgroundTaskService = UIKitBackgroundTaskService {
-            UIApplication.shared
-        }
+        backgroundTaskService = UIKitBackgroundTaskService(appMediator: appMediator)
 
         let keychainController = KeychainController(service: .sessions,
                                                     accessGroup: InfoPlistReader.main.keychainAccessGroupIdentifier)
@@ -409,6 +410,7 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
         authenticationFlowCoordinator = AuthenticationFlowCoordinator(authenticationService: authenticationService,
                                                                       bugReportService: ServiceLocator.shared.bugReportService,
                                                                       navigationRootCoordinator: navigationRootCoordinator,
+                                                                      appMediator: appMediator,
                                                                       appSettings: appSettings,
                                                                       analytics: ServiceLocator.shared.analytics,
                                                                       userIndicatorController: ServiceLocator.shared.userIndicatorController,
@@ -471,6 +473,7 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
                                                                     appLockService: appLockFlowCoordinator.appLockService,
                                                                     bugReportService: ServiceLocator.shared.bugReportService,
                                                                     roomTimelineControllerFactory: RoomTimelineControllerFactory(),
+                                                                    appMediator: appMediator,
                                                                     appSettings: appSettings,
                                                                     analytics: ServiceLocator.shared.analytics,
                                                                     notificationManager: notificationManager,
@@ -645,7 +648,7 @@ class AppCoordinator: AppCoordinatorProtocol, AuthenticationFlowCoordinatorDeleg
     
     private func handleAppRoute(_ appRoute: AppRoute) {
         if let userSessionFlowCoordinator {
-            userSessionFlowCoordinator.handleAppRoute(appRoute, animated: UIApplication.shared.applicationState == .active)
+            userSessionFlowCoordinator.handleAppRoute(appRoute, animated: appMediator.appState == .active)
         } else {
             storedAppRoute = appRoute
         }

ElementX/Sources/Application/AppMediator.swift

@@ -0,0 +1,68 @@
+//
+// Copyright 2024 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import UIKit
+
+class AppMediator: AppMediatorProtocol {
+    private let windowManager: WindowManagerProtocol
+        
+    // UIApplication.State won't update if we store this e.g. in the constructor
+    private var application: UIApplication {
+        UIApplication.shared
+    }
+    
+    init(windowManager: WindowManagerProtocol) {
+        self.windowManager = windowManager
+    }
+    
+    func beginBackgroundTask(withName taskName: String?, expirationHandler handler: (() -> Void)?) -> UIBackgroundTaskIdentifier {
+        application.beginBackgroundTask(withName: taskName, expirationHandler: handler)
+    }
+
+    func endBackgroundTask(_ identifier: UIBackgroundTaskIdentifier) {
+        application.endBackgroundTask(identifier)
+    }
+    
+    func open(_ url: URL) {
+        application.open(url, options: [:], completionHandler: nil)
+    }
+    
+    func openAppSettings() {
+        guard let url = URL(string: UIApplication.openSettingsURLString) else {
+            return
+        }
+        
+        open(url)
+    }
+
+    var backgroundTimeRemaining: TimeInterval {
+        application.backgroundTimeRemaining
+    }
+
+    @MainActor
+    var appState: UIApplication.State {
+        switch application.applicationState {
+        case .active:
+            windowManager.mainWindow.traitCollection.activeAppearance == .active ? .active : .inactive
+        case .inactive:
+            .inactive
+        case .background:
+            .background
+        default:
+            .inactive
+        }
+    }
+}

ElementX/Sources/Application/AppMediatorProtocol.swift

@@ -0,0 +1,63 @@
+//
+// Copyright 2022 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import UIKit
+
+// sourcery: AutoMockable
+protocol AppMediatorProtocol {
+    func beginBackgroundTask(withName taskName: String?, expirationHandler handler: (() -> Void)?) -> UIBackgroundTaskIdentifier
+
+    func endBackgroundTask(_ identifier: UIBackgroundTaskIdentifier)
+    
+    func open(_ url: URL)
+    
+    func openAppSettings()
+
+    var backgroundTimeRemaining: TimeInterval { get }
+
+    var appState: UIApplication.State { get }
+}
+
+extension UIApplication.State: CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case .active:
+            return "active"
+        case .inactive:
+            return "inactive"
+        case .background:
+            return "background"
+        @unknown default:
+            return "unknown"
+        }
+    }
+}
+
+extension UIUserInterfaceActiveAppearance: CustomStringConvertible {
+    public var description: String {
+        switch self {
+        case .active:
+            return "active"
+        case .inactive:
+            return "inactive"
+        case .unspecified:
+            return "unspecified"
+        @unknown default:
+            return "unknown"
+        }
+    }
+}