Refactor AppDelegate (milestone 1)

Core/PixelEvent.swift

@@ -1885,7 +1885,7 @@ extension Pixel.Event {
         case .openAIChatFromAddressBar: return "m_aichat_addressbar_icon"
 
         // MARK: Lifecycle
-        case .appDidTransitionToUnexpectedState: return "m_debug_app-did-transition-to-unexpected-state"
+        case .appDidTransitionToUnexpectedState: return "m_debug_app-did-transition-to-unexpected-state-2"
 
         }
     }

DuckDuckGo.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -32,8 +32,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/DuckDuckGo/BrowserServicesKit",
       "state" : {
-        "revision" : "b71ed70ce9b0ef3ce51d4f96da0193ab70493944",
-        "version" : "221.3.0"
+        "branch" : "jacek/refactor-app-delegate",
+        "revision" : "3712ccc0b6867e08b6235083f7e754d537f0b5cb"
       }
     },
     {

DuckDuckGo/AppDelegate+AppDeepLinks.swift

@@ -20,7 +20,7 @@
 import UIKit
 import Core
 
-extension AppDelegate {
+extension OldAppDelegate {
 
     func handleAppDeepLink(_ app: UIApplication, _ mainViewController: MainViewController?, _ url: URL) -> Bool {
         guard let mainViewController else { return false }

DuckDuckGo/AppDependencies.swift

@@ -0,0 +1,58 @@
+//
+//  AppDependencies.swift
+//  DuckDuckGo
+//
+//  Copyright © 2024 DuckDuckGo. All rights reserved.
+//
+//  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 Subscription
+import UIKit
+import Core
+import DDGSync
+import Combine
+import BrowserServicesKit
+
+struct AppDependencies {
+
+    let accountManager: AccountManager
+    let vpnWorkaround: VPNRedditSessionWorkaround
+    let vpnFeatureVisibility: DefaultNetworkProtectionVisibility
+
+    let appSettings: AppSettings
+    let privacyStore: PrivacyUserDefaults
+
+    let uiService: UIService
+    let mainViewController: MainViewController
+
+    let voiceSearchHelper: VoiceSearchHelper
+    let autoClear: AutoClear
+    let autofillLoginSession: AutofillLoginSession
+    let marketplaceAdPostbackManager: MarketplaceAdPostbackManaging
+    let syncService: DDGSync
+    let syncDataProviders: SyncDataProviders
+    let isSyncInProgressCancellable: AnyCancellable
+    let privacyProDataReporter: PrivacyProDataReporting
+    let remoteMessagingClient: RemoteMessagingClient
+
+    let subscriptionService: SubscriptionService
+
+    let onboardingPixelReporter: OnboardingPixelReporter
+    let widgetRefreshModel: NetworkProtectionWidgetRefreshModel
+    let autofillPixelReporter: AutofillPixelReporter
+    let crashReportUploaderOnboarding: CrashCollectionOnboarding
+
+    var syncDidFinishCancellable: AnyCancellable?
+
+}

DuckDuckGo/AppLifecycle/AppStateMachine.swift

@@ -21,27 +21,30 @@ import UIKit
 
 enum AppEvent {
 
-    case launching(UIApplication, launchOptions: [UIApplication.LaunchOptionsKey: Any]?)
-    case activating(UIApplication)
-    case backgrounding(UIApplication)
-    case suspending(UIApplication)
+    case launching(UIApplication, isTesting: Bool)
+    case activating
+    case backgrounding
+    case suspending
 
     case openURL(URL)
+    case handleShortcutItem(UIApplicationShortcutItem)
 
 }
 
 protocol AppState {
 
-    func apply(event: AppEvent) -> any AppState
+    mutating func apply(event: AppEvent) -> any AppState
 
 }
 
 protocol AppEventHandler {
 
+    @MainActor
     func handle(_ event: AppEvent)
 
 }
 
+@MainActor
 final class AppStateMachine: AppEventHandler {
 
     private(set) var currentState: any AppState = Init()

DuckDuckGo/AppLifecycle/AppStateTransitions.swift

@@ -24,8 +24,11 @@ extension Init {
 
     func apply(event: AppEvent) -> any AppState {
         switch event {
-        case .launching(let application, let launchOptions):
-            return Launched(application: application, launchOptions: launchOptions)
+        case .launching(let application, let isTesting):
+            if isTesting {
+                return Testing(application: application)
+            }
+            return Launched(stateContext: makeStateContext(application: application))
         default:
             return handleUnexpectedEvent(event)
         }
@@ -35,14 +38,18 @@ extension Init {
 
 extension Launched {
 
-    func apply(event: AppEvent) -> any AppState {
+    mutating func apply(event: AppEvent) -> any AppState {
         switch event {
-        case .activating(let application):
-            return Active(application: application)
-        case .openURL:
+        case .activating:
+            return Active(stateContext: makeStateContext())
+        case .openURL(let url):
+            urlToOpen = url
+            return self
+        case .handleShortcutItem(let shortcutItem):
+            shortcutItemToHandle = shortcutItem
             return self
         case .backgrounding:
-            return InactiveBackground()
+            return Background(stateContext: makeStateContext())
         case .launching, .suspending:
             return handleUnexpectedEvent(event)
         }
@@ -54,9 +61,13 @@ extension Active {
 
     func apply(event: AppEvent) -> any AppState {
         switch event {
-        case .suspending(let application):
-            return Inactive(application: application)
-        case .openURL:
+        case .suspending:
+            return Inactive(stateContext: makeStateContext())
+        case .openURL(let url):
+            openURL(url)
+            return self
+        case .handleShortcutItem(let shortcutItem):
+            handleShortcutItem(shortcutItem)
             return self
         case .launching, .activating, .backgrounding:
             return handleUnexpectedEvent(event)
@@ -67,15 +78,16 @@ extension Active {
 
 extension Inactive {
 
-    func apply(event: AppEvent) -> any AppState {
+    mutating func apply(event: AppEvent) -> any AppState {
         switch event {
-        case .backgrounding(let application):
-            return Background(application: application)
-        case .activating(let application):
-            return Active(application: application)
-        case .openURL:
+        case .backgrounding:
+            return Background(stateContext: makeStateContext())
+        case .activating:
+            return Active(stateContext: makeStateContext())
+        case .openURL(let url):
+            urlToOpen = url
             return self
-        case .launching, .suspending:
+        case .launching, .suspending, .handleShortcutItem:
             return handleUnexpectedEvent(event)
         }
     }
@@ -84,55 +96,29 @@ extension Inactive {
 
 extension Background {
 
-    func apply(event: AppEvent) -> any AppState {
+    mutating func apply(event: AppEvent) -> any AppState {
         switch event {
-        case .activating(let application):
-            return Active(application: application)
-        case .openURL:
+        case .activating:
+            return Active(stateContext: makeStateContext())
+        case .openURL(let url):
+            urlToOpen = url
             return self
         case .backgrounding:
-            return DoubleBackground()
+            run()
+            return self
+        case .handleShortcutItem(let shortcutItem):
+            shortcutItemToHandle = shortcutItem
+            return self
         case .launching, .suspending:
             return handleUnexpectedEvent(event)
         }
     }
 
 }
 
-extension DoubleBackground {
-
-    func apply(event: AppEvent) -> any AppState {
-        // report event so we know what events can be called at this moment, but do not let SM be stuck in this state just not to be flooded with these events
-        _ = handleUnexpectedEvent(event)
-
-        switch event {
-        case .activating(let application):
-            return Active(application: application)
-        case .suspending(let application):
-            return Inactive(application: application)
-        case .launching, .backgrounding, .openURL:
-            return self
-        }
-
-    }
-
-}
-
-extension InactiveBackground {
+extension Testing {
 
-    func apply(event: AppEvent) -> any AppState {
-        // report event so we know what events can be called at this moment, but do not let SM be stuck in this state just not to be flooded with these events
-        _ = handleUnexpectedEvent(event)
-
-        switch event {
-        case .activating(let application):
-            return Active(application: application)
-        case .suspending(let application):
-            return Inactive(application: application)
-        case .launching, .backgrounding, .openURL:
-            return self
-        }
-    }
+    func apply(event: AppEvent) -> any AppState { self }
 
 }
 
@@ -145,6 +131,7 @@ extension AppEvent {
         case .backgrounding: return "backgrounding"
         case .suspending: return "suspending"
         case .openURL: return "openURL"
+        case .handleShortcutItem: return "handleShortcutItem"
         }
     }