@capacitor/geolocation 7.1.4 → 7.1.5-dev.2

package/CapacitorGeolocation.podspec

@@ -13,6 +13,6 @@ Pod::Spec.new do |s|
   s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
   s.ios.deployment_target = '14.0'
   s.dependency 'Capacitor'
-  s.dependency 'IONGeolocationLib', spec='~> 1.0'
+  #s.dependency 'IONGeolocationLib', spec='1.0.1'
   s.swift_version = '5.1'
 end

package/Package.swift

@@ -10,20 +10,16 @@ let package = Package(
             targets: ["GeolocationPlugin"])
     ],
     dependencies: [
-        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0"),
+        .package(url: "https://github.com/ionic-team/ion-ios-geolocation.git", from: "1.0.2")
     ],
     targets: [
-        .binaryTarget(
-            name: "IONGeolocationLib",
-            url: "https://github.com/ionic-team/ion-ios-geolocation/releases/download/1.0.0/IONGeolocationLib.zip",
-            checksum: "b117d3681a947f5d367e79abdb3bfc9abf7ab070ea5279d7da634ddd2d54ffdb" // sha-256
-        ),
         .target(
             name: "GeolocationPlugin",
             dependencies: [
                 .product(name: "Capacitor", package: "capacitor-swift-pm"),
                 .product(name: "Cordova", package: "capacitor-swift-pm"),
-                "IONGeolocationLib"
+                .product(name: "IONGeolocationLib", package: "ion-ios-geolocation")
             ],
             path: "ios/Sources/GeolocationPlugin"),
         .testTarget(

package/ios/Sources/GeolocationPlugin/GeolocationCallbackManager.swift

@@ -1,5 +1,5 @@
 import Capacitor
-import IONGeolocationLib
+//import IONGeolocationLib
 
 private enum GeolocationCallbackType {
     case requestPermissions

package/ios/Sources/GeolocationPlugin/GeolocationError.swift

@@ -10,6 +10,7 @@ enum GeolocationError: Error {
     case permissionRestricted
     case positionUnavailable
     case inputArgumentsIssue(target: GeolocationMethod)
+    case timeout
 
     func toCodeMessagePair() -> (String, String) {
         ("OS-PLUG-GLOC-\(String(format: "%04d", code))", description)
@@ -29,6 +30,7 @@ private extension GeolocationError {
             case .watchPosition: 5
             case .clearWatch: 6
             }
+        case .timeout: 10
         }
     }
 
@@ -39,6 +41,7 @@ private extension GeolocationError {
         case .locationServicesDisabled: "Location services are not enabled."
         case .permissionRestricted: "Application's use of location services was restricted."
         case .inputArgumentsIssue(let target): "The '\(target.rawValue)' input parameters aren't valid."
+        case .timeout: "Could not obtain location in time. Try with a higher timeout."
         }
     }
 }

package/ios/Sources/GeolocationPlugin/GeolocationPlugin.swift

@@ -1,5 +1,6 @@
 import Capacitor
-import IONGeolocationLib
+
+// import IONGeolocationLib
 import UIKit
 
 import Combine
@@ -19,14 +20,16 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
     private var locationService: (any IONGLOCService)?
     private var cancellables = Set<AnyCancellable>()
     private var locationCancellable: AnyCancellable?
+    private var timeoutCancellable: AnyCancellable?
     private var callbackManager: GeolocationCallbackManager?
     private var statusInitialized = false
     private var locationInitialized: Bool = false
+    private var timeout : Int?
 
     override public func load() {
         self.locationService = IONGLOCManagerWrapper()
         self.callbackManager = .init(capacitorBridge: bridge)
-        
+
         NotificationCenter.default.addObserver(
             self,
             selector: #selector(appDidBecomeActive),
@@ -40,8 +43,10 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
             print("App became active. Restarting location monitoring for watch callbacks.")
             locationCancellable?.cancel()
             locationCancellable = nil
+            timeoutCancellable?.cancel()
+            timeoutCancellable = nil
             locationInitialized = false
-            
+
             locationService?.stopMonitoringLocation()
             locationService?.startMonitoringLocation()
             bindLocationPublisher()
@@ -55,6 +60,7 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
     @objc func getCurrentPosition(_ call: CAPPluginCall) {
         shouldSetupBindings()
         let enableHighAccuracy = call.getBool(Constants.Arguments.enableHighAccuracy, false)
+        self.timeout = call.getInt("timeout")
         handleLocationRequest(enableHighAccuracy, call: call)
     }
 
@@ -62,6 +68,7 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
         shouldSetupBindings()
         let enableHighAccuracy = call.getBool(Constants.Arguments.enableHighAccuracy, false)
         let watchUUID = call.callbackId
+        self.timeout = call.getInt("timeout")
         handleLocationRequest(enableHighAccuracy, watchUUID: watchUUID, call: call)
     }
 
@@ -77,6 +84,8 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
             locationService?.stopMonitoringLocation()
             locationCancellable?.cancel()
             locationCancellable = nil
+            timeoutCancellable?.cancel()
+            timeoutCancellable = nil
             locationInitialized = false
         }
 
@@ -145,7 +154,7 @@ private extension GeolocationPlugin {
         locationCancellable = locationService?.currentLocationPublisher
             .catch { [weak self] error -> AnyPublisher<IONGLOCPositionModel, Never> in
                 print("An error was found while retrieving the location: \(error)")
-                
+
                 if case IONGLOCLocationError.locationUnavailable = error {
                     print("Location unavailable (likely due to backgrounding). Keeping watch callbacks alive.")
                     self?.callbackManager?.sendError(.positionUnavailable)
@@ -160,6 +169,15 @@ private extension GeolocationPlugin {
             .sink(receiveValue: { [weak self] position in
                 self?.callbackManager?.sendSuccess(with: position)
             })
+
+        timeoutCancellable = locationService?.locationTimeoutPublisher
+            .sink(receiveValue: { [weak self] error in
+                if case .timeout = error {
+                    self?.callbackManager?.sendError(.timeout)
+                } else {
+                    self?.callbackManager?.sendError(.positionUnavailable)
+                }
+            })
     }
 
     func requestLocationAuthorisation(type requestType: IONGLOCAuthorisationRequestType) {
@@ -200,14 +218,15 @@ private extension GeolocationPlugin {
             callbackManager?.sendRequestPermissionsSuccess(Constants.AuthorisationStatus.Status.granted)
         }
         if shouldRequestCurrentPosition {
-            locationService?.requestSingleLocation()
+            locationService?.requestSingleLocation(timeout: self.timeout)
         }
         if shouldRequestLocationMonitoring {
-            locationService?.startMonitoringLocation()
+            locationService?.startMonitoringLocation(timeout: self.timeout)
         }
     }
 
     func handleLocationRequest(_ enableHighAccuracy: Bool, watchUUID: String? = nil, call: CAPPluginCall) {
+        bindLocationPublisher()
         let configurationModel = IONGLOCConfigurationModel(enableHighAccuracy: enableHighAccuracy)
         locationService?.updateConfiguration(configurationModel)
 

package/ios/Sources/GeolocationPlugin/IONGLOCPositionModel+JSONTransformer.swift

@@ -1,5 +1,5 @@
 import Capacitor
-import IONGeolocationLib
+//import IONGeolocationLib
 
 extension IONGLOCPositionModel {
     func toJSObject() -> JSObject {

package/ios/Sources/GeolocationPlugin/IONGeolocationLib/IONGLOCAuthorisation.swift

@@ -0,0 +1,26 @@
+import CoreLocation
+
+public enum IONGLOCAuthorisation {
+    case notDetermined
+    case restricted
+    case denied
+    case authorisedAlways
+    case authorisedWhenInUse
+
+    init(from status: CLAuthorizationStatus) {
+        self = switch status {
+        case .notDetermined: .notDetermined
+        case .restricted: .restricted
+        case .denied: .denied
+        case .authorizedAlways: .authorisedAlways
+        case .authorizedWhenInUse: .authorisedWhenInUse
+        @unknown default: .notDetermined
+        }
+    }
+}
+
+extension CLLocationManager {
+    var currentAuthorisationValue: IONGLOCAuthorisation {
+        .init(from: authorizationStatus)
+    }
+}

package/ios/Sources/GeolocationPlugin/IONGeolocationLib/IONGLOCAuthorisationRequestType.swift

@@ -0,0 +1,16 @@
+import CoreLocation
+
+public enum IONGLOCAuthorisationRequestType {
+    case whenInUse
+    case always
+
+    func requestAuthorization(using locationManager: CLLocationManager) {
+        let requestAuthorisation = switch self {
+        case .whenInUse:
+            locationManager.requestWhenInUseAuthorization
+        case .always:
+            locationManager.requestAlwaysAuthorization
+        }
+        requestAuthorisation()
+    }
+}

package/ios/Sources/GeolocationPlugin/IONGeolocationLib/IONGLOCPositionModel.swift

@@ -0,0 +1,44 @@
+import CoreLocation
+
+public struct IONGLOCPositionModel: Equatable {
+    private(set) public var altitude: Double
+    private(set) public var course: Double
+    private(set) public var horizontalAccuracy: Double
+    private(set) public var latitude: Double
+    private(set) public var longitude: Double
+    private(set) public var speed: Double
+    private(set) public var timestamp: Double
+    private(set) public var verticalAccuracy: Double
+
+    private init(altitude: Double, course: Double, horizontalAccuracy: Double, latitude: Double, longitude: Double, speed: Double, timestamp: Double, verticalAccuracy: Double) {
+        self.altitude = altitude
+        self.course = course
+        self.horizontalAccuracy = horizontalAccuracy
+        self.latitude = latitude
+        self.longitude = longitude
+        self.speed = speed
+        self.timestamp = timestamp
+        self.verticalAccuracy = verticalAccuracy
+    }
+}
+
+public extension IONGLOCPositionModel {
+    static func create(from location: CLLocation) -> IONGLOCPositionModel {
+        .init(
+            altitude: location.altitude,
+            course: location.course,
+            horizontalAccuracy: location.horizontalAccuracy,
+            latitude: location.coordinate.latitude,
+            longitude: location.coordinate.longitude,
+            speed: location.speed,
+            timestamp: location.timestamp.millisecondsSinceUnixEpoch,
+            verticalAccuracy: location.verticalAccuracy
+        )
+    }
+}
+
+private extension Date {
+    var millisecondsSinceUnixEpoch: Double {
+        timeIntervalSince1970 * 1000
+    }
+}

package/ios/Sources/GeolocationPlugin/IONGeolocationLib/Publishers/IONGLOCManagerProtocols.swift

@@ -0,0 +1,45 @@
+import Combine
+
+public protocol IONGLOCServicesChecker {
+    func areLocationServicesEnabled() -> Bool
+}
+
+public protocol IONGLOCAuthorisationHandler {
+    var authorisationStatus: IONGLOCAuthorisation { get }
+    var authorisationStatusPublisher: Published<IONGLOCAuthorisation>.Publisher { get }
+
+    func requestAuthorisation(withType authorisationType: IONGLOCAuthorisationRequestType)
+}
+
+public enum IONGLOCLocationError: Error {
+    case locationUnavailable
+    case timeout
+    case other(_ error: Error)
+}
+
+public protocol IONGLOCLocationHandler {
+    var currentLocation: IONGLOCPositionModel? { get }
+    var currentLocationPublisher: AnyPublisher<IONGLOCPositionModel, IONGLOCLocationError> { get }
+    var locationTimeoutPublisher: AnyPublisher<IONGLOCLocationError, Never> { get }
+    func updateConfiguration(_ configuration: IONGLOCConfigurationModel)
+}
+
+public protocol IONGLOCSingleLocationHandler: IONGLOCLocationHandler {
+    func requestSingleLocation(timeout: Int?)
+}
+
+public protocol IONGLOCMonitorLocationHandler: IONGLOCLocationHandler {
+    func startMonitoringLocation(timeout: Int?)
+    func startMonitoringLocation()
+    func stopMonitoringLocation()
+}
+
+public struct IONGLOCConfigurationModel {
+    private(set) var enableHighAccuracy: Bool
+    private(set) var minimumUpdateDistanceInMeters: Double?
+
+    public init(enableHighAccuracy: Bool, minimumUpdateDistanceInMeters: Double? = nil) {
+        self.enableHighAccuracy = enableHighAccuracy
+        self.minimumUpdateDistanceInMeters = minimumUpdateDistanceInMeters
+    }
+}

package/ios/Sources/GeolocationPlugin/IONGeolocationLib/Publishers/IONGLOCManagerWrapper.swift

@@ -0,0 +1,133 @@
+import Combine
+import CoreLocation
+
+public typealias IONGLOCService = IONGLOCServicesChecker & IONGLOCAuthorisationHandler & IONGLOCSingleLocationHandler & IONGLOCMonitorLocationHandler
+
+public struct IONGLOCServicesValidator: IONGLOCServicesChecker {
+    public init() {}
+    
+    public func areLocationServicesEnabled() -> Bool {
+        CLLocationManager.locationServicesEnabled()
+    }
+}
+
+public class IONGLOCManagerWrapper: NSObject, IONGLOCService {
+    @Published public var authorisationStatus: IONGLOCAuthorisation
+    public var authorisationStatusPublisher: Published<IONGLOCAuthorisation>.Publisher { $authorisationStatus }
+
+    @Published public var currentLocation: IONGLOCPositionModel?
+    private var timeoutCancellable: AnyCancellable?
+    public var currentLocationPublisher: AnyPublisher<IONGLOCPositionModel, IONGLOCLocationError> {
+        Publishers.Merge($currentLocation, currentLocationForceSubject)
+            .dropFirst()    // ignore the first value as it's the one set on the constructor.
+            .tryMap { location in
+                guard let location else { throw IONGLOCLocationError.locationUnavailable }
+                return location
+            }
+            .mapError { $0 as? IONGLOCLocationError ?? .other($0) }
+            .eraseToAnyPublisher()
+    }
+    
+    public var locationTimeoutPublisher: AnyPublisher<IONGLOCLocationError, Never> {
+        locationTimeoutSubject.eraseToAnyPublisher()
+    }
+    
+    private let currentLocationForceSubject = PassthroughSubject<IONGLOCPositionModel?, Never>()
+    private let locationTimeoutSubject = PassthroughSubject<IONGLOCLocationError, Never>()
+    
+    private let locationManager: CLLocationManager
+    private let servicesChecker: IONGLOCServicesChecker
+    
+    private var isMonitoringLocation = false
+
+    public init(locationManager: CLLocationManager = .init(), servicesChecker: IONGLOCServicesChecker = IONGLOCServicesValidator()) {
+        self.locationManager = locationManager
+        self.servicesChecker = servicesChecker
+        self.authorisationStatus = locationManager.currentAuthorisationValue
+
+        super.init()
+        locationManager.delegate = self
+    }
+
+    public func requestAuthorisation(withType authorisationType: IONGLOCAuthorisationRequestType) {
+        authorisationType.requestAuthorization(using: locationManager)
+    }
+  
+    public func startMonitoringLocation(timeout: Int? = nil) {
+        let timeoutValue = timeout ?? 5000
+        isMonitoringLocation = true
+        self.startTimer(timeout: timeoutValue)
+        locationManager.startUpdatingLocation()
+    }
+    
+    public func startMonitoringLocation() {
+        isMonitoringLocation = true
+        locationManager.startUpdatingLocation()
+    }
+
+    public func stopMonitoringLocation() {
+        isMonitoringLocation = false
+        locationManager.stopUpdatingLocation()
+    }
+    
+    public func requestSingleLocation(timeout: Int? = nil) {
+        // Fallback to default timeout (5000) when the parameter is nil,
+        // since optional defaults in Swift don't apply when nil is explicitly passed.
+        let timeoutValue = timeout ?? 5000
+        // If monitoring is active meaning the location service is already running
+        // and calling .requestLocation() will not trigger a new location update,
+        // we can just return the current location.
+        if isMonitoringLocation, let location = currentLocation {
+            currentLocationForceSubject.send(location)
+            return
+        }
+        self.startTimer(timeout: timeoutValue)
+        self.locationManager.requestLocation()
+    }
+    
+    private func startTimer(timeout: Int) {
+        timeoutCancellable?.cancel()
+        timeoutCancellable = nil
+        timeoutCancellable = Just(())
+            .delay(for: .milliseconds(timeout), scheduler: DispatchQueue.main)
+            .sink { [weak self] _ in
+                guard let self = self else { return }
+                self.locationTimeoutSubject.send(.timeout)
+                self.timeoutCancellable?.cancel()
+                self.timeoutCancellable = nil
+            }
+    }
+    
+    public func updateConfiguration(_ configuration: IONGLOCConfigurationModel) {
+        locationManager.desiredAccuracy = configuration.enableHighAccuracy ? kCLLocationAccuracyBest : kCLLocationAccuracyThreeKilometers
+        configuration.minimumUpdateDistanceInMeters.map {
+            locationManager.distanceFilter = $0
+        }
+    }
+
+    public func areLocationServicesEnabled() -> Bool {
+        servicesChecker.areLocationServicesEnabled()
+    }
+}
+
+extension IONGLOCManagerWrapper: CLLocationManagerDelegate {
+    public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        authorisationStatus = manager.currentAuthorisationValue
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        timeoutCancellable?.cancel()
+        timeoutCancellable = nil
+        guard let latestLocation = locations.last else {
+            currentLocation = nil
+            return
+        }
+        currentLocation = IONGLOCPositionModel.create(from: latestLocation)
+    }
+
+    public func locationManager(_ manager: CLLocationManager, didFailWithError error: any Error) {
+        timeoutCancellable?.cancel()
+        timeoutCancellable = nil
+        currentLocation = nil
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/geolocation",
-  "version": "7.1.4",
+  "version": "7.1.5-dev.2",
   "description": "The Geolocation API provides simple methods for getting and tracking the current position of the device using GPS, along with altitude, heading, and speed information if available.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -57,6 +57,7 @@
     "@ionic/prettier-config": "^4.0.0",
     "@ionic/swiftlint-config": "^2.0.0",
     "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^11.0.1",
     "@semantic-release/npm": "^12.0.1",