perf(phase 4): scope ContentView re-renders + lazy startup

DynamicIsland/ContentView.swift

@@ -44,7 +44,13 @@ struct ContentView: View {
     @ObservedObject var timerManager = TimerManager.shared
     @ObservedObject var reminderManager = ReminderLiveActivityManager.shared
     @ObservedObject var batteryModel = BatteryStatusViewModel.shared
-    @ObservedObject var statsManager = StatsManager.shared
+    // NOTE: Intentionally NOT @ObservedObject. `StatsManager` publishes every ~1s,
+    // and observing it here invalidated the entire ContentView body on every tick.
+    // ContentView only uses it for imperative `updateMonitoringState(...)` calls and
+    // for `statsRowCount()` (which reads @Default flags, not published stats values).
+    // The live stats UI (`NotchStatsView`) owns its own @ObservedObject StatsManager,
+    // so reactivity for the stats display is preserved and now scoped to that leaf.
+    let statsManager = StatsManager.shared
     @ObservedObject var recordingManager = ScreenRecordingManager.shared
     @ObservedObject var privacyManager = PrivacyIndicatorManager.shared
     @ObservedObject var doNotDisturbManager = DoNotDisturbManager.shared
@@ -212,6 +218,11 @@ struct ContentView: View {
     @State private var hiddenEdgeHoverPollingTask: Task<Void, Never>?
     @State private var isHoveringClosedMusicWaveformControl: Bool = false
 
+    /// Cached result of the `NSScreen.screens` notch scan (see `isNonNotchScreen`).
+    /// Defaults to `true`, matching the original "screen not found" fallback, and
+    /// is refreshed on appear / screen-parameter change / selected-screen change.
+    @State private var cachedIsNonNotchScreen: Bool = true
+
     @State private var gestureProgress: CGFloat = .zero
     @State private var skipGestureActiveDirection: MusicManager.SkipDirection?
     @State private var isMusicControlWindowVisible = false
@@ -384,13 +395,34 @@ struct ContentView: View {
     }
 
     /// Whether the current screen lacks a physical notch.
+    ///
+    /// Reads a cached value instead of scanning `NSScreen.screens` on every body
+    /// evaluation. The cache is recomputed only when its inputs can change:
+    /// on appear, when the screen configuration changes
+    /// (`didChangeScreenParametersNotification`), or when the selected screen
+    /// name changes. Behaviour is identical to the previous inline scan.
     private var isNonNotchScreen: Bool {
+        cachedIsNonNotchScreen
+    }
+
+    /// Performs the actual `NSScreen.screens` scan that backs `isNonNotchScreen`.
+    /// Kept behaviour-identical to the original computed property (including the
+    /// `true` fallback when no matching screen is found).
+    private func computeIsNonNotchScreen() -> Bool {
         guard let screen = NSScreen.screens.first(where: { $0.localizedName == currentScreenName }) else {
             return true
         }
         return screen.safeAreaInsets.top <= 0
     }
 
+    /// Refreshes `cachedIsNonNotchScreen` if the scan result has changed.
+    private func refreshIsNonNotchScreenCache() {
+        let value = computeIsNonNotchScreen()
+        if value != cachedIsNonNotchScreen {
+            cachedIsNonNotchScreen = value
+        }
+    }
+
     /// Whether the global sneak peek is visible on this specific screen.
     private var isSneakPeekVisibleOnCurrentScreen: Bool {
         guard coordinator.sneakPeek.show else { return false }
@@ -741,6 +773,7 @@ struct ContentView: View {
     private func installPrimaryRootLifecycleHandlers<Content: View>(on view: Content) -> some View {
         view
             .onAppear {
+                refreshIsNonNotchScreenCache()
                 isMusicControlWindowSuppressed = vm.notchState != .closed
                     || lockScreenManager.isLocked
                     || isMusicHUDDeferredAfterUnlock
@@ -858,6 +891,12 @@ struct ContentView: View {
                     enqueueMusicControlWindowSync(forceRefresh: true)
                 }
             }
+            .onChange(of: currentScreenName) { _, _ in
+                refreshIsNonNotchScreenCache()
+            }
+            .onReceive(NotificationCenter.default.publisher(for: NSApplication.didChangeScreenParametersNotification)) { _ in
+                refreshIsNonNotchScreenCache()
+            }
             .onDisappear {
                 performViewTeardown()
             }

DynamicIsland/DynamicIslandApp.swift

@@ -108,17 +108,23 @@ class AppDelegate: NSObject, NSApplicationDelegate {
     @ObservedObject var coordinator = DynamicIslandViewCoordinator.shared
     var whatsNewWindow: NSWindow?
     var timer: Timer?
-    let calendarManager = CalendarManager.shared
-    let webcamManager = WebcamManager.shared
-    let dndManager = DoNotDisturbManager.shared  // NEW: DND detection
-    let bluetoothAudioManager = BluetoothAudioManager.shared  // NEW: Bluetooth audio detection
-    let idleAnimationManager = IdleAnimationManager.shared  // NEW: Custom idle animations
-    let downloadManager = DownloadManager.shared  // NEW: Chromium downloads detection
-    let lockScreenPanelManager = LockScreenPanelManager.shared  // NEW: Lock screen music panel
-    let mediaControlsStateCoordinator = MediaControlsStateCoordinator.shared
-    let systemTimerBridge = SystemTimerBridge.shared
-    let extensionXPCServiceHost = ExtensionXPCServiceHost.shared
-    let extensionRPCServer = ExtensionRPCServer.shared
+    // Feature-dependent managers are lazily initialized so their (sometimes
+    // observer/poller-heavy) `.shared` init does not run synchronously when the
+    // AppDelegate object is allocated (before applicationDidFinishLaunching).
+    // Each is either kept alive by an external owner that is touched during
+    // launch (ContentView / vm / ReminderLiveActivityManager), gated behind its
+    // feature flag, or explicitly touched from the deferred launch block below.
+    lazy var calendarManager = CalendarManager.shared  // owned by ReminderLiveActivityManager (touched at launch)
+    let webcamManager = WebcamManager.shared  // eager: consumed by createDynamicIslandWindow during launch; also owned by vm
+    lazy var dndManager = DoNotDisturbManager.shared  // NEW: DND detection (gated by enableDoNotDisturbDetection; owned by ContentView)
+    lazy var bluetoothAudioManager = BluetoothAudioManager.shared  // NEW: Bluetooth audio detection (deferred touch)
+    lazy var idleAnimationManager = IdleAnimationManager.shared  // NEW: Custom idle animations (touched via deferred initializeDefaultAnimations)
+    lazy var downloadManager = DownloadManager.shared  // NEW: Chromium downloads detection (owned by ContentView)
+    lazy var lockScreenPanelManager = LockScreenPanelManager.shared  // NEW: Lock screen music panel (deferred touch)
+    let mediaControlsStateCoordinator = MediaControlsStateCoordinator.shared  // eager: settings-consistency glue with no other owner; cheap init
+    lazy var systemTimerBridge = SystemTimerBridge.shared  // deferred touch (no external owner; init hosts mirrorSystemTimer observer)
+    let extensionXPCServiceHost = ExtensionXPCServiceHost.shared  // eager: start()/stop() lifecycle driven from launch/terminate
+    let extensionRPCServer = ExtensionRPCServer.shared  // eager: start()/stop() lifecycle driven from launch/terminate
     var closeNotchWorkItem: DispatchWorkItem?
     private var previousScreens: [NSScreen]?
     private var onboardingWindowController: NSWindowController?
@@ -611,10 +617,8 @@ class AppDelegate: NSObject, NSApplicationDelegate {
             }
             .store(in: &cancellables)
 
-        // Initialize idle animations (load bundled + built-in face)
-        idleAnimationManager.initializeDefaultAnimations()
-
-        applySelectedAppIcon()
+        // Idle-animation loading (disk I/O) and app-icon application (disk I/O)
+        // are deferred to the post-first-frame block at the end of this method.
         installTopMenuItemsIfNeeded()
 
         Defaults.publisher(.focusMonitoringMode, options: [])
@@ -926,8 +930,8 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         if coordinator.firstLaunch && !AppRuntimeEnvironment.isUITesting {
             DispatchQueue.main.async {
                 self.showOnboardingWindow()
+                self.playWelcomeSound()
             }
-            playWelcomeSound()
         }
 
         previousScreens = NSScreen.screens
@@ -945,6 +949,36 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         let timerWidgetManager = LockScreenTimerWidgetManager.shared
         timerWidgetManager.handleLockStateChange(isLocked: LockScreenManager.shared.currentLockStatus)
 
+        // Defer non-critical launch work until after the first window/notch is on
+        // screen. This runs on the next main-runloop turn, once the synchronous
+        // launch path (window creation above) has completed.
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+
+            // Idle animations: resolves bundled resource URLs and reconciles the
+            // Defaults keys that back the animation picker. Kept on the main actor
+            // because those Defaults writes have UI observers — and it only resolves
+            // bundle URLs (no file-content reads), so it stays cheap here.
+            self.idleAnimationManager.initializeDefaultAnimations()
+
+            // App icon: the image file read is the one real disk hit on this path,
+            // so load it off-main (mirrors ModelPricingManager.loadInitialPricing)
+            // and publish applicationIconImage back on the main actor.
+            Task.detached(priority: .utility) {
+                let image = loadSelectedAppIconImage()
+                await MainActor.run {
+                    if let image { NSApp.applicationIconImage = image }
+                }
+            }
+
+            // Instantiate always-on managers whose init only registers
+            // observers/pollers. They have no other owner touched during launch,
+            // so they must be materialized here to preserve behavior — just one
+            // runloop later than before, off the synchronous launch path.
+            _ = self.bluetoothAudioManager
+            _ = self.systemTimerBridge
+            _ = self.lockScreenPanelManager
+        }
     }
 
     private func installTopMenuItemsIfNeeded() {

DynamicIsland/MediaControllers/AmazonMusicController.swift

@@ -55,6 +55,10 @@ class FilteredNowPlayingController: ObservableObject, MediaControllerProtocol {
     /// True only after a stream line explicitly identified the selected app as the now playing source.
     private var targetSessionActive = false
 
+    /// Reused across every stream update to avoid re-allocating a formatter
+    /// on each (1+/second) now playing payload.
+    private static let iso8601Formatter = ISO8601DateFormatter()
+
     init?(bundleIdentifier: String, controllerName: String) {
         self.targetBundleIdentifier = bundleIdentifier
         self.controllerName = controllerName
@@ -136,14 +140,18 @@ class FilteredNowPlayingController: ObservableObject, MediaControllerProtocol {
     }
 
     func toggleShuffle() async {
-        MRMediaRemoteSetShuffleModeFunction(playbackState.isShuffled ? 1 : 3)
-        playbackState.isShuffled.toggle()
+        await MainActor.run {
+            MRMediaRemoteSetShuffleModeFunction(playbackState.isShuffled ? 1 : 3)
+            playbackState.isShuffled.toggle()
+        }
     }
 
     func toggleRepeat() async {
-        let newRepeatMode = (playbackState.repeatMode == .off) ? 3 : (playbackState.repeatMode.rawValue - 1)
-        playbackState.repeatMode = RepeatMode(rawValue: newRepeatMode) ?? .off
-        MRMediaRemoteSetRepeatModeFunction(newRepeatMode)
+        await MainActor.run {
+            let newRepeatMode = (playbackState.repeatMode == .off) ? 3 : (playbackState.repeatMode.rawValue - 1)
+            playbackState.repeatMode = RepeatMode(rawValue: newRepeatMode) ?? .off
+            MRMediaRemoteSetRepeatModeFunction(newRepeatMode)
+        }
     }
 
     private func setupNowPlayingObserver() async {
@@ -214,9 +222,12 @@ class FilteredNowPlayingController: ObservableObject, MediaControllerProtocol {
         return state
     }
 
-    private func applyIdleBecauseDifferentSource() {
+    private func applyIdleBecauseDifferentSource() async {
         targetSessionActive = false
-        playbackState = Self.makeIdlePlaybackState(bundleIdentifier: targetBundleIdentifier)
+        let idleState = Self.makeIdlePlaybackState(bundleIdentifier: targetBundleIdentifier)
+        await MainActor.run { [weak self] in
+            self?.playbackState = idleState
+        }
     }
 
     private func handleAdapterUpdate(_ update: NowPlayingUpdate) async {
@@ -233,12 +244,12 @@ class FilteredNowPlayingController: ObservableObject, MediaControllerProtocol {
 
         if let source = explicitSource {
             if source != targetBundleIdentifier {
-                applyIdleBecauseDifferentSource()
+                await applyIdleBecauseDifferentSource()
                 return
             }
             targetSessionActive = true
         } else if !diff {
-            applyIdleBecauseDifferentSource()
+            await applyIdleBecauseDifferentSource()
             return
         } else if !targetSessionActive {
             return
@@ -276,7 +287,7 @@ class FilteredNowPlayingController: ObservableObject, MediaControllerProtocol {
         }
 
         if let dateString = payload.timestamp,
-           let date = ISO8601DateFormatter().date(from: dateString) {
+           let date = Self.iso8601Formatter.date(from: dateString) {
             newPlaybackState.lastUpdated = date
         } else if !diff {
             newPlaybackState.lastUpdated = Date()
@@ -288,7 +299,9 @@ class FilteredNowPlayingController: ObservableObject, MediaControllerProtocol {
         newPlaybackState.isPlaying = payload.playing ?? (diff ? self.playbackState.isPlaying : false)
         newPlaybackState.bundleIdentifier = targetBundleIdentifier
 
-        self.playbackState = newPlaybackState
+        await MainActor.run { [weak self] in
+            self?.playbackState = newPlaybackState
+        }
     }
 }
 

DynamicIsland/MediaControllers/AppleMusicController.swift

@@ -162,7 +162,10 @@ class AppleMusicController: MediaControllerProtocol {
         }
 
         updatedState.lastUpdated = Date()
-        self.playbackState = updatedState
+        let finalState = updatedState
+        await MainActor.run { [weak self] in
+            self?.playbackState = finalState
+        }
     }
 
     // MARK: - Private Methods