macOS中如何检测SwiftUI View是否可见及监听状态变化

你现有的NSView扩展已经覆盖了核心的可见性判断逻辑，稍作优化后可以更简洁，核心逻辑依然可靠。下面是基于这个扩展实现可见性变化监听的适配方案，完美支持SwiftUI场景：

一、增强NSView扩展，添加监听能力 #

扩展NSView，集成KVO和通知监听，捕获所有可能导致可见性变化的场景（hidden状态、透明度、窗口归属、布局变化、父视图变更等）：

import AppKit

public extension NSView {
    var isVisible: Bool {
        guard let window = window, window.isVisible else { return false }
        guard alphaValue > 0 else { return false }
        guard !isHiddenOrHasHiddenAncestor else { return false }
        return !NSIsEmptyRect(visibleRect)
    }
    
    /// 添加可见性变化监听
    /// - Parameter handler: 可见性变化时的回调闭包
    func addVisibilityChangeObserver(handler: @escaping (Bool) -> Void) {
        let context = UnsafeMutableRawPointer(bitPattern: "VisibilityObserver".hashValue)!
        // 关联回调闭包到当前view
        objc_setAssociatedObject(self, context, handler, .OBJC_ASSOCIATION_COPY_NONATOMIC)
        
        // 监听关键属性变化
        addObserver(self, forKeyPath: "hidden", options: [.initial, .new], context: context)
        addObserver(self, forKeyPath: "alphaValue", options: [.initial, .new], context: context)
        addObserver(self, forKeyPath: "window", options: [.initial, .new], context: context)
        addObserver(self, forKeyPath: "bounds", options: [.initial, .new], context: context)
        
        // 监听父视图变更事件
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(onSuperviewChanged),
            name: NSView.didAddSubviewNotification,
            object: nil
        )
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(onSuperviewChanged),
            name: NSView.willRemoveSubviewNotification,
            object: nil
        )
        
        // 触发初始状态回调
        handler(isVisible)
    }
    
    /// 移除可见性变化监听
    func removeVisibilityChangeObserver() {
        let context = UnsafeMutableRawPointer(bitPattern: "VisibilityObserver".hashValue)!
        removeObserver(self, forKeyPath: "hidden", context: context)
        removeObserver(self, forKeyPath: "alphaValue", context: context)
        removeObserver(self, forKeyPath: "window", context: context)
        removeObserver(self, forKeyPath: "bounds", context: context)
        
        NotificationCenter.default.removeObserver(self, name: NSView.didAddSubviewNotification, object: nil)
        NotificationCenter.default.removeObserver(self, name: NSView.willRemoveSubviewNotification, object: nil)
        
        // 清除关联的回调闭包
        objc_setAssociatedObject(self, context, nil, .OBJC_ASSOCIATION_COPY_NONATOMIC)
    }
    
    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        let expectedContext = UnsafeMutableRawPointer(bitPattern: "VisibilityObserver".hashValue)!
        guard context == expectedContext else {
            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
            return
        }
        
        // 触发可见性变化回调
        if let handler = objc_getAssociatedObject(self, context) as? (Bool) -> Void {
            handler(isVisible)
        }
    }
    
    @objc private func onSuperviewChanged() {
        let context = UnsafeMutableRawPointer(bitPattern: "VisibilityObserver".hashValue)!
        if let handler = objc_getAssociatedObject(self, context) as? (Bool) -> Void {
            handler(isVisible)
        }
    }
}

二、SwiftUI桥接：封装成可复用View #

通过NSViewRepresentable将监听逻辑包装成SwiftUI可直接使用的组件，把可见性状态以Binding形式暴露：

import SwiftUI

struct VisibilityTrackingView<Content: View>: NSViewRepresentable {
    private let content: Content
    @Binding var isVisible: Bool
    
    init(isVisible: Binding<Bool>, @ViewBuilder content: () -> Content) {
        self._isVisible = isVisible
        self.content = content()
    }
    
    func makeNSView(context: Context) -> NSHostingView<Content> {
        let hostingView = NSHostingView(rootView: content)
        hostingView.addVisibilityChangeObserver { [weak self] visible in
            DispatchQueue.main.async {
                self?.isVisible = visible
            }
        }
        return hostingView
    }
    
    func updateNSView(_ nsView: NSHostingView<Content>, context: Context) {
        nsView.rootView = content
    }
    
    static func dismantleNSView(_ nsView: NSHostingView<Content>, coordinator: ()) {
        nsView.removeVisibilityChangeObserver()
    }
}

// 使用示例
struct ContentView: View {
    @State private var targetIsVisible = false
    
    var body: some View {
        VStack(spacing: 20) {
            Text("目标视图状态: \(targetIsVisible ? "✅ 可见" : "❌ 不可见")")
                .font(.headline)
            
            VisibilityTrackingView(isVisible: $targetIsVisible) {
                Rectangle()
                    .fill(Color.blue)
                    .frame(width: 200, height: 200)
            }
            
            Button("切换视图可见性") {
                // 可通过修改父容器的opacity/hidden属性测试监听逻辑
            }
        }
        .padding()
        .frame(maxWidth: .infinity, maxHeight: .infinity)
    }
}

关键注意事项 #

• 观察者清理：必须在视图销毁时调用removeVisibilityChangeObserver()，避免内存泄漏，上面的VisibilityTrackingView已通过dismantleNSView自动处理。
• 可见性定义：当前isVisible判断的是「视图有任意部分在屏幕可见区域内」，如果需要判断「视图完全可见」，需额外对比视图全局frame与屏幕frame。
• 主线程更新：KVO回调可能在非主线程触发，更新SwiftUI状态时必须切换到主队列。

内容的提问来源于stack exchange，提问作者ixany