Weatherkit data how to improve app launch?

Question

I am making a weather app with the new Apple weatherKit. I want to improve the launch of the application because sometimes it crashes. So I would like at launch the data to be refreshed (loaded) and when the application is in the background, the data is refreshed every 30 min. here is the swift file i am trying to edit.

thank you

    @main
struct PlaneWXApp: App {
    @Environment(\.scenePhase) private var phase

    let weatherModel: WeatherModel
    
    @StateObject var launchScreeenManager = LaunchScreenManager()

    init() {
        self.weatherModel = WeatherModel()

        weatherModel.refresh()
    }
    @State private var selection = 3

    var body: some Scene {
        WindowGroup {
            ZStack{
                TabView(selection: $selection) {
                    alertView(weatherModel: weatherModel).tag(1)
                    todayView(weatherModel: weatherModel).tag(2)
                    homeView(weatherModel: weatherModel).tag(3)
                    forecastView(weatherModel: weatherModel).tag(4)

                }
                .tabViewStyle(PageTabViewStyle(indexDisplayMode: .always))
                .onAppear
                {
                    DispatchQueue
                        .main
                        .asyncAfter(deadline: .now() + 5) {
                            launchScreeenManager.dismiss()
                        }
                    
                    UIPageControl.appearance().currentPageIndicatorTintColor = .black
                    UIPageControl.appearance().pageIndicatorTintColor = UIColor.black.withAlphaComponent(0.2)
                }
                
                if launchScreeenManager.state != .completed{
                    LaunchScreenView()
                }
            }
            .environmentObject(launchScreeenManager)
        }
        .onChange(of: phase) { newPhase in
            switch newPhase {
            case .background: scheduleAppRefresh()
            default: break
            }
        }
        .backgroundTask(.appRefresh("myapprefresh")) {
            await weatherModel.refresh()
        }
    }
}

func scheduleAppRefresh() {
    let request = BGAppRefreshTaskRequest(identifier: "myapprefresh")
    request.earliestBeginDate = .now.addingTimeInterval(24 * 3600)
    try? BGTaskScheduler.shared.submit(request)
}

WeatherModel:

@MainActor

class WeatherModel: ObservableObject { let locationProvider = LocationProvider()

@Published var temperature: String?
@Published var minTemperature: String?
@Published var maxTemperature: String?

@Published var feelTemperature: String?
@Published var feelTemperatureDescription: String?
@Published var dewPoint: String?

@Published var alerts: [WeatherAlertInfo] = []

@Published var wind: [Wind] = []


func refresh() {
    Task {
        await getAddress()
        await getWeather()
    }
}

private func getAddress() async{

    let locManager = CLLocationManager()
    var currentLocation: CLLocation!
    currentLocation = locManager.location
    
    if let currentLocation {
        let location = CLLocation(latitude: currentLocation.coordinate.latitude,
                                  longitude: currentLocation.coordinate.longitude)
        
        locationProvider.getPlace(for: location) { plsmark in
            guard let placemark = plsmark else { return }
            if let city = placemark.locality,
               let state = placemark.administrativeArea {
                self.cityName = "\(city), \(state)"
            } else if let city = placemark.locality, let state = placemark.administrativeArea {
                self.cityName = "\(city) \(state)"
            } else {
                self.cityName = "Address Unknown"
            }
        }
    }
 }
          
private func getWeather() async {
    let weatherService = WeatherService()
            
    let locManager = CLLocationManager()
    var currentLocation: CLLocation!
    currentLocation = locManager.location
    
    let weather: Weather?
    
    if let currentLocation {
        let coordinate = CLLocation(latitude: currentLocation.coordinate.latitude
                                    ,longitude: currentLocation.coordinate.longitude)
        weather = try? await weatherService.weather(for: coordinate)
    } else {
        weather = nil
    }

    var todayForecast: DayWeather? {
       weather?.dailyForecast.first{Calendar.current.isDateInToday($0.date) }
    }

    minTemperature = todayForecast?.lowTemperature.formatted()
    maxTemperature = todayForecast?.highTemperature.formatted()

Location provider

private func getAddress() async{

        let locManager = CLLocationManager()
        var currentLocation: CLLocation!
        currentLocation = locManager.location
        
        if let currentLocation {
            let location = CLLocation(latitude: currentLocation.coordinate.latitude,
                                      longitude: currentLocation.coordinate.longitude)
            
            locationProvider.getPlace(for: location) { plsmark in
                guard let placemark = plsmark else { return }
                if let city = placemark.locality,
                   let state = placemark.administrativeArea {
                    self.cityName = "\(city), \(state)"
                } else if let city = placemark.locality, let state = placemark.administrativeArea {
                    self.cityName = "\(city) \(state)"
                } else {
                    self.cityName = "Address Unknown"
                }
            }
        }
     }
              
    private func getWeather() async {
        let weatherService = WeatherService()
                
        let locManager = CLLocationManager()
        var currentLocation: CLLocation!
        currentLocation = locManager.location
        
        let weather: Weather?
        
        if let currentLocation {
            let coordinate = CLLocation(latitude: currentLocation.coordinate.latitude
                                        ,longitude: currentLocation.coordinate.longitude)
            weather = try? await weatherService.weather(for: coordinate)
        } else {
            weather = nil
        }
}


public func getPlace(for location: CLLocation, completion: @escaping (CLPlacemark?) -> Void) {
    let geocoder = CLGeocoder()
    geocoder.reverseGeocodeLocation(location) { placemarks, error in
        guard error == nil else {
            print("=====> Error \(error!.localizedDescription)")
            completion(nil)
            return
        }
        guard let placemark = placemarks?.first else {
            print("=====> Error placemark is nil")
            completion(nil)
            return
        }
        completion(placemark)
    }
}

Launch process

@main
struct PlaneWXApp: App {
    @Environment(\.scenePhase) private var phase
    @StateObject var model = WeatherModel()

    @StateObject var launchScreeenManager = LaunchScreenManager()

    @State private var selection = 3

    var body: some Scene {
        WindowGroup {
            ZStack{
                TabView(selection: $selection) {
                    alertView(weatherModel: weatherModel).tag(1)
                    todayView(weatherModel: weatherModel).tag(2)
                    homeView(weatherModel: weatherModel).tag(3)
                    forecastView(weatherModel: weatherModel).tag(4)

                }
                .tabViewStyle(PageTabViewStyle(indexDisplayMode: .always))
                .onAppear
                {
                    DispatchQueue
                        .main
                        .asyncAfter(deadline: .now() + 5) {
                            launchScreeenManager.dismiss()
                        }
                    
                    UIPageControl.appearance().currentPageIndicatorTintColor = .black
                    UIPageControl.appearance().pageIndicatorTintColor = UIColor.black.withAlphaComponent(0.2)
                }
                
                if launchScreeenManager.state != .completed{
                    LaunchScreenView()
                }
            }
            .environmentObject(launchScreeenManager)
        }
        .onChange(of: phase) { newPhase in
            switch newPhase {
            case .background: scheduleAppRefresh()
            default: break
            }
        }
        .backgroundTask(.appRefresh("myapprefresh")) {
            await model.getWeather()
        }
    }
}

func scheduleAppRefresh() {
    let request = BGAppRefreshTaskRequest(identifier: "myapprefresh")
    request.earliestBeginDate = .now.addingTimeInterval(24 * 3600)
    try? BGTaskScheduler.shared.submit(request)
}

Answer 1

The code cannot work because you have to ask CLLocationManager to get the current location asynchronously.

This is a basic implementation of a location manager to get the current location and the places for a location async/await compliant.

import CoreLocation

@MainActor
class LocationManager : NSObject {
   
    private var continuation : CheckedContinuation<CLLocation, Error>?
    private let locationManager : CLLocationManager
   
    public override init() {
        locationManager = CLLocationManager()
        super.init()
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyBest
        locationManager.requestAlwaysAuthorization()
    }
    
    public func currentLocation() async throws -> CLLocation {
        try await withCheckedThrowingContinuation { continuation in
            self.continuation = continuation
            locationManager.startUpdatingLocation()
        }
    }
    
    public func getPlaces(for location: CLLocation) async throws -> [CLPlacemark] {
        try await CLGeocoder().reverseGeocodeLocation(location, preferredLocale: nil)
    }
}

extension LocationManager : CLLocationManagerDelegate {
    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
        self.continuation?.resume(throwing: error)
        locationManager.stopUpdatingLocation()
    }
    
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        self.continuation?.resume(returning: locations.last!)
        locationManager.stopUpdatingLocation()
    }
}

WeatherModel can be reduced to the following, rather than having a lot of optional @Published properties there are only two (non-optional), a state enum which indicates several phases and the cityName

@MainActor
class WeatherModel: ObservableObject {

    enum LoadingState {
        case idle, loading, loaded(CurrentWeather, DayWeather), failed(Error)
    }
    
    let service = WeatherService()

    @Published var state = LoadingState.idle
    @Published var cityName = "" 

    func getWeather() async {
        state = .loading
        let manager = LocationManager()
        do {
            let location = try await manager.currentLocation()
            let weather = try await service.weather(for: location)
            let places = try await manager.getPlaces(for: location)
            let today = weather.dailyForecast.first{ Calendar.current.isDateInToday($0.date) }!
            state = .loaded(weather.currentWeather, today)
            guard let placemark = places.first else { return }
            if let city = placemark.locality,
               let state = placemark.administrativeArea {
                self.cityName = "\(city), \(state)"
            } else if let city = placemark.locality {
                self.cityName = city
            } else {
                self.cityName = "Address Unknown"
            }
        } catch {
            state = .failed(error)
        }
    }
}

In the view create an instance of WeatherModel and switch on the state. Add your views in the loaded and failed states.

import WeatherKit

struct ContentView: View {
    @StateObject var model = WeatherModel()
    
    var body: some View {
        Group {
            switch model.state {
                case .idle: EmptyView()
                case .loading: ProgressView()
                case .loaded(let currentWeather, let today): // show weather data
                case .failed(let error): // show error 
        }
        .task {
            await model.getWeather()
        }
    }
}