IOS-238: the layer on the radar widget matches the layer in the app.

OneWeatherWidget/Data/WeatherProvider.swift

@@ -47,7 +47,8 @@ class WeatherProvider: TimelineProvider {
                 let coordinates = fetchedLocation.coordinates
                 let coordinates = fetchedLocation.coordinates
             {
             {
                 if self.needsRadar {
                 if self.needsRadar {
-                    SnapshotLoader.load(at: coordinates,
+                    SnapshotLoader.load(for: fetchedLocation,
+                                        at: coordinates,
                                         size: .init(width: 340, height: 280)
                                         size: .init(width: 340, height: 280)
                     ) { mapImage in
                     ) { mapImage in
                         let nextRefresh = Calendar.current.date(byAdding: .minute, value: 30, to: Date())!
                         let nextRefresh = Calendar.current.date(byAdding: .minute, value: 30, to: Date())!

OneWeatherWidget/UI/SnapshotLoader.swift

@@ -9,18 +9,19 @@ import SwiftUI
 import MapKit
 import MapKit
 import Swarm
 import Swarm
 
 
+import OneWeatherCore
+
 private let WDT_APP_ID = "e3b73414"
 private let WDT_APP_ID = "e3b73414"
 private let WDT_APP_KEY = "25e8d6b72de3bcd528f7769b073cc335"
 private let WDT_APP_KEY = "25e8d6b72de3bcd528f7769b073cc335"
 
 
 @available(iOS 14, *)
 @available(iOS 14, *)
 class SnapshotLoader: ObservableObject {
 class SnapshotLoader: ObservableObject {
-    private static let swarmOverlay = SwarmManager.sharedManager.overlayForGroup(.none, baseLayer: .radar)
-    
-    static func load(at coordinates: CLLocationCoordinate2D, size: CGSize, completion:@escaping (_ snapshot:UIImage?) -> Void) {
+    static func load(for location: Location, at coordinates: CLLocationCoordinate2D, size: CGSize, completion:@escaping (_ snapshot:UIImage?) -> Void) {
         SwarmManager.sharedManager.authentication = SkywiseAuthentication (
         SwarmManager.sharedManager.authentication = SkywiseAuthentication (
             app_id: WDT_APP_ID,
             app_id: WDT_APP_ID,
             app_key: WDT_APP_KEY
             app_key: WDT_APP_KEY
         )
         )
+        rebuildLayers(for: location)
         
         
         let region = MKCoordinateRegion(center: coordinates,
         let region = MKCoordinateRegion(center: coordinates,
                                         latitudinalMeters: 30000,
                                         latitudinalMeters: 30000,
@@ -43,6 +44,62 @@ class SnapshotLoader: ObservableObject {
         }
         }
     }
     }
     
     
+    private static var weatherLayers = [RadarLayer]()
+    private static var severeLayers = [RadarLayer]()
+    
+    //Private
+    private static func rebuildLayers(for location: Location) {
+        let pinnedLayerIds = Settings.shared.pinnedLayerIds
+        
+        //Fill weather layers
+        if location.supportsRadar == true {
+            weatherLayers = WeatherLayerType.allCases.map{ RadarLayer(pinned: pinnedLayerIds.contains($0.id), layer: $0) }
+            severeLayers = SevereLayerType.allCases.map{ RadarLayer(pinned: pinnedLayerIds.contains($0.id), layer: $0) }
+        }
+        else {
+            weatherLayers = [RadarLayer(pinned: pinnedLayerIds.contains(WeatherLayerType.clouds.id), layer: WeatherLayerType.clouds),
+                             RadarLayer(pinned: pinnedLayerIds.contains(WeatherLayerType.uvIndex.id), layer: WeatherLayerType.uvIndex)]
+            severeLayers = [RadarLayer(pinned: pinnedLayerIds.contains(SevereLayerType.hurricaneTropicalTracks.id),
+                                       layer: SevereLayerType.hurricaneTropicalTracks)]
+        }
+    }
+    
+    public static var selectedLayer: RadarLayer? {
+        let selectedLayerId = Settings.shared.selectedLayerId
+        
+        if let weatherSelectedLayer = (weatherLayers.first{$0.layer.id == selectedLayerId}) {
+            return weatherSelectedLayer
+        }
+        
+        if let severeSelectedLayer = (severeLayers.first{$0.layer.id == selectedLayerId}) {
+            return severeSelectedLayer
+        }
+        
+        return weatherLayers.first
+    }
+    
+    private static func getOverlay() -> SwarmOverlay? {
+        guard let selectedLayer = self.selectedLayer else {
+            return nil
+        }
+        
+        var rawOverlay:SwarmOverlay?
+        if let weatherLayer = selectedLayer.layer as? WeatherLayerType {
+            rawOverlay = SwarmManager.sharedManager.overlayForBaseLayer(weatherLayer.swarmLayer)
+            // This is needed to use enhanced styles for international radar
+            
+            if weatherLayer.swarmLayer == .satellite {
+                rawOverlay?.style = "enhanced"
+            }
+        }
+        
+        if let severeLayer = selectedLayer.layer as? SevereLayerType {
+            rawOverlay = SwarmManager.sharedManager.overlayForGroup(severeLayer.swarmLayer, baseLayer: .radar)
+        }
+        
+        return rawOverlay
+    }
+    
     private static func addTile(to snapshot: MKMapSnapshotter.Snapshot,
     private static func addTile(to snapshot: MKMapSnapshotter.Snapshot,
                                 region: MKCoordinateRegion,
                                 region: MKCoordinateRegion,
                                 scale: CGFloat,
                                 scale: CGFloat,
@@ -58,8 +115,8 @@ class SnapshotLoader: ObservableObject {
             let b = MKMapPoint(bottomRight)
             let b = MKMapPoint(bottomRight)
             let rect = MKMapRect(origin: MKMapPoint(x:min(a.x,b.x), y:min(a.y,b.y)),
             let rect = MKMapRect(origin: MKMapPoint(x:min(a.x,b.x), y:min(a.y,b.y)),
                                  size: MKMapSize(width: abs(a.x-b.x), height: abs(a.y-b.y)))
                                  size: MKMapSize(width: abs(a.x-b.x), height: abs(a.y-b.y)))
-            
-            let renderer = SwarmTileOverlayRenderer(overlay: SnapshotLoader.swarmOverlay)
+            let overlay: SwarmOverlay = getOverlay() ?? SwarmManager.sharedManager.overlayForGroup(.none, baseLayer: .radar)
+            let renderer = SwarmTileOverlayRenderer(overlay: overlay)
             let zoomLevel = Int(SnapshotLoader.zoomLevel(for: region).rounded(.down))
             let zoomLevel = Int(SnapshotLoader.zoomLevel(for: region).rounded(.down))
             renderer.getTilesImage(rect, zoomLevel: zoomLevel, scale: scale) { image in
             renderer.getTilesImage(rect, zoomLevel: zoomLevel, scale: scale) { image in
                 guard let tilesImage = image else {
                 guard let tilesImage = image else {