27 · 옵저버 — NotificationCenter·KVO·Observation

import Foundation

let center = NotificationCenter.default
let name = Notification.Name("test.sync")

center.addObserver(forName: name, object: nil, queue: nil) { _ in
    print("  옵저버 시작 — thread:", Thread.current, "isMain:", Thread.isMainThread)
    Thread.sleep(forTimeInterval: 0.5)
    print("  옵저버 종료 (0.5초 대기 후)")
}

let t0 = Date()
print("post() 호출 직전:", Thread.current)
center.post(name: name, object: nil)
let elapsed = Date().timeIntervalSince(t0)
print("post() 반환 — 경과 시간: \(elapsed)초")

// 실제 실행 결과:
// post() 호출 직전: <_NSMainThread: ...>{number = 1, name = main}
//   옵저버 시작 — thread: <_NSMainThread: ...> isMain: true
//   옵저버 종료 (0.5초 대기 후)
// post() 반환 — 경과 시간: 0.5048890113830566초

// ❌ 옵저버가 곧 게시자의 실행 시간이 된다
NotificationCenter.default.addObserver(forName: .dataDidUpdate, object: nil, queue: nil) { note in
    let parsed = expensiveDecode(note.userInfo)   // 이 시간만큼 post() 호출자가 멈춘다
    render(parsed)
}

// ✅ 받는 즉시 별도 큐로 넘겨 게시자를 붙잡지 않는다
NotificationCenter.default.addObserver(forName: .dataDidUpdate, object: nil, queue: nil) { note in
    let payload = note.userInfo
    Task.detached(priority: .userInitiated) {
        let parsed = expensiveDecode(payload)
        await MainActor.run { render(parsed) }
    }
}

DispatchQueue.global().async {
    // ... 네트워크 작업 ...
    // ❌ queue: nil로 등록된 UI 옵저버가 있다면 그 옵저버도 백그라운드에서 돈다
    NotificationCenter.default.post(name: .downloadFinished, object: nil)
}

// 옵저버 등록 시점에 명시적으로 메인 큐를 지정해두면 안전하다
NotificationCenter.default.addObserver(forName: .downloadFinished, object: nil, queue: .main) { _ in
    imageView.image = downloadedImage   // 항상 메인 큐에서 실행됨이 보장된다
}

import Foundation

let name = Notification.Name("widget.tick")

final class Widget {
    init() {
        // 토큰을 버림 + self를 암묵적으로 강하게 캡처 — 흔한 실수
        _ = NotificationCenter.default.addObserver(forName: name, object: nil, queue: nil) { _ in
            self.report()
        }
    }
    func report() { print("  Widget 콜백 실행 — 아직 살아있다는 뜻") }
    deinit { print("  Widget deinit 호출됨") }
}

var w: Widget? = Widget()
w = nil                       // 우리 쪽 강한 참조는 끊었다
print("w = nil 완료")
NotificationCenter.default.post(name: name, object: nil)
print("post 완료")

// 실제 실행 결과:
// w = nil 완료
//   Widget 콜백 실행 — 아직 살아있다는 뜻     ← deinit 로그가 안 찍혔다
// post 완료

import Foundation

final class Event {}

struct EventDidStart: NotificationCenter.MainActorMessage {
    typealias Subject = Event
    let startedAt: Date
}

let event = Event()

Task { @MainActor in
    let token = NotificationCenter.default.addObserver(of: event, for: EventDidStart.self) { message in
        print("타입 메시지 수신 — startedAt:", message.startedAt)
    }
    NotificationCenter.default.post(EventDidStart(startedAt: Date()), subject: event)
    _ = token
}
// 실제 출력: 타입 메시지 수신 — startedAt: 2026-07-27 09:22:30 +0000

final class ProfileViewModel {
    private var token: NSObjectProtocol?

    init() {
        token = NotificationCenter.default.addObserver(
            forName: .userDidUpdateProfile, object: nil, queue: .main
        ) { [weak self] note in
            self?.reload()   // weak self — 순환 참조 자체를 만들지 않는다
        }
    }
    func reload() { /* ... */ }

    deinit {
        if let token { NotificationCenter.default.removeObserver(token) }
    }
}

@available(iOS 26, macOS 26, *)
struct ProfileDidUpdate: NotificationCenter.MainActorMessage {
    typealias Subject = ProfileStore
    let newName: String   // userInfo["name"] as? String 같은 캐스팅이 필요 없다
}

@available(iOS 26, macOS 26, *)
final class ProfileObserverExample {
    var token: NotificationCenter.ObservationToken?

    @MainActor func start(store: ProfileStore) {
        // 토큰을 프로퍼티에 저장하면 이 인스턴스가 살아있는 동안만 관찰,
        // 저장 안 해도 반환값이 즉시 해제되며 자동으로 등록도 풀린다
        token = NotificationCenter.default.addObserver(of: store, for: ProfileDidUpdate.self) { message in
            print("새 이름:", message.newName)
        }
    }
}

import Foundation

@objc(Dog) class Dog: NSObject {
    @objc dynamic var name: String = "초코"
}

let dog = Dog()
print("관찰 전:", String(cString: class_getName(object_getClass(dog)!)))

let token = dog.observe(\.name, options: [.old, .new]) { _, change in
    print("  변경 감지:", change.oldValue ?? "", "->", change.newValue ?? "")
}

print("관찰 후:", String(cString: class_getName(object_getClass(dog)!)))
print("type(of:) 는 여전히:", type(of: dog))   // 스위즐된 클래스가 class 메서드를 오버라이드해 원래 타입인 척한다

dog.name = "바둑이"
_ = token

// 실제 실행 결과:
// 관찰 전: Dog
// 관찰 후: NSKVONotifying_Dog
// type(of:) 는 여전히: Dog
//   변경 감지: 초코 -> 바둑이

@objc(Dog) final class Dog: NSObject {   // final이어도 문제없다
    @objc dynamic var name: String = "초코"
    @objc dynamic var age: Int = 1
}

let dog1 = Dog(), dog2 = Dog()
let t1 = dog1.observe(\.name) { _, _ in }
let t2 = dog2.observe(\.age) { _, _ in }   // 다른 인스턴스, 다른 프로퍼티

print(object_getClass(dog1)! == object_getClass(dog2)!)  // true — 클래스당 서브클래스 1개
_ = (t1, t2)

// ✅ 프레임워크의 KVO 지점(예: Operation의 진행 상태)을 관찰할 때만 필요
final class ProgressObserver: NSObject {
    private var token: NSKeyValueObservation?

    func track(_ operation: Operation) {
        token = operation.observe(\.isFinished, options: [.new]) { op, change in
            guard change.newValue == true else { return }
            print("작업 완료:", op)
        }
    }
}

// ❌ 순수 데이터 모델에 KVO 대응을 위해 NSObject를 상속시킬 필요는 없다
// struct/순수 class + Combine 또는 @Observable로 충분하다

final class PlayerState: NSObject {
    @objc dynamic var score: Int = 0          // KVO로 UI가 관찰 — 동적 디스패치 필요
    var internalTickCount: Int = 0            // 아무도 관찰 안 함 — 정적 디스패치로 충분
}

import Foundation

@objc(Dog) class Dog: NSObject { @objc dynamic var name: String = "초코" }

final class Owner {
    var token: NSKeyValueObservation?
    init(observing dog: Dog) {
        token = dog.observe(\.name, options: [.new]) { _, change in
            print("  Owner가 감지:", change.newValue ?? "")
        }
    }
    deinit { print("Owner deinit — token도 곧 해제된다") }
}

let dog = Dog()
var owner: Owner? = Owner(observing: dog)
dog.name = "1차 변경"          // Owner가 살아있음 — 감지됨

owner = nil                    // Owner 해제 -> token deinit -> invalidate() 자동 호출
print("owner를 nil로 만든 뒤:")
dog.name = "2차 변경"          // 관찰 끊김 — 아무것도 출력되지 않아야 정상
print("끝 — 크래시 없음, 추가 감지 로그도 없음")

// 실제 실행 결과:
//   Owner가 감지: 1차 변경
// Owner deinit — token도 곧 해제된다
// owner를 nil로 만든 뒤:
// 끝 — 크래시 없음, 추가 감지 로그도 없음   ← "2차 변경"에 대한 감지 로그가 없다

private var kvoContext = 0

final class LegacyObserver: NSObject {
    weak var dog: Dog?

    func start(observing dog: Dog) {
        self.dog = dog
        dog.addObserver(self, forKeyPath: "name", options: [.new], context: &kvoContext)
    }

    override func observeValue(forKeyPath keyPath: String?, of object: Any?,
                                change: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
        guard context == &kvoContext else {
            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
            return
        }
        print("이름 변경 감지")
    }

    deinit {
        dog?.removeObserver(self, forKeyPath: "name", context: &kvoContext)   // 짝을 반드시 맞춘다
    }
}

final class DogMonitor {
    private var tokens: [NSKeyValueObservation] = []

    func start(observing dog: Dog) {
        tokens.append(dog.observe(\.name, options: [.new]) { _, c in print("이름:", c.newValue ?? "") })
        tokens.append(dog.observe(\.age,  options: [.new]) { _, c in print("나이:", c.newValue ?? "") })
        // deinit에서 tokens 배열이 해제되면 모든 관찰이 자동으로 끊긴다 — 별도 정리 코드 불필요
    }
}

// 원본:
// @Observable
// final class Counter {
//     var count: Int = 0
// }

// 매크로가 생성한 코드(발췌, 실제 확장 결과):
@ObservationIgnored private let _$observationRegistrar = Observation.ObservationRegistrar()

@ObservationIgnored private var _count: Int = 0

var count: Int {
    get {
        access(keyPath: \.count)          // "지금 count를 읽었다"고 등록
        return _count
    }
    set {
        guard shouldNotifyObservers(_count, newValue) else {
            _count = newValue             // 값이 실제로 같으면 알리지 않고 그냥 대입
            return
        }
        withMutation(keyPath: \.count) {  // 값이 실제로 다를 때만 관찰자에게 통지
            _count = newValue
        }
    }
}

// @Observable — withObservationTracking으로 직접 관찰
import Observation
@Observable final class Counter { var count: Int = 0 }
let c = Counter()
var changeCount = 0
func track() {
    withObservationTracking { _ = c.count } onChange: {
        changeCount += 1
        track()   // SwiftUI가 매 렌더마다 재구독하는 것과 동일한 패턴
    }
}
track()
c.count = 0   // 같은 값
c.count = 5   // 다른 값
print(changeCount)   // 실제 결과: 1 — 같은 값 대입은 통지되지 않았다

// ObservableObject — objectWillChange를 직접 구독
import Combine
final class LegacyCounter: ObservableObject { @Published var count: Int = 0 }
let lc = LegacyCounter()
var fireCount = 0
let sub = lc.objectWillChange.sink { _ in fireCount += 1 }
lc.count = 0   // 같은 값
lc.count = 5   // 다른 값
print(fireCount)   // 실제 결과: 2 — 같은 값이어도 무조건 발동했다

// ❌ 이전 — count 하나만 바뀌어도 label을 읽는 뷰까지 전부 재평가
final class OldViewModel: ObservableObject {
    @Published var count: Int = 0
    @Published var label: String = "카운터"
}
struct OldView: View {
    @StateObject var vm = OldViewModel()
    var body: some View { Text(vm.label) }   // count 변경에도 계속 재평가된다
}

// ✅ 이후 — body가 실제로 읽는 프로퍼티가 바뀔 때만 재평가
@Observable
final class NewViewModel {
    var count: Int = 0
    var label: String = "카운터"
}
struct NewView: View {
    @State var vm = NewViewModel()
    var body: some View { Text(vm.label) }   // count가 바뀌어도 이 뷰는 재평가되지 않는다
}

@Observable
final class SearchViewModel {
    var query: String = ""             // 뷰가 읽음 — 추적 대상
    var results: [Item] = []           // 뷰가 읽음 — 추적 대상

    @ObservationIgnored
    private var debounceWorkItem: DispatchWorkItem?   // 뷰와 무관한 내부 상태 — 추적 제외
}