@capacitor/geolocation 7.1.0-dev.2 → 7.1.1

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

@@ -53,8 +53,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 +69,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)
         }
@@ -94,13 +95,13 @@ private extension GeolocationPlugin {
 
                 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
                 }
             })
@@ -120,23 +121,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 +175,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",
+  "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"
     }
   }
-}
+}