Not has address

pedi-foods/Sources/PediFoods/Services/LocationService.swift

@@ -4,8 +4,10 @@ import Foundation
 import CoreLocation
 #endif
 
+@MainActor
 final class LocationService: NSObject {
     typealias LocationResult = Result<(Double, Double), LocationError>
+    static let shared = LocationService()
 
 #if os(iOS)
     enum LocationError: Error {
@@ -35,13 +37,8 @@ final class LocationService: NSObject {
 
     func requestLocation(_ completion: @escaping (LocationResult) -> Void) {
 #if os(iOS)
-        guard CLLocationManager.locationServicesEnabled() else {
-            completion(.failure(.servicesDisabled))
-            return
-        }
         self.completion = completion
-        manager.requestWhenInUseAuthorization()
-        manager.requestLocation()
+        handleAuthorizationStatus(manager.authorizationStatus)
 #else
         let defaults = UserDefaults.standard
         if defaults.bool(forKey: "location_permission_denied") {
@@ -59,16 +56,55 @@ final class LocationService: NSObject {
         completion(.success((lat, lng)))
 #endif
     }
+
+    func cachedLocation() -> (Double, Double)? {
+#if os(iOS)
+        guard let location = manager.location else {
+            return nil
+        }
+        return (location.coordinate.latitude, location.coordinate.longitude)
+#else
+        let defaults = UserDefaults.standard
+        guard let latRaw = defaults.string(forKey: "last_location_lat"),
+              let lngRaw = defaults.string(forKey: "last_location_lng"),
+              let lat = Double(latRaw),
+              let lng = Double(lngRaw) else {
+            return nil
+        }
+        return (lat, lng)
+#endif
+    }
+
+    func requestLocationAsync(timeoutSeconds: TimeInterval = 8) async -> (Double, Double)? {
+        await withCheckedContinuation { continuation in
+            var hasResumed = false
+
+            func resumeOnce(_ value: (Double, Double)?) {
+                guard hasResumed == false else { return }
+                hasResumed = true
+                continuation.resume(returning: value)
+            }
+
+            requestLocation { result in
+                switch result {
+                case .success(let coordinate):
+                    resumeOnce(coordinate)
+                case .failure:
+                    resumeOnce(nil)
+                }
+            }
+
+            DispatchQueue.main.asyncAfter(deadline: .now() + timeoutSeconds) {
+                resumeOnce(nil)
+            }
+        }
+    }
 }
 
 #if os(iOS)
-extension LocationService: CLLocationManagerDelegate {
+extension LocationService: @preconcurrency CLLocationManagerDelegate {
     func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
-        let status = manager.authorizationStatus
-        if status == .denied || status == .restricted {
-            completion?(.failure(.denied))
-            completion = nil
-        }
+        handleAuthorizationStatus(manager.authorizationStatus)
     }
 
     func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
@@ -81,5 +117,20 @@ extension LocationService: CLLocationManagerDelegate {
         completion?(.failure(.unavailable))
         completion = nil
     }
+
+    private func handleAuthorizationStatus(_ status: CLAuthorizationStatus) {
+        switch status {
+        case .notDetermined:
+            manager.requestWhenInUseAuthorization()
+        case .authorizedAlways, .authorizedWhenInUse:
+            manager.requestLocation()
+        case .denied, .restricted:
+            completion?(.failure(.denied))
+            completion = nil
+        @unknown default:
+            completion?(.failure(.unavailable))
+            completion = nil
+        }
+    }
 }
 #endif