如何让两个UIViewRepresentable共享底层UIKit视图/控制器协作？

UIViewRepresentable可用于将UIKit视图引入SwiftUI环境，但它有个核心限制：UIKit侧的实例化不由我们控制，而是由SwiftUI子系统按需创建。

当两个UIView需要互相感知协作时，这会带来明显麻烦。比如MKMapView和MKCompassButton，后者必须依赖前者的实例才能同步显示。由于无法直接获取对方的控制器或视图实例，在独立的UIViewRepresentable实例之间传递这类引用非常困难。

示例代码：

struct MapView: UIViewRepresentable {
    func makeUIView(context: Context) -> MKMapView { .init() }
}
struct CompassButton: UIViewRepresentable {
    func makeUIView(context: Context) -> MKCompassButton { .init(mapView: ???) }
}
/// 或者嵌套写法
struct MapView: UIViewRepresentable {
    let compass = CompassButton()

    func makeUIView(context: Context) -> MKMapView { .init() }

    struct CompassButton: UIViewRepresentable {
        func makeUIView(context: Context) -> MKCompassButton { .init(mapView: ???) }
    }
}

请问是否存在机制，能让基于UIViewRepresentable的两个SwiftUI视图通过底层UIKit视图协作？比如共享控制器实例或其他方式？

我最初的想法是把控制器实例化从makeController移到UIViewRepresentable中作为属性，但担心这会干扰SwiftUI对控制器的生命周期管理。

可行解决方案 #

1. 用ObservableObject共享UIKit实例 #

创建一个可观察对象持有MKMapView实例，让两个UIViewRepresentable都依赖该对象。当MapView创建好MKMapView后，CompassButton就能自动获取到这个实例：

class MapCoordinator: ObservableObject {
    @Published var mapView: MKMapView?
}

struct MapView: UIViewRepresentable {
    @ObservedObject var coordinator: MapCoordinator

    func makeUIView(context: Context) -> MKMapView {
        let mapView = MKMapView()
        coordinator.mapView = mapView
        return mapView
    }

    func updateUIView(_ uiView: MKMapView, context: Context) {}
}

struct CompassButton: UIViewRepresentable {
    @ObservedObject var coordinator: MapCoordinator

    func makeUIView(context: Context) -> MKCompassButton {
        // 处理mapView未就绪的情况，先创建临时实例
        MKCompassButton(mapView: coordinator.mapView ?? MKMapView())
    }

    func updateUIView(_ uiView: MKCompassButton, context: Context) {
        // mapView就绪后更新按钮关联的地图实例
        if let mapView = coordinator.mapView, uiView.mapView !== mapView {
            uiView.mapView = mapView
        }
    }
}

// 使用示例
struct ContentView: View {
    @StateObject private var mapCoordinator = MapCoordinator()

    var body: some View {
        VStack {
            MapView(coordinator: mapCoordinator)
                .frame(height: 300)
            CompassButton(coordinator: mapCoordinator)
        }
    }
}

核心逻辑是通过ObservableObject在两个视图间传递共享实例，利用SwiftUI的状态更新机制，自动在mapView就绪后同步CompassButton。

2. 将关联视图封装到同一个UIViewRepresentable中 #

如果两个UIView本身强关联（比如地图和指南针按钮），直接把它们放到同一个UIViewRepresentable里管理会更简单，彻底避开跨实例传递引用的问题：

struct MapWithCompassView: UIViewRepresentable {
    func makeUIView(context: Context) -> UIView {
        let container = UIView()
        let mapView = MKMapView()
        let compassButton = MKCompassButton(mapView: mapView)
        
        // 设置布局，将指南针按钮固定在地图右上角
        mapView.translatesAutoresizingMaskIntoConstraints = false
        compassButton.translatesAutoresizingMaskIntoConstraints = false
        
        container.addSubview(mapView)
        container.addSubview(compassButton)
        
        NSLayoutConstraint.activate([
            mapView.topAnchor.constraint(equalTo: container.topAnchor),
            mapView.leadingAnchor.constraint(equalTo: container.leadingAnchor),
            mapView.trailingAnchor.constraint(equalTo: container.trailingAnchor),
            mapView.bottomAnchor.constraint(equalTo: container.bottomAnchor),
            
            compassButton.trailingAnchor.constraint(equalTo: mapView.trailingAnchor, constant: -16),
            compassButton.topAnchor.constraint(equalTo: mapView.topAnchor, constant: 16)
        ])
        
        return container
    }

    func updateUIView(_ uiView: UIView, context: Context) {}
}

// 使用示例
struct ContentView: View {
    var body: some View {
        MapWithCompassView()
            .frame(height: 300)
    }
}

这种方式下，两个UIView在同一上下文创建，直接互相引用，生命周期由同一个UIViewRepresentable管理，完全符合UIKit原生协作逻辑。

3. 用PreferenceKey传递UIView引用 #

通过SwiftUI的PreferenceKey机制，在MapView创建后将MKMapView实例传递给父视图，再由父视图传递给CompassButton：

struct MapViewPreferenceKey: PreferenceKey {
    static var defaultValue: MKMapView? = nil
    
    static func reduce(value: inout MKMapView?, nextValue: () -> MKMapView?) {
        value = nextValue() ?? value
    }
}

struct MapView: UIViewRepresentable {
    func makeUIView(context: Context) -> MKMapView {
        MKMapView()
    }

    func updateUIView(_ uiView: MKMapView, context: Context) {
        // 确保视图已加入层级后传递实例
        DispatchQueue.main.async {
            uiView.superview?.setPreference(
                key: MapViewPreferenceKey.self,
                value: uiView
            )
        }
    }
}

struct CompassButton: UIViewRepresentable {
    var mapView: MKMapView?
    
    func makeUIView(context: Context) -> MKCompassButton {
        MKCompassButton(mapView: mapView ?? MKMapView())
    }

    func updateUIView(_ uiView: MKCompassButton, context: Context) {
        if let mapView = mapView, uiView.mapView !== mapView {
            uiView.mapView = mapView
        }
    }
}

// 使用示例
struct ContentView: View {
    @State private var mapView: MKMapView?
    
    var body: some View {
        VStack {
            MapView()
                .frame(height: 300)
                .onPreferenceChange(MapViewPreferenceKey.self) { newMapView in
                    mapView = newMapView
                }
            CompassButton(mapView: mapView)
        }
    }
}

这里用DispatchQueue.main.async确保视图已加入层级，才能正确传递Preference。这种方法适合需要分开布局但又要共享实例的场景。

关于直接存储实例的风险 #

你最初想把控制器/视图实例作为UIViewRepresentable的属性存储，这种做法不推荐：SwiftUI可能会多次创建UIViewRepresentable实例，或在视图更新时重新初始化，导致实例不一致，还会破坏SwiftUI的生命周期管理逻辑，引发内存泄漏或视图状态异常。

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