🔖 1.2.0 [ci skip]

Author: fonok3

Sources/GMMapUtility/Camera/CameraConfiguration.swift

@@ -1,21 +1,23 @@
 import Foundation
 
 public struct CameraConfiguration {
+    // MARK: Nested Types
+
     public enum Perspective: Int, CaseIterable, Codable {
         case threeDimensional
         case twoDimensional
         case twoDimensionalNorth
     }
 
+    // MARK: Properties
+
+    public let zoomLevelOffset: Double
+    public let perspective: Perspective
+
     // MARK: Lifecycle
 
     public init(zoomLevelOffset: Double = 0, perspective: Perspective = .threeDimensional) {
         self.zoomLevelOffset = zoomLevelOffset
         self.perspective = perspective
     }
-
-    // MARK: Public
-
-    public let zoomLevelOffset: Double
-    public let perspective: Perspective
 }

Sources/GMMapUtility/Camera/StaticCameraConfigurationProvider.swift

@@ -1,13 +1,13 @@
 import Foundation
 
 public final class StaticCameraConfigurationProvider: CameraConfigurationProvider {
+    // MARK: Properties
+
+    public let cameraConfiguration: CameraConfiguration
+
     // MARK: Lifecycle
 
     public init(cameraConfiguration: CameraConfiguration = CameraConfiguration()) {
         self.cameraConfiguration = cameraConfiguration
     }
-
-    // MARK: Public
-
-    public let cameraConfiguration: CameraConfiguration
 }

Sources/GMMapUtility/Layers/Handler/AggregatingMGLStyleLayersHandler.swift

@@ -2,16 +2,11 @@ import Foundation
 import Mapbox
 
 open class AggregatingMGLStyleLayersHandler: MGLStyleLayersHandler {
+    // MARK: Properties
+
     public var layerHandlers: [MGLStyleLayersHandler]
 
-    public init(
-        mapLayerManager: MapboxMapLayerManager?,
-        mapTheme: MapTheme,
-        layerHandlers: [MGLStyleLayersHandler]
-    ) {
-        self.layerHandlers = layerHandlers
-        super.init(mapLayerManager: mapLayerManager, mapTheme: mapTheme)
-    }
+    // MARK: Lifecycle
 
     override open func setup() {
         layerHandlers.forEach { $0.setup() }
@@ -25,6 +20,17 @@ open class AggregatingMGLStyleLayersHandler: MGLStyleLayersHandler {
         layerHandlers.forEach { $0.stopLayerUpdates() }
     }
 
+    public init(
+        mapLayerManager: MapboxMapLayerManager?,
+        mapTheme: MapTheme,
+        layerHandlers: [MGLStyleLayersHandler]
+    ) {
+        self.layerHandlers = layerHandlers
+        super.init(mapLayerManager: mapLayerManager, mapTheme: mapTheme)
+    }
+
+    // MARK: Overridden Functions
+
     override public func updateVisibility(_ visible: Bool) {
         layerHandlers.forEach { $0.updateVisibility(visible) }
     }

Sources/GMMapUtility/Layers/Handler/MapLayerHandler.swift

@@ -2,7 +2,7 @@ import Foundation
 
 /// Handles the updates and styling of objects shown on a map which belong together.
 ///
-/// - note: A `MapLayerHandler` may be self updating to model changes or receive udpates from outside. 
+/// - note: A `MapLayerHandler` may be self updating to model changes or receive udpates from outside.
 /// Often these two purposes are split up.
 public protocol MapLayerHandler {
     var mapTheme: MapTheme { get }
@@ -18,23 +18,28 @@ public protocol MapLayerHandler {
 
     /// Handles Layer visibility.
     ///
-    /// - warning: This controls the visibility from outside, but it is not guranteed that the layer is displayed if `isVisible` is set tu `true`.
+    /// - warning: This controls the visibility from outside, but it is not guaranteed that the layer is displayed if `isVisible` is set tu `true`.
     ///  The `MapLayerHandler` may have inner logic whether the layer should be shown.
     func updateVisibility(_ visible: Bool)
 
     /// This method should be called if the camera tilt of the `MapView` changes in order to update the layer.
     func updateTilt(tilt: Float)
 
+    /// This method is called when a feature on the map is tapped.
     func didTapFeature(identifier: Any?, attributes: [String: Any])
 }
 
 extension MapLayerHandler {
+    // MARK: Lifecycle
+
     public func setup() {}
 
     public func startLayerUpdates() {}
 
     public func stopLayerUpdates() {}
 
+    // MARK: Functions
+
     public func updateVisibility(_: Bool) {}
 
     public func updateTilt(tilt _: Float) {}

Sources/GMMapUtility/MapLibre/Extensions/MGLPolylineFeature+Geodesic.swift

@@ -2,6 +2,14 @@ import Foundation
 import Mapbox
 
 extension MGLPolylineFeature {
+    // MARK: Static Properties
+
+    private static let earthRadiusMeter = 6_371_008.8
+    // swiftlint:disable:next no_magic_numbers
+    private static let metersNorthToLatitude = 180.0 / Double.pi / earthRadiusMeter
+
+    // MARK: Static Functions
+
     public static func geodesicPolyline(
         fromCoordinate src: CLLocationCoordinate2D,
         toCoordinate dst: CLLocationCoordinate2D
@@ -11,9 +19,6 @@ extension MGLPolylineFeature {
         return MGLPolylineFeature(coordinates: coordinates, count: UInt(coordinates.count))
     }
 
-    private static let earthRadiusMeter = 6_371_008.8
-    // swiftlint:disable:next no_magic_numbers
-    private static let metersNorthToLatitude = 180.0 / Double.pi / earthRadiusMeter
     // swiftlint:disable:next no_magic_numbers
     private static func deg2rad(_ number: Double) -> Double { number * .pi / 180 }
 
@@ -23,20 +28,20 @@ extension MGLPolylineFeature {
 
     private static func shiftByCartesian(latitude: Double, longitude: Double, metersNorth: Double, metersEast: Double)
         -> CLLocationCoordinate2D {
-            CLLocationCoordinate2D(
-                latitude: latitude + metersNorth * metersNorthToLatitude,
-                longitude: longitude + metersEast * metersEastToLongitude(latitude: latitude)
-            )
+        CLLocationCoordinate2D(
+            latitude: latitude + metersNorth * metersNorthToLatitude,
+            longitude: longitude + metersEast * metersEastToLongitude(latitude: latitude)
+        )
     }
 
     private static func shiftByCartesian(src: CLLocationCoordinate2D, metersNorth: Double, metersEast: Double)
         -> CLLocationCoordinate2D {
-            shiftByCartesian(
-                latitude: src.latitude,
-                longitude: src.longitude,
-                metersNorth: metersNorth,
-                metersEast: metersEast
-            )
+        shiftByCartesian(
+            latitude: src.latitude,
+            longitude: src.longitude,
+            metersNorth: metersNorth,
+            metersEast: metersEast
+        )
     }
 
     private static func distanceMetersNorth(src: CLLocationCoordinate2D, dst: CLLocationCoordinate2D) -> Double {
@@ -59,7 +64,7 @@ extension MGLPolylineFeature {
         }
 
         let northMid = 0.5 * northEnd + eastEnd * normalisation // swiftlint:disable:this no_magic_numbers
-        let eastMid = 0.5 * eastEnd - northEnd * normalisation  // swiftlint:disable:this no_magic_numbers
+        let eastMid = 0.5 * eastEnd - northEnd * normalisation // swiftlint:disable:this no_magic_numbers
 
         var positions = [CLLocationCoordinate2D]()
 

Sources/GMMapUtility/MapLibre/Layers/MGLMapViewLifeCycleHandler.swift

@@ -3,14 +3,24 @@ import Mapbox
 import UIKit
 
 public final class MGLMapViewLifeCycleHandler: NSObject {
+    // MARK: Properties
+
+    public weak var mapView: MGLMapView?
+
     private var mapThemeRepository: MapThemeRepository
     private let mapStyleUrlProvider: MGLMapStyleUrlProvider
     private let mapStyleLocalizer: MGLMapStyleLocalizer
     private let mapLayerHandlerBuilder: MapLayerHandlerBuilder
 
-    public weak var mapView: MGLMapView?
-
     private var currentLayersController: MGLStyleLayersHandler?
+    private lazy var mapTapGestureRecognizer: UITapGestureRecognizer = {
+        let recognizer = UITapGestureRecognizer(target: self, action: #selector(didTapMapView(sender:)))
+        recognizer.delegate = self
+        return recognizer
+    }()
+
+    // MARK: Computed Properties
+
     private var layerUpdatesPaused = true {
         didSet {
             if layerUpdatesPaused {
@@ -21,11 +31,7 @@ public final class MGLMapViewLifeCycleHandler: NSObject {
         }
     }
 
-    private lazy var mapTapGestureRecognizer: UITapGestureRecognizer = {
-        let recognizer = UITapGestureRecognizer(target: self, action: #selector(didTapMapView(sender:)))
-        recognizer.delegate = self
-        return recognizer
-    }()
+    // MARK: Lifecycle
 
     public init(
         mapThemeRepository: MapThemeRepository,

Sources/GMMapUtility/MapLibre/Layers/MGLStyleLayersHandler.swift

@@ -2,17 +2,78 @@ import Foundation
 import Mapbox
 
 open class MGLStyleLayersHandler: MapLayerHandler {
+    // MARK: Properties
+
     public private(set) var mapTheme: MapTheme
 
     public private(set) var mapLayerManager: MapboxMapLayerManager?
 
+    // MARK: Computed Properties
+
     open var interactionLayerIdentifiers: Set<String> { Set<String>([]) }
 
+    private var isVisible = true {
+        didSet {
+            guard isVisible != oldValue else {
+                return
+            }
+            refreshLayerVisibility(isVisible: isVisible)
+        }
+    }
+
+    private var tilt: Float = 0 {
+        didSet {
+            guard tilt != oldValue else {
+                return
+            }
+            updateTilt(tilt: tilt)
+        }
+    }
+
+    // MARK: Lifecycle
+
+    open func setup() {}
+
+    open func startLayerUpdates() {
+        updateTilt(tilt: tilt)
+        updateVisibility(isVisible: isVisible)
+    }
+
+    open func stopLayerUpdates() {}
+
     public init(mapLayerManager: MapboxMapLayerManager?, mapTheme: MapTheme) {
         self.mapLayerManager = mapLayerManager
         self.mapTheme = mapTheme
     }
 
+    // MARK: Functions
+
+    /// This method is called when layer should be updated due to visibility change.
+    ///
+    /// This method should be overwritten by subclasses.
+    open func refreshLayerVisibility(isVisible _: Bool) {}
+
+    /// This method is called when layer should be updated due to camera tilt change.
+    ///
+    /// This method should be overwritten by subclasses.
+    open func refreshLayerTilt(tilt _: Float) {}
+
+    open func didTapFeature(identifier _: Any?, attributes _: [String: Any]) {}
+
+    /// This method should be called from outside to update the visibility of the layer.
+    ///
+    /// If the handler is currently inactive the value will be stored and applied when the handler is started.
+    public func updateVisibility(isVisible: Bool) {
+        self.isVisible = isVisible
+    }
+
+    /// This method should be called from outside to update the camera tilt of the layer.
+    ///
+    /// If the handler is currently inactive the value will be stored and applied when the handler is started.
+    public func updateTilt(tilt: Float) {
+        self.tilt = tilt
+    }
+
     // MARK: - User Interaction
 
     func didTapLayer(at location: CGPoint, in mapView: MGLMapView) {
@@ -22,16 +83,4 @@ open class MGLStyleLayersHandler: MapLayerHandler {
         )
         features.first.map { didTapFeature(identifier: $0.identifier, attributes: $0.attributes) }
     }
-
-    open func setup() {}
-
-    open func startLayerUpdates() {}
-
-    open func stopLayerUpdates() {}
-
-    open func updateVisibility(_: Bool) {}
-
-    open func updateTilt(tilt _: Float) {}
-
-    open func didTapFeature(identifier _: Any?, attributes _: [String: Any]) {}
 }