Unify rotatation code to use a single animation function

Author: bryceco

src/Shared/DisplayLink.swift

@@ -16,7 +16,6 @@ final class DisplayLink {
 		case rotateScreenSmoothing // smoothly rotates the screen when compass is enabled/disabled
 		case automatedFramerateTest // automatically pans the screen during FPS test
 		case fpsLabelUpdate // updates the FPS test label
-		case compassSmoothHeading // smooths compass heading to reduce jitter
 		case pinDragScroll // pans the screen when pushpin is dragged to edge
 		case screenPanningInertia // applies inertia after user pan gesture ends
 	}

src/Shared/LocationProvider.swift

@@ -24,22 +24,20 @@ final class LocationProvider: NSObject, CLLocationManagerDelegate {
 		}
 	}
 
-	private(set) var currentHeading: CLHeading? {
+	struct Heading {
+		var heading: Double // radians, north up
+		var accuracy: Double // radians
+	}
+
+	private(set) var currentHeading: Heading? {
 		didSet {
 			if let currentHeading {
 				onChangeHeading.notify(currentHeading)
 			}
 		}
 	}
 
-	private(set) var smoothHeading = 0.0 {
-		didSet {
-			onChangeSmoothHeading.notify((smoothHeading, currentHeading?.headingAccuracy ?? 0.0))
-		}
-	}
-
-	let onChangeHeading = NotificationService<CLHeading>()
-	let onChangeSmoothHeading = NotificationService<(heading: Double, accuracy: Double)>()
+	let onChangeHeading = NotificationService<Heading>()
 	let onChangeLocation = NotificationService<CLLocation>()
 
 	var allowsBackgroundLocationUpdates: Bool {
@@ -144,7 +142,7 @@ final class LocationProvider: NSObject, CLLocationManagerDelegate {
 		self.currentLocation = newLocation
 	}
 
-	static func headingAdjustedForInterfaceOrientation(_ clHeading: CLHeading) -> Double {
+	private static func headingAdjustedForInterfaceOrientation(_ clHeading: CLHeading) -> Double {
 		var heading = clHeading.trueHeading * .pi / 180
 		if let scene = UIApplication.shared.connectedScenes.compactMap({ $0 as? UIWindowScene }).first {
 			switch scene.interfaceOrientation {
@@ -166,30 +164,8 @@ final class LocationProvider: NSObject, CLLocationManagerDelegate {
 	// MARK: CLLocationManagerDelegate
 
 	func locationManager(_ manager: CLLocationManager, didUpdateHeading newHeading: CLHeading) {
-		let heading = Self.headingAdjustedForInterfaceOrientation(newHeading)
-
-		self.currentHeading = newHeading
-
-		if DisplayLink.shared.has(.rotateScreenSmoothing) {
-			return
-		}
-		DisplayLink.shared.add(.compassSmoothHeading, block: { [self] in
-			var delta = heading - self.smoothHeading
-			if delta > .pi {
-				delta -= 2 * .pi
-			} else if delta < -.pi {
-				delta += 2 * .pi
-			}
-			delta *= 0.15
-			if abs(delta) < 0.0001 {
-				self.smoothHeading = heading
-			} else {
-				self.smoothHeading += delta
-			}
-			if heading == self.smoothHeading {
-				DisplayLink.shared.remove(.compassSmoothHeading)
-			}
-		})
+		self.currentHeading = Heading(heading: Self.headingAdjustedForInterfaceOrientation(newHeading),
+		                              accuracy: newHeading.headingAccuracy * .pi / 180)
 	}
 
 	func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {

src/iOS/CustomViews/LocationBallView.swift

@@ -44,21 +44,7 @@ final class LocationBallView: UIView, MapPositionedView {
 			viewPort.mapTransform.onChange.subscribe(self) { [weak self] in
 				guard let self else { return }
 				self.updateScreenPosition()
-
-				guard !isHidden else { return }
-				let screenAngle = viewPort.mapTransform.rotation()
-				let mainView = AppDelegate.shared.mainView!
-				if mainView.gpsState == .HEADING,
-				   abs(heading - -.pi / 2) < 0.001
-				{
-					// don't pin location ball to North until we've animated our rotation to north
-					heading = -.pi / 2
-				} else {
-					if let heading = LocationProvider.shared.currentHeading {
-						let heading = LocationProvider.headingAdjustedForInterfaceOrientation(heading)
-						self.heading = CGFloat(screenAngle + heading - .pi / 2)
-					}
-				}
+				setNeedsLayout()
 			}
 		}
 	}
@@ -179,6 +165,9 @@ final class LocationBallView: UIView, MapPositionedView {
 		super.layoutSubviews()
 
 		if showHeading, headingAccuracy > 0 {
+			let screenAngle = viewPort?.mapTransform.rotation() ?? 0.0
+			let heading = CGFloat(screenAngle + heading - .pi / 2)
+
 			// draw heading
 			let shapeLayer = headingLayer.mask as! CAShapeLayer
 			let radius = shapeLayer.bounds.width / 2

src/iOS/MainViewController.swift

@@ -332,8 +332,9 @@ final class MainViewController: UIViewController, DPadDelegate,
 			self?.locationBallView.updateGpsLocation(location)
 		}
 
-		LocationProvider.shared.onChangeSmoothHeading.subscribe(self) { [weak self] heading, accuracy in
-			self?.headingChanged(heading, accuracy: accuracy)
+		LocationProvider.shared.onChangeHeading.subscribe(self) { [weak self] heading in
+			self?.headingChanged(heading.heading,
+			                     accuracy: heading.accuracy)
 		}
 
 		settings.$enableRotation.subscribe(self) { [weak self] newValue in
@@ -342,7 +343,9 @@ final class MainViewController: UIViewController, DPadDelegate,
 				// remove rotation
 				let centerPoint = viewPort.screenCenterPoint()
 				let angle = CGFloat(viewPort.mapTransform.rotation())
-				viewPort.animateRotation(by: -angle, aroundPoint: centerPoint)
+				viewPort.rotate(by: -angle,
+				                around: centerPoint,
+				                animation: .largeShift)
 			}
 		}
 
@@ -960,7 +963,9 @@ final class MainViewController: UIViewController, DPadDelegate,
 			let centerPoint = rotationGesture.location(in: mapView)
 #endif
 			let angle = rotationGesture.rotation
-			viewPort.rotate(by: angle, aroundScreenPoint: centerPoint)
+			viewPort.rotate(by: angle,
+			                around: centerPoint,
+			                animation: .none)
 			rotationGesture.rotation = 0.0
 
 			if gpsState == .HEADING {
@@ -1103,20 +1108,27 @@ final class MainViewController: UIViewController, DPadDelegate,
 		}
 	}
 
+	/// Called when GPS indicates a new heading. Updates location ball or screen rotation.
+	/// - Parameters:
+	///   - heading: The user's current heading, in radians, measured clockwise from true north.
+	///   - accuracy: The estimated heading accuracy, in radians. Larger values indicate less
+	///     certainty; passed through to the location ball for visual display.
 	func headingChanged(_ heading: Double, accuracy: Double) {
 		let screenAngle = viewPort.mapTransform.rotation()
 
 		if gpsState == .HEADING {
-			// rotate to new heading
+			// rotate view to new heading
 			let center = viewPort.screenCenterPoint()
 			let delta = -(heading + screenAngle)
-			viewPort.rotate(by: CGFloat(delta), aroundScreenPoint: center)
-		} else {
-			// rotate location ball
-			locationBallView.headingAccuracy = CGFloat(accuracy * (.pi / 180))
-			locationBallView.showHeading = true
-			locationBallView.heading = CGFloat(heading + screenAngle - .pi / 2)
+			viewPort.rotate(by: delta,
+			                around: center,
+			                animation: .smallShift)
 		}
+
+		// update location ball
+		locationBallView.headingAccuracy = CGFloat(accuracy)
+		locationBallView.heading = heading
+		locationBallView.showHeading = true
 	}
 
 	/// Called to indicate that GPS has provided us with an update to our location.
@@ -1149,6 +1161,8 @@ final class MainViewController: UIViewController, DPadDelegate,
 			                  zoom: nil,
 			                  rotation: nil)
 		}
+
+		locationBallView.updateLocation(LatLon(newLocation.coordinate))
 	}
 
 	func moveToLocation(_ location: MapLocation) {
@@ -1263,17 +1277,16 @@ final class MainViewController: UIViewController, DPadDelegate,
 
 	@IBAction func compassPressed(_ sender: Any?) {
 		switch gpsState {
+		case .NONE:
+			viewPort.rotateToHeading(0.0)
 		case .HEADING:
 			gpsState = .LOCATION
-			viewPort.rotateToNorth()
+			viewPort.rotateToHeading(0.0)
 		case .LOCATION:
 			gpsState = .HEADING
-			if let clHeading = LocationProvider.shared.currentHeading {
-				let heading = LocationProvider.headingAdjustedForInterfaceOrientation(clHeading)
+			if let heading = LocationProvider.shared.currentHeading?.heading {
 				viewPort.rotateToHeading(heading)
 			}
-		case .NONE:
-			viewPort.rotateToNorth()
 		}
 	}
 

src/iOS/MapViewPort.swift

@@ -9,6 +9,8 @@
 import CoreLocation
 import UIKit
 
+enum ViewPortRotationStyle { case none, smallShift, largeShift }
+
 // Allows other layers of the map to view changes to the map view
 protocol MapViewPort: AnyObject {
 	var mapTransform: MapTransform { get }
@@ -97,22 +99,24 @@ extension MapViewPort {
 		mapTransform.transform = t
 	}
 
-	func rotate(by angle: CGFloat, aroundScreenPoint zoomCenter: CGPoint) {
+	private func rotate(by angle: CGFloat, around center: CGPoint) {
 		guard angle != 0.0 else {
 			return
 		}
-
-		let offset = mapTransform.mapPoint(forScreenPoint: OSMPoint(zoomCenter), birdsEye: false)
+		let offset = mapTransform.mapPoint(forScreenPoint: OSMPoint(center), birdsEye: false)
 		var t = mapTransform.transform
 		t = t.translatedBy(dx: offset.x, dy: offset.y)
 		t = t.rotatedBy(Double(angle))
 		t = t.translatedBy(dx: -offset.x, dy: -offset.y)
 		mapTransform.transform = t
 	}
 
-	func animateRotation(by deltaHeading: Double, aroundPoint center: CGPoint) {
-		var deltaHeading = deltaHeading
+	func rotate(by deltaHeading: Double,
+	            around center: CGPoint,
+	            animation: ViewPortRotationStyle)
+	{
 		// don't rotate the long way around
+		var deltaHeading = deltaHeading
 		while deltaHeading < -.pi {
 			deltaHeading += 2 * .pi
 		}
@@ -124,20 +128,25 @@ extension MapViewPort {
 			return
 		}
 
-		let startTime = CACurrentMediaTime()
-
-		let duration = 0.4
-		var prevHeading: Double = 0
-		DisplayLink.shared.remove(.compassSmoothHeading)
-		DisplayLink.shared.add(.rotateScreenSmoothing, block: { [weak self] in
-			guard let self else { return }
+		switch animation {
+		case .none:
+			self.rotate(by: deltaHeading, around: center)
+
+		case .smallShift:
+			var currentDelta = 0.0
+			DisplayLink.shared.add(.rotateScreenSmoothing, block: { [weak self] in
+				guard let self else { return }
+				var delta = deltaHeading - currentDelta
+				if abs(delta) < 0.0001 {
+					DisplayLink.shared.remove(.rotateScreenSmoothing)
+				} else {
+					delta *= 0.15
+				}
+				currentDelta += delta
+				self.rotate(by: delta, around: center)
+			})
 
-			var elapsedTime = CACurrentMediaTime() - startTime
-			if elapsedTime > duration {
-				elapsedTime = CFTimeInterval(duration) // don't want to over-rotate
-			}
-			// Rotate using an ease-in/out curve. This ensures that small changes in direction don't cause jerkiness.
-			// result = interpolated value, t = current time, b = initial value, c = delta value, d = duration
+		case .largeShift:
 			func easeInOutQuad(_ t: Double, _ b: Double, _ c: Double, _ d: Double) -> Double {
 				var t = t
 				t /= d / 2
@@ -147,13 +156,27 @@ extension MapViewPort {
 				t -= 1
 				return -c / 2 * (t * (t - 2) - 1) + b
 			}
-			let miniHeading = easeInOutQuad(elapsedTime, 0, deltaHeading, duration)
-			self.rotate(by: CGFloat(miniHeading - prevHeading), aroundScreenPoint: center)
-			prevHeading = miniHeading
-			if elapsedTime >= duration {
-				DisplayLink.shared.remove(.rotateScreenSmoothing)
-			}
-		})
+
+			let duration = 0.4
+			var prevHeading: Double = 0
+			let startTime = CACurrentMediaTime()
+			DisplayLink.shared.add(.rotateScreenSmoothing, block: { [weak self] in
+				guard let self else { return }
+
+				var elapsedTime = CACurrentMediaTime() - startTime
+				if elapsedTime > duration {
+					elapsedTime = CFTimeInterval(duration) // don't want to over-rotate
+				}
+				// Rotate using an ease-in/out curve. This ensures that small changes in direction don't cause jerkiness.
+				// result = interpolated value, t = current time, b = initial value, c = delta value, d = duration
+				let miniHeading = easeInOutQuad(elapsedTime, 0, deltaHeading, duration)
+				self.rotate(by: CGFloat(miniHeading - prevHeading), around: center)
+				prevHeading = miniHeading
+				if elapsedTime >= duration {
+					DisplayLink.shared.remove(.rotateScreenSmoothing)
+				}
+			})
+		}
 	}
 
 	func rotateBirdsEye(by angle: Double) {
@@ -190,11 +213,9 @@ extension MapViewPort {
 		// Rotate to face current compass heading
 		let center = screenCenterPoint()
 		let screenAngle = mapTransform.rotation()
-		animateRotation(by: -(screenAngle + heading), aroundPoint: center)
-	}
-
-	func rotateToNorth() {
-		rotateToHeading(0.0)
+		rotate(by: -(screenAngle + heading),
+		       around: center,
+		       animation: .largeShift)
 	}
 }