@capacitor/geolocation 7.1.0-dev.2 → 7.1.1-pr.25

package/Package.swift

@@ -10,7 +10,7 @@ let package = Package(
             targets: ["GeolocationPlugin"])
     ],
     dependencies: [
-        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", branch: "main")
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
     ],
     targets: [
         .binaryTarget(

package/README.md

@@ -48,7 +48,7 @@ Read about [Setting Permissions](https://capacitorjs.com/docs/android/configurat
 
 </docgen-index>
 
-For list of error codes, see [Errors](#Errors)
+For list of error codes, see [Errors](#errors)
 
 <docgen-api>
 <!--Update the source file JSDoc comments and rerun docgen to update the docs below-->

package/ios/Sources/GeolocationPlugin/GeolocationCallbackManager.swift

@@ -2,6 +2,7 @@ import Capacitor
 import IONGeolocationLib
 
 private enum GeolocationCallbackType {
+    case requestPermissions
     case location
     case watch
 
@@ -10,7 +11,7 @@ private enum GeolocationCallbackType {
     }
 
     var shouldClearAfterSending: Bool {
-        self == .location
+        self == .location || self == .requestPermissions
     }
 }
 
@@ -20,23 +21,34 @@ private struct GeolocationCallbackGroup {
 }
 
 final class GeolocationCallbackManager {
+    private(set) var requestPermissionsCallbacks: [CAPPluginCall]
     private(set) var locationCallbacks: [CAPPluginCall]
     private(set) var watchCallbacks: [String: CAPPluginCall]
     private let capacitorBridge: CAPBridgeProtocol?
 
     private var allCallbackGroups: [GeolocationCallbackGroup] {
         [
+            .init(ids: requestPermissionsCallbacks, type: .requestPermissions),
             .init(ids: locationCallbacks, type: .location),
             .init(ids: Array(watchCallbacks.values), type: .watch)
         ]
     }
+    private var requestPermissionsCallbackGroup: GeolocationCallbackGroup? {
+        allCallbackGroups.first { $0.type == .requestPermissions }
+    }
 
     init(capacitorBridge: CAPBridgeProtocol?) {
         self.capacitorBridge = capacitorBridge
+        self.requestPermissionsCallbacks = []
         self.locationCallbacks = []
         self.watchCallbacks = [:]
     }
 
+    func addRequestPermissionsCallback(capacitorCall call: CAPPluginCall) {
+        capacitorBridge?.saveCall(call)
+        requestPermissionsCallbacks.append(call)
+    }
+
     func addLocationCallback(capacitorCall call: CAPPluginCall) {
         capacitorBridge?.saveCall(call)
         locationCallbacks.append(call)
@@ -47,6 +59,13 @@ final class GeolocationCallbackManager {
         watchCallbacks[watchId] = call
     }
 
+    func clearRequestPermissionsCallbacks() {
+        requestPermissionsCallbacks.forEach {
+            capacitorBridge?.releaseCall($0)
+        }
+        requestPermissionsCallbacks.removeAll()
+    }
+
     func clearWatchCallbackIfExists(_ watchId: String) {
         if let callbackToRemove = watchCallbacks[watchId] {
             capacitorBridge?.releaseCall(callbackToRemove)
@@ -69,10 +88,25 @@ final class GeolocationCallbackManager {
         call.resolve(data)
     }
 
+    func sendRequestPermissionsSuccess(_ permissionsResult: String) {
+        if let group = requestPermissionsCallbackGroup {
+            let data = [
+                Constants.AuthorisationStatus.ResultKey.location: permissionsResult,
+                Constants.AuthorisationStatus.ResultKey.coarseLocation: permissionsResult
+            ]
+            send(.success(data), to: group)
+        }
+    }
+
     func sendSuccess(with position: IONGLOCPositionModel) {
         createPluginResult(status: .success(position.toJSObject()))
     }
 
+    func sendError(_ call: CAPPluginCall, error: GeolocationError) {
+        let errorModel = error.toCodeMessagePair()
+        call.reject(errorModel.1, errorModel.0)
+    }
+
     func sendError(_ error: GeolocationError) {
         createPluginResult(status: .error(error.toCodeMessagePair()))
     }
@@ -87,6 +121,7 @@ private enum CallResultStatus {
 }
 
 private extension GeolocationCallbackManager {
+
     func createPluginResult(status: CallResultStatus) {
         allCallbackGroups.forEach {
             send(status, to: $0)
@@ -112,6 +147,8 @@ private extension GeolocationCallbackManager {
     func clearCallbacks(for type: GeolocationCallbackType) {
         if case .location = type {
             clearLocationCallbacks()
+        } else if case .requestPermissions = type {
+            clearRequestPermissionsCallbacks()
         }
     }
 }

package/ios/Sources/GeolocationPlugin/GeolocationPlugin.swift

@@ -18,7 +18,8 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
     private var locationService: (any IONGLOCService)?
     private var cancellables = Set<AnyCancellable>()
     private var callbackManager: GeolocationCallbackManager?
-    private var isInitialised: Bool = false
+    private var statusInitialized = false
+    private var locationInitialized: Bool = false
 
     override public func load() {
         self.locationService = IONGLOCManagerWrapper()
@@ -53,8 +54,8 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
         callbackManager?.sendSuccess(call)
     }
 
-    override public func checkPermissions(_ call: CAPPluginCall) {
-        checkIfLocationServicesAreEnabled()
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        guard checkIfLocationServicesAreEnabled(call) else { return }
 
         let status = switch locationService?.authorisationStatus {
         case .restricted, .denied: Constants.AuthorisationStatus.Status.denied
@@ -69,11 +70,12 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
         callbackManager?.sendSuccess(call, with: callResultData)
     }
 
-    override public func requestPermissions(_ call: CAPPluginCall) {
-        checkIfLocationServicesAreEnabled()
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        guard checkIfLocationServicesAreEnabled(call) else { return }
 
         if locationService?.authorisationStatus == .notDetermined {
             shouldSetupBindings()
+            callbackManager?.addRequestPermissionsCallback(capacitorCall: call)
         } else {
             checkPermissions(call)
         }
@@ -82,33 +84,40 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
 
 private extension GeolocationPlugin {
     func shouldSetupBindings() {
-        guard !isInitialised else { return }
-        isInitialised = true
-        setupBindings()
+        bindauthorisationStatusPublisher()
+        bindLocationPublisher()
     }
 
-    func setupBindings() {
+    func bindauthorisationStatusPublisher() {
+        guard !statusInitialized else { return }
+        statusInitialized = true
         locationService?.authorisationStatusPublisher
             .sink(receiveValue: { [weak self] status in
                 guard let self else { return }
 
                 switch status {
                 case .denied:
-                    self.callbackManager?.sendError(.permissionDenied)
+                    self.onLocationPermissionNotGranted(error: .permissionDenied)
                 case .notDetermined:
                     self.requestLocationAuthorisation(type: .whenInUse)
                 case .restricted:
-                    self.callbackManager?.sendError(.permissionRestricted)
+                    self.onLocationPermissionNotGranted(error: .permissionRestricted)
                 case .authorisedAlways, .authorisedWhenInUse:
-                    self.requestLocation()
+                    self.onLocationPermissionGranted()
                 @unknown default: break
                 }
             })
             .store(in: &cancellables)
+    }
 
+    func bindLocationPublisher() {
+        guard !locationInitialized else { return }
+        locationInitialized = true
         locationService?.currentLocationPublisher
             .sink(receiveCompletion: { [weak self] completion in
                 if case .failure(let error) = completion {
+                    // publisher should be re-observed in the next plugin call
+                    self?.locationInitialized = false
                     print("An error was found while retrieving the location: \(error)")
                     self?.callbackManager?.sendError(.positionUnavailable)
                 }
@@ -120,23 +129,41 @@ private extension GeolocationPlugin {
 
     func requestLocationAuthorisation(type requestType: IONGLOCAuthorisationRequestType) {
         DispatchQueue.global(qos: .background).async {
-            self.checkIfLocationServicesAreEnabled()
+            guard self.checkIfLocationServicesAreEnabled() else { return }
             self.locationService?.requestAuthorisation(withType: requestType)
         }
     }
 
-    func checkIfLocationServicesAreEnabled() {
-        guard locationService?.areLocationServicesEnabled() ?? false else {
-            callbackManager?.sendError(.locationServicesDisabled)
-            return
+    func checkIfLocationServicesAreEnabled(_ call: CAPPluginCall? = nil) -> Bool {
+        guard locationService?.areLocationServicesEnabled() == true else {
+            call.map { callbackManager?.sendError($0, error: .locationServicesDisabled) }
+                ?? callbackManager?.sendError(.locationServicesDisabled)
+            return false
+        }
+        return true
+    }
+
+    func onLocationPermissionNotGranted(error: GeolocationError) {
+        let shouldNotifyRequestPermissionsResult = callbackManager?.requestPermissionsCallbacks.isEmpty == false
+        let shouldNotifyPermissionError = callbackManager?.locationCallbacks.isEmpty == false ||  callbackManager?.watchCallbacks.isEmpty == false
+
+        if shouldNotifyRequestPermissionsResult {
+            self.callbackManager?.sendRequestPermissionsSuccess(Constants.AuthorisationStatus.Status.denied)
+        }
+        if shouldNotifyPermissionError {
+            self.callbackManager?.sendError(error)
         }
     }
 
-    func requestLocation() {
-        // should request if callbacks exist and are not empty
+    func onLocationPermissionGranted() {
+        let shouldNotifyPermissionGranted = callbackManager?.requestPermissionsCallbacks.isEmpty == false
+        // should request location if callbacks below exist and are not empty
         let shouldRequestCurrentPosition = callbackManager?.locationCallbacks.isEmpty == false
         let shouldRequestLocationMonitoring = callbackManager?.watchCallbacks.isEmpty == false
 
+        if shouldNotifyPermissionGranted {
+            callbackManager?.sendRequestPermissionsSuccess(Constants.AuthorisationStatus.Status.granted)
+        }
         if shouldRequestCurrentPosition {
             locationService?.requestSingleLocation()
         }
@@ -156,7 +183,7 @@ private extension GeolocationPlugin {
         }
 
         switch locationService?.authorisationStatus {
-        case .authorisedAlways, .authorisedWhenInUse: requestLocation()
+        case .authorisedAlways, .authorisedWhenInUse: onLocationPermissionGranted()
         case .denied: callbackManager?.sendError(.permissionDenied)
         case .restricted: callbackManager?.sendError(.permissionRestricted)
         default: break

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capacitor/geolocation",
-  "version": "7.1.0-dev.2",
-  "description": "Geolocation plugin for Capacitor",
+  "version": "7.1.1-pr.25",
+  "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",
   "types": "dist/esm/index.d.ts",
@@ -86,4 +86,4 @@
       "src": "android"
     }
   }
-}
+}