SwiftUI macOs AppDelegate detect the change of ObservedObject

Question

I have the following AppDelegate class, I want to determine when userPreferences.backgroundIsTransparent changes state, must call a function inside AppDelegate.

I took a look here: https://stackoverflow.com/a/58431723/8024296

But I'm failing to figure out how I can use it in my case.

How can I do?

AppDelegate:

import Cocoa
import SwiftUI

@main
class AppDelegate: NSObject, NSApplicationDelegate {
    var popover = NSPopover.init()
    var statusBar: StatusBarController?
    @Environment(\.colorScheme) var colorScheme
    
    @ObservedObject var userPreferences = UserPreferences.instance
    
    func applicationDidFinishLaunching(_ aNotification: Notification) {
        let contentView = ContentView()
        popover.contentSize = NSSize(width: 560, height: 360)
        popover.contentViewController = NSHostingController(rootView: contentView)
        statusBar = StatusBarController.init(popover)
        DistributedNotificationCenter.default.addObserver(self, selector: #selector(interfaceModeChanged(sender:)), name: NSNotification.Name(rawValue: "AppleInterfaceThemeChangedNotification"), object: nil)
    }
    
    func applicationWillTerminate(_ aNotification: Notification) {
        // Insert code here to tear down your application
    }
    
    @objc func interfaceModeChanged(sender: NSNotification) {
        //popover.backgroundColor = colorScheme == .dark ? #colorLiteral(red: 0.3411764801, green: 0.6235294342, blue: 0.1686274558, alpha: 1) : #colorLiteral(red: 0.2392156869, green: 0.6745098233, blue: 0.9686274529, alpha: 1)
        popover.backgroundColor = NSColor(named: "backgroundTheme")?.withAlphaComponent(userPreferences.backgroundIsTransparent ? 0.3 : 1.0)
        print("change", colorScheme)
    }
}

import EventKit
import ServiceManagement

private struct PreferencesKeys {
    static let backgroundIsTransparent = "backgroundIsTransparent"
    static let isDarkMode = "isDarkMode"
}

class UserPreferences: ObservableObject {
    static let instance = UserPreferences()
    
    private init() {
        // This prevents others from using the default '()' initializer for this class.
    }
    
    private static let defaults = UserDefaults.standard
    
    @Published var backgroundIsTransparent: Bool = {
        guard UserDefaults.standard.object(forKey: PreferencesKeys.backgroundIsTransparent) != nil else {
            return true
        }
        return UserDefaults.standard.bool(forKey: PreferencesKeys.backgroundIsTransparent)
    }() {
        didSet {
            UserPreferences.defaults.set(backgroundIsTransparent, forKey: PreferencesKeys.backgroundIsTransparent)
        }
    }
    
    @Published var isDarkMode: Bool = {
        guard UserDefaults.standard.object(forKey: PreferencesKeys.isDarkMode) != nil else {
            return true
        }
        return UserDefaults.standard.bool(forKey: PreferencesKeys.isDarkMode)
    }() {
        didSet {
            UserPreferences.defaults.set(isDarkMode, forKey: PreferencesKeys.isDarkMode)
        }
    }
    
}

Answer 1

There is a more sophisticated way to observe UserDefaults.

The Combine framework provides a publisher for UserDefaults, which is actually a Key-Value Observing Publisher

First make your backgroundIsTransparent property an extension of UserDefaults

extension UserDefaults {
    @objc var backgroundIsTransparent: Bool {
        get {
            guard object(forKey: PreferencesKeys.backgroundIsTransparent) != nil else { return true }
            return bool(forKey: PreferencesKeys.backgroundIsTransparent)
        }
        set {
            set(newValue, forKey: PreferencesKeys.backgroundIsTransparent)
        }
    }
}

In AppDelegate import Combine and create a Set for the subscription(s)

import Combine

@main
class AppDelegate: NSObject, NSApplicationDelegate { ...

    private var subscriptions = Set<AnyCancellable>()

and in applicationDidFinishLaunching add the publisher

    func applicationDidFinishLaunching(_ aNotification: Notification) {

    // .....

        UserDefaults.standard.publisher(for: \.backgroundIsTransparent)
            .sink { state in
                print(state)
                // do something with state
            }
            .store(in: &subscriptions)
    }

---

An alternative using your approach is to make userPreferences a @StateObject

@StateObject var userPreferences = UserPreferences.instance

and observe backgroundIsTransparent

userPreferences.$backgroundIsTransparent
.sink { state in
   print(state)
   // do something with state
}
.store(in: &subscriptions)