Swift 缩小时，注释将隐藏

这是我的问题：

当缩小且property showsUserLocation设置为true且注释以用户位置为中心时，集群将在缩小时消失。我不想这样，它们应该总是可见的。displayPriority的默认值设置为required，因此我不确定如何修复此问题每个注释和簇都应该始终可见。当我将属性showsUserLocation设置为false，或者确保注释/簇不在当前位置附近时，它会起作用

有两种方法可以重现我的问题：

克隆并运行

复制粘贴并运行下面的代码

代码

import UIKit
import MapKit

class ViewController: UIViewController, MKMapViewDelegate, CLLocationManagerDelegate {
    let mapView = MKMapView(frame: .zero)

    private let locationManager = CLLocationManager()

    override func viewDidLoad() {
        view.addSubview(mapView)

        mapView.translatesAutoresizingMaskIntoConstraints = false
        mapView.widthAnchor.constraint(equalTo: view.widthAnchor).isActive = true
        mapView.heightAnchor.constraint(equalTo: view.heightAnchor).isActive = true
        mapView.centerYAnchor.constraint(equalTo: view.centerYAnchor).isActive = true
        mapView.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
        mapView.delegate = self

        mapView.showsUserLocation = true
    }

    override func viewDidAppear(_ animated: Bool) {
        let authorizationStatus = CLLocationManager.authorizationStatus()

        switch authorizationStatus {
        case .authorizedWhenInUse, .authorizedAlways:
            break
        case .notDetermined, .restricted, .denied:
            locationManager.requestWhenInUseAuthorization()
        @unknown default:
            fatalError()
        }

        DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(1)) {
            for _ in 0...20 {
                let currentLocation = self.mapView.userLocation.coordinate
                let newLocation = currentLocation.shiftRandomPosition(meters: 30000, randomMeters: true)

                self.mapView.addAnnotation(Annotation(coordinate: newLocation))
            }

            self.mapView.setRegion(MKCoordinateRegion(center: self.mapView.userLocation.coordinate, span: MKCoordinateSpan(latitudeDelta: 0, longitudeDelta: 0)), animated: false)
        }
    }

    func mapView(_ mapView: MKMapView, clusterAnnotationForMemberAnnotations memberAnnotations: [MKAnnotation]) -> MKClusterAnnotation {
        MKClusterAnnotation(memberAnnotations: memberAnnotations)
    }

    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {

    }

    func mapView(_ mapView: MKMapView, viewFor annotation: MKAnnotation) -> MKAnnotationView? {
        guard let annotation = annotation as? Annotation else { return nil }

        let identifier = "marker"
        let view: MKMarkerAnnotationView

        if let dequeuedView = mapView.dequeueReusableAnnotationView(withIdentifier: identifier) as? MKMarkerAnnotationView {
            dequeuedView.annotation = annotation
            view = dequeuedView
        } else {
            view = MKMarkerAnnotationView(annotation: annotation, reuseIdentifier: identifier)
        }

        view.clusteringIdentifier = "identifier"


        return view
    }
}

class Annotation: NSObject, MKAnnotation {
    let coordinate: CLLocationCoordinate2D

    init(coordinate: CLLocationCoordinate2D) {
        self.coordinate = coordinate

        super.init()
    }
}

// https://stackoverflow.com/a/55459722/7715250
extension CLLocationCoordinate2D {
    /// Get coordinate moved from current to `distanceMeters` meters with azimuth `azimuth` [0, Double.pi)
    ///
    /// - Parameters:
    ///   - distanceMeters: the distance in meters
    ///   - azimuth: the azimuth (bearing)
    /// - Returns: new coordinate
    private func shift(byDistance distanceMeters: Double, azimuth: Double) -> CLLocationCoordinate2D {
        let bearing = azimuth
        let origin = self
        let distRadians = distanceMeters / (6372797.6) // earth radius in meters

        let lat1 = origin.latitude * Double.pi / 180
        let lon1 = origin.longitude * Double.pi / 180

        let lat2 = asin(sin(lat1) * cos(distRadians) + cos(lat1) * sin(distRadians) * cos(bearing))
        let lon2 = lon1 + atan2(sin(bearing) * sin(distRadians) * cos(lat1), cos(distRadians) - sin(lat1) * sin(lat2))
        return CLLocationCoordinate2D(latitude: lat2 * 180 / Double.pi, longitude: lon2 * 180 / Double.pi)
    }

    func shiftRandomPosition(meters: Double, randomMeters: Bool) -> CLLocationCoordinate2D {
        let finalMeters: Double

        if randomMeters {
            finalMeters = Double.random(in: -meters..<meters)
        } else {
            finalMeters = meters
        }

        let randomAzimuth = Double.random(in: -Double.pi..<Double.pi)

        return shift(byDistance: finalMeters, azimuth: randomAzimuth)
    }
}

导入UIKit
导入地图套件
类ViewController:UIViewController、MKMapViewDelegate、CLLocationManagerDelegate{
让mapView=MKMapView（帧：.0）
私有let locationManager=CLLocationManager（）
重写func viewDidLoad（）{
view.addSubview（地图视图）
mapView.TranslatesAutoResizezingMaskintoConstraints=false
mapView.widthAnchor.constraint（equalTo:view.widthAnchor）.isActive=true
mapView.heightAnchor.constraint（equalTo:view.heightAnchor）.isActive=true
mapView.centerYAnchor.constraint（equalTo:view.centerYAnchor）.isActive=true
mapView.centerXAnchor.constraint（equalTo:view.centerXAnchor）.isActive=true
mapView.delegate=self
mapView.showsUserLocation=true
}
覆盖函数视图显示（u动画：Bool）{
让authorizationStatus=CLLocationManager.authorizationStatus（）
交换机授权状态{
案例。授权使用。授权方式：
打破
案例.未确定、.限制、.拒绝：
locationManager.RequestWhenUseAuthorization（）
@未知默认值：
法塔莱罗（）
}
DispatchQueue.main.asyncAfter（截止日期：.now（）+秒（1））{
对于0…20中的uu{
让currentLocation=self.mapView.userLocation.coordinate
设newLocation=currentLocation.shiftRandomPosition（仪表：30000，随机仪表：true）
self.mapView.addAnnotation（注释（坐标：newLocation））
}
self.mapView.setRegion（mkcoordinaterRegion（中心：self.mapView.userLocation.coordinate，span:MKCoordinateSpan（latitudeDelta:0，longitudeDelta:0）），动画：false）
}
}
func映射视图（uMapView:MKMapView，ClusterAnnotationFormMemberAnnotations成员注释：[MKAnnotation]）->MKClusterAnnotation{
MKClusterAnnotation（memberAnnotations:memberAnnotations）
}
func locationManager（manager:CLLocationManager，didUpdateLocations位置：[CLLocation]）{
}
func mapView（uMapView:MKMapView，viewFor annotation:MKAnnotation）->MKAnnotationView{
guard let annotation=注释为？注释else{return nil}
让identifier=“marker”
let视图：mkmarkerNotationView
如果让dequeuedView=mapView.dequeueReusableAnnotationView（带标识符：identifier）作为？mkMarkerNotationView{
dequeuedView.annotation=注释
view=dequeuedView
}否则{
view=mkmarkerNotationView（注释：注释，reuseIdentifier:identifier）
}
view.clusteringIdentifier=“标识符”
返回视图
}
}
类注释：NSObject，MKAnnotation{
let坐标：CLLocationCoordinate2D
初始（坐标：CLLocationCoordinate2D）{
self.coordinate=坐标
super.init（）
}
}
// https://stackoverflow.com/a/55459722/7715250
扩展位置坐标2d{
///使用方位角“方位角”[0，Double.pi）将坐标从当前移动到“距离米”
///
///-参数：
///-距离米：以米为单位的距离
///-方位角：方位角（方位角）
///-返回：新坐标
专用功能移位（按距离距离计：双精度，方位角：双精度）->CLLOCATIONCOORDIATE2D{
方位角=方位角
让原点=自我
设distRadians=距离米/（6372797.6）//地球半径（米）
设lat1=origin.latitude*Double.pi/180
设lon1=origin.longitude*Double.pi/180
设lat2=asin（sin（lat1）*cos（distRadians）+cos（lat1）*sin（distRadians）*cos（轴承））
设lon2=lon1+atan2（sin（轴承）*sin（分布盘）*cos（lat1），cos（分布盘）-sin（lat1）*sin（lat2））
返回CLLocationCoordinate2D（纬度：lat2*180/Double.pi，经度：lon2*180/Double.pi）
}
func shiftRandomPosition（仪表：双精度，随机仪表：布尔）->CLLOCATIONCoordinated2D{
让决赛选手：加倍
中频随机数计{
finalMeters=Double.random（in:-meters..YMMV），但是我可以通过显式地将displayPriority设置为.required来解决这个问题。文档说这是默认值，但我在调试时注意到，注释的优先级实际上较低，这会导致它们被用户位置注释阻塞

更新：
这只起了一点作用，但当视图通过出列进行集群和/或重用时，它就会再次停止工作。我尝试在AnnotationView的init（）和prepareForDisplay（）中设置displayPriority，等等。问题仍然出现。在所有情况下，对我有效的是，每次创建或退出显示优先级时都重置显示优先级。如果您将
view.displayPriority=.required
添加到设置
clusteringIdentifier
的代码上方或下方，则在返回视图之前，它应该可以工作。对我有效！您可能还必须为mkclusterAnnotationView主动/显式地重置它。
当前用户的批注没有群集标识符。如果为当前用户的批注提供群集标识符，则它可以工作