@capacitor/geolocation 8.0.0-next.2 → 8.0.0-next.4

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 = '15.0'
   s.dependency 'Capacitor'
-  s.dependency 'IONGeolocationLib', spec='1.0.1'
+  s.dependency 'IONGeolocationLib', spec='2.0.0'
   s.swift_version = '5.1'
 end

package/Package.swift

@@ -11,7 +11,7 @@ let package = Package(
     ],
     dependencies: [
         .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")
+        .package(url: "https://github.com/ionic-team/ion-ios-geolocation.git", from: "2.0.0")
     ],
     targets: [
         .target(

package/README.md

@@ -167,12 +167,13 @@ Not available on web.
 
 #### PositionOptions
 
-| Prop                        | Type                 | Description                                                                                                                                                                                                                                                                                                     | Default            | Since |
-| --------------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- |
-| **`enableHighAccuracy`**    | <code>boolean</code> | High accuracy mode (such as GPS, if available) On Android 12+ devices it will be ignored if users didn't grant ACCESS_FINE_LOCATION permissions (can be checked with location alias).                                                                                                                           | <code>false</code> | 1.0.0 |
-| **`timeout`**               | <code>number</code>  | The maximum wait time in milliseconds for location updates. In Android, since version 7.1.0 of the plugin, it is also used to determine the interval of location updates for `watchPosition`.                                                                                                                   | <code>10000</code> | 1.0.0 |
-| **`maximumAge`**            | <code>number</code>  | The maximum age in milliseconds of a possible cached position that is acceptable to return                                                                                                                                                                                                                      | <code>0</code>     | 1.0.0 |
-| **`minimumUpdateInterval`** | <code>number</code>  | The minumum update interval for location updates. If location updates are available faster than this interval then an update will only occur if the minimum update interval has expired since the last location update. This parameter is only available for Android. It has no effect on iOS or Web platforms. | <code>5000</code>  | 6.1.0 |
+| Prop                         | Type                 | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | Default            | Since |
+| ---------------------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ | ----- |
+| **`enableHighAccuracy`**     | <code>boolean</code> | High accuracy mode (such as GPS, if available) On Android 12+ devices it will be ignored if users didn't grant ACCESS_FINE_LOCATION permissions (can be checked with location alias).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | <code>false</code> | 1.0.0 |
+| **`timeout`**                | <code>number</code>  | The maximum wait time in milliseconds for location updates. In Android, since version 7.1.0 of the plugin, it is also used to determine the interval of location updates for `watchPosition`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | <code>10000</code> | 1.0.0 |
+| **`maximumAge`**             | <code>number</code>  | The maximum age in milliseconds of a possible cached position that is acceptable to return                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | <code>0</code>     | 1.0.0 |
+| **`minimumUpdateInterval`**  | <code>number</code>  | The minumum update interval for location updates. If location updates are available faster than this interval then an update will only occur if the minimum update interval has expired since the last location update. This parameter is only available for Android. It has no effect on iOS or Web platforms.                                                                                                                                                                                                                                                                                                                                                                                  | <code>5000</code>  | 6.1.0 |
+| **`enableLocationFallback`** | <code>boolean</code> | This option applies to Android only. Whether to fall back to the Android framework's `LocationManager` in case Google Play Service's location settings checks fail. This can happen for multiple reasons - e.g. device has no Play Services or device has no network connection (Airplane Mode) If set to `false`, failures are propagated to the caller. Note that `LocationManager` may not be as effective as Google Play Services implementation. If the device's in airplane mode, only the GPS provider is used, which may take longer to return a location, depending on GPS signal. This means that to receive location in such circumstances, you may need to provide a higher timeout. | <code>true</code>  | 8.0.0 |
 
 
 #### ClearWatchOptions
@@ -237,10 +238,11 @@ The following table list all the plugin errors:
 | OS-PLUG-GLOC-0007 | Android, iOS | Location services are not enabled. |
 | OS-PLUG-GLOC-0008 | iOS          | Application's use of location services was restricted. |
 | OS-PLUG-GLOC-0009 | Android      | Request to enable location was denied. |
-| OS-PLUG-GLOC-0010 | Android      | Could not obtain location in time. Try with a higher timeout. |
+| OS-PLUG-GLOC-0010 | Android, iOS | Could not obtain location in time. Try with a higher timeout. |
 | OS-PLUG-GLOC-0011 | Android      | Timeout needs to be a positive value. |
 | OS-PLUG-GLOC-0012 | Android      | WatchId not found. |
 | OS-PLUG-GLOC-0013 | Android      | WatchId needs to be provided. |
 | OS-PLUG-GLOC-0014 | Android      | Google Play Services error user resolvable. |
 | OS-PLUG-GLOC-0015 | Android      | Google Play Services error. |
 | OS-PLUG-GLOC-0016 | Android      | Location settings error. |
+| OS-PLUG-GLOC-0017 | Android      | Unable to retrieve location because device has both Network and Location turned off. |

package/android/build.gradle

@@ -58,7 +58,7 @@ repositories {
 
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
-    implementation("io.ionic.libs:iongeolocation-android:1.0.0")
+    implementation("io.ionic.libs:iongeolocation-android:2.0.0")
     implementation project(':capacitor-android')
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
 

package/android/src/main/kotlin/com/capacitorjs/plugins/geolocation/GeolocationErrors.kt

@@ -68,4 +68,9 @@ object GeolocationErrors {
         code = formatErrorCode(16),
         message = "Location settings error."
     )
+
+    val NETWORK_LOCATION_DISABLED_ERROR = ErrorInfo(
+        code = formatErrorCode(17),
+        message = "Unable to retrieve location because device has both Network and Location turned off."
+    )
 }

package/android/src/main/kotlin/com/capacitorjs/plugins/geolocation/GeolocationPlugin.kt

@@ -54,11 +54,7 @@ class GeolocationPlugin : Plugin() {
             }
         }
 
-        this.controller = IONGLOCController(
-            LocationServices.getFusedLocationProviderClient(context),
-            activityLauncher
-        )
-
+        this.controller = IONGLOCController(context, activityLauncher)
     }
 
     override fun handleOnDestroy() {
@@ -82,7 +78,7 @@ class GeolocationPlugin : Plugin() {
      * @param onLocationEnabled lambda function to use in case location services are enabled
      */
     private fun checkLocationState(call: PluginCall, onLocationEnabled: () -> Unit) {
-        if (controller.areLocationServicesEnabled(context)) {
+        if (controller.areLocationServicesEnabled()) {
             onLocationEnabled()
         } else {
             call.sendError(GeolocationErrors.LOCATION_DISABLED)
@@ -279,6 +275,9 @@ class GeolocationPlugin : Plugin() {
             is IONGLOCException.IONGLOCSettingsException -> {
                 call.sendError(GeolocationErrors.LOCATION_SETTINGS_ERROR)
             }
+            is IONGLOCException.IONGLOCLocationAndNetworkDisabledException -> {
+                call.sendError(GeolocationErrors.NETWORK_LOCATION_DISABLED_ERROR)
+            }
             is IONGLOCException.IONGLOCInvalidTimeoutException -> {
                 call.sendError(GeolocationErrors.INVALID_TIMEOUT)
             }
@@ -330,8 +329,15 @@ class GeolocationPlugin : Plugin() {
         val maximumAge = call.getNumber("maximumAge", 0)
         val enableHighAccuracy = call.getBoolean("enableHighAccuracy", false) ?: false
         val minimumUpdateInterval = call.getNumber("minimumUpdateInterval", 5000)
-
-        val locationOptions = IONGLOCLocationOptions(timeout, maximumAge, enableHighAccuracy, minimumUpdateInterval)
+        val enableLocationFallback = call.getBoolean("enableLocationFallback", true) ?: true
+
+        val locationOptions = IONGLOCLocationOptions(
+            timeout,
+            maximumAge,
+            enableHighAccuracy,
+            enableLocationFallback,
+            minimumUpdateInterval
+        )
 
         return locationOptions
     }

package/dist/docs.json

@@ -230,6 +230,22 @@
           "docs": "The minumum update interval for location updates.\n\nIf location updates are available faster than this interval then an update\nwill only occur if the minimum update interval has expired since the last location update.\n\nThis parameter is only available for Android. It has no effect on iOS or Web platforms.",
           "complexTypes": [],
           "type": "number | undefined"
+        },
+        {
+          "name": "enableLocationFallback",
+          "tags": [
+            {
+              "text": "true",
+              "name": "default"
+            },
+            {
+              "text": "8.0.0",
+              "name": "since"
+            }
+          ],
+          "docs": "This option applies to Android only.\n\nWhether to fall back to the Android framework's `LocationManager` in case Google Play Service's location settings checks fail.\nThis can happen for multiple reasons - e.g. device has no Play Services or device has no network connection (Airplane Mode)\nIf set to `false`, failures are propagated to the caller.\nNote that `LocationManager` may not be as effective as Google Play Services implementation.\nIf the device's in airplane mode, only the GPS provider is used, which may take longer to return a location, depending on GPS signal.\nThis means that to receive location in such circumstances, you may need to provide a higher timeout.",
+          "complexTypes": [],
+          "type": "boolean | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -168,6 +168,20 @@ export interface PositionOptions {
      * @since 6.1.0
      */
     minimumUpdateInterval?: number;
+    /**
+     * This option applies to Android only.
+     *
+     * Whether to fall back to the Android framework's `LocationManager` in case Google Play Service's location settings checks fail.
+     * This can happen for multiple reasons - e.g. device has no Play Services or device has no network connection (Airplane Mode)
+     * If set to `false`, failures are propagated to the caller.
+     * Note that `LocationManager` may not be as effective as Google Play Services implementation.
+     * If the device's in airplane mode, only the GPS provider is used, which may take longer to return a location, depending on GPS signal.
+     * This means that to receive location in such circumstances, you may need to provide a higher timeout.
+     *
+     * @default true
+     * @since 8.0.0
+     */
+    enableLocationFallback?: boolean;
 }
 export type WatchPositionCallback = (position: Position | null, err?: any) => void;
 /**

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PermissionState } from '@capacitor/core';\n\nexport type CallbackID = string;\n\nexport interface PermissionStatus {\n  /**\n   * Permission state for location alias.\n   *\n   * On Android it requests/checks both ACCESS_COARSE_LOCATION and\n   * ACCESS_FINE_LOCATION permissions.\n   *\n   * On iOS and web it requests/checks location permission.\n   *\n   * @since 1.0.0\n   */\n  location: PermissionState;\n\n  /**\n   * Permission state for coarseLocation alias.\n   *\n   * On Android it requests/checks ACCESS_COARSE_LOCATION.\n   *\n   * On Android 12+, users can choose between Approximate location (ACCESS_COARSE_LOCATION) or\n   * Precise location (ACCESS_FINE_LOCATION), so this alias can be used if the app doesn't\n   * need high accuracy.\n   *\n   * On iOS and web it will have the same value as location alias.\n   *\n   * @since 1.2.0\n   */\n  coarseLocation: PermissionState;\n}\n\nexport type GeolocationPermissionType = 'location' | 'coarseLocation';\n\nexport interface GeolocationPluginPermissions {\n  permissions: GeolocationPermissionType[];\n}\n\nexport interface GeolocationPlugin {\n  /**\n   * Get the current GPS location of the device\n   *\n   * @since 1.0.0\n   */\n  getCurrentPosition(options?: PositionOptions): Promise<Position>;\n\n  /**\n   * Set up a watch for location changes. Note that watching for location changes\n   * can consume a large amount of energy. Be smart about listening only when you need to.\n   *\n   * @since 1.0.0\n   */\n  watchPosition(options: PositionOptions, callback: WatchPositionCallback): Promise<CallbackID>;\n\n  /**\n   * Clear a given watch\n   *\n   * @since 1.0.0\n   */\n  clearWatch(options: ClearWatchOptions): Promise<void>;\n\n  /**\n   * Check location permissions.  Will throw if system location services are disabled.\n   *\n   * @since 1.0.0\n   */\n  checkPermissions(): Promise<PermissionStatus>;\n\n  /**\n   * Request location permissions.  Will throw if system location services are disabled.\n   *\n   * Not available on web.\n   *\n   * @since 1.0.0\n   */\n  requestPermissions(permissions?: GeolocationPluginPermissions): Promise<PermissionStatus>;\n}\n\nexport interface ClearWatchOptions {\n  id: CallbackID;\n}\n\nexport interface Position {\n  /**\n   * Creation timestamp for coords\n   *\n   * @since 1.0.0\n   */\n  timestamp: number;\n\n  /**\n   * The GPS coordinates along with the accuracy of the data\n   *\n   * @since 1.0.0\n   */\n  coords: {\n    /**\n     * Latitude in decimal degrees\n     *\n     * @since 1.0.0\n     */\n    latitude: number;\n\n    /**\n     * longitude in decimal degrees\n     *\n     * @since 1.0.0\n     */\n    longitude: number;\n\n    /**\n     * Accuracy level of the latitude and longitude coordinates in meters\n     *\n     * @since 1.0.0\n     */\n    accuracy: number;\n\n    /**\n     * Accuracy level of the altitude coordinate in meters, if available.\n     *\n     * Available on all iOS versions and on Android 8.0+.\n     *\n     * @since 1.0.0\n     */\n    altitudeAccuracy: number | null | undefined;\n\n    /**\n     * The altitude the user is at (if available)\n     *\n     * @since 1.0.0\n     */\n    altitude: number | null;\n\n    /**\n     * The speed the user is traveling (if available)\n     *\n     * @since 1.0.0\n     */\n    speed: number | null;\n\n    /**\n     * The heading the user is facing (if available)\n     *\n     * @since 1.0.0\n     */\n    heading: number | null;\n  };\n}\n\nexport interface PositionOptions {\n  /**\n   * High accuracy mode (such as GPS, if available)\n   *\n   * On Android 12+ devices it will be ignored if users didn't grant\n   * ACCESS_FINE_LOCATION permissions (can be checked with location alias).\n   *\n   * @default false\n   * @since 1.0.0\n   */\n  enableHighAccuracy?: boolean;\n\n  /**\n   * The maximum wait time in milliseconds for location updates.\n   *\n   * In Android, since version 7.1.0 of the plugin, it is also used to determine the\n   * interval of location updates for `watchPosition`.\n   *\n   * @default 10000\n   * @since 1.0.0\n   */\n  timeout?: number;\n\n  /**\n   * The maximum age in milliseconds of a possible cached position that is acceptable to return\n   *\n   * @default 0\n   * @since 1.0.0\n   */\n  maximumAge?: number;\n\n  /**\n   * The minumum update interval for location updates.\n   *\n   * If location updates are available faster than this interval then an update\n   * will only occur if the minimum update interval has expired since the last location update.\n   *\n   * This parameter is only available for Android. It has no effect on iOS or Web platforms.\n   *\n   * @default 5000\n   * @since 6.1.0\n   */\n  minimumUpdateInterval?: number;\n}\n\nexport type WatchPositionCallback = (position: Position | null, err?: any) => void;\n\n/**\n * @deprecated Use `PositionOptions`.\n * @since 1.0.0\n */\nexport type GeolocationOptions = PositionOptions;\n\n/**\n * @deprecated Use `WatchPositionCallback`.\n * @since 1.0.0\n */\nexport type GeolocationWatchCallback = WatchPositionCallback;\n\n/**\n * @deprecated Use `Position`.\n * @since 1.0.0\n */\nexport type GeolocationPosition = Position;\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PermissionState } from '@capacitor/core';\n\nexport type CallbackID = string;\n\nexport interface PermissionStatus {\n  /**\n   * Permission state for location alias.\n   *\n   * On Android it requests/checks both ACCESS_COARSE_LOCATION and\n   * ACCESS_FINE_LOCATION permissions.\n   *\n   * On iOS and web it requests/checks location permission.\n   *\n   * @since 1.0.0\n   */\n  location: PermissionState;\n\n  /**\n   * Permission state for coarseLocation alias.\n   *\n   * On Android it requests/checks ACCESS_COARSE_LOCATION.\n   *\n   * On Android 12+, users can choose between Approximate location (ACCESS_COARSE_LOCATION) or\n   * Precise location (ACCESS_FINE_LOCATION), so this alias can be used if the app doesn't\n   * need high accuracy.\n   *\n   * On iOS and web it will have the same value as location alias.\n   *\n   * @since 1.2.0\n   */\n  coarseLocation: PermissionState;\n}\n\nexport type GeolocationPermissionType = 'location' | 'coarseLocation';\n\nexport interface GeolocationPluginPermissions {\n  permissions: GeolocationPermissionType[];\n}\n\nexport interface GeolocationPlugin {\n  /**\n   * Get the current GPS location of the device\n   *\n   * @since 1.0.0\n   */\n  getCurrentPosition(options?: PositionOptions): Promise<Position>;\n\n  /**\n   * Set up a watch for location changes. Note that watching for location changes\n   * can consume a large amount of energy. Be smart about listening only when you need to.\n   *\n   * @since 1.0.0\n   */\n  watchPosition(options: PositionOptions, callback: WatchPositionCallback): Promise<CallbackID>;\n\n  /**\n   * Clear a given watch\n   *\n   * @since 1.0.0\n   */\n  clearWatch(options: ClearWatchOptions): Promise<void>;\n\n  /**\n   * Check location permissions.  Will throw if system location services are disabled.\n   *\n   * @since 1.0.0\n   */\n  checkPermissions(): Promise<PermissionStatus>;\n\n  /**\n   * Request location permissions.  Will throw if system location services are disabled.\n   *\n   * Not available on web.\n   *\n   * @since 1.0.0\n   */\n  requestPermissions(permissions?: GeolocationPluginPermissions): Promise<PermissionStatus>;\n}\n\nexport interface ClearWatchOptions {\n  id: CallbackID;\n}\n\nexport interface Position {\n  /**\n   * Creation timestamp for coords\n   *\n   * @since 1.0.0\n   */\n  timestamp: number;\n\n  /**\n   * The GPS coordinates along with the accuracy of the data\n   *\n   * @since 1.0.0\n   */\n  coords: {\n    /**\n     * Latitude in decimal degrees\n     *\n     * @since 1.0.0\n     */\n    latitude: number;\n\n    /**\n     * longitude in decimal degrees\n     *\n     * @since 1.0.0\n     */\n    longitude: number;\n\n    /**\n     * Accuracy level of the latitude and longitude coordinates in meters\n     *\n     * @since 1.0.0\n     */\n    accuracy: number;\n\n    /**\n     * Accuracy level of the altitude coordinate in meters, if available.\n     *\n     * Available on all iOS versions and on Android 8.0+.\n     *\n     * @since 1.0.0\n     */\n    altitudeAccuracy: number | null | undefined;\n\n    /**\n     * The altitude the user is at (if available)\n     *\n     * @since 1.0.0\n     */\n    altitude: number | null;\n\n    /**\n     * The speed the user is traveling (if available)\n     *\n     * @since 1.0.0\n     */\n    speed: number | null;\n\n    /**\n     * The heading the user is facing (if available)\n     *\n     * @since 1.0.0\n     */\n    heading: number | null;\n  };\n}\n\nexport interface PositionOptions {\n  /**\n   * High accuracy mode (such as GPS, if available)\n   *\n   * On Android 12+ devices it will be ignored if users didn't grant\n   * ACCESS_FINE_LOCATION permissions (can be checked with location alias).\n   *\n   * @default false\n   * @since 1.0.0\n   */\n  enableHighAccuracy?: boolean;\n\n  /**\n   * The maximum wait time in milliseconds for location updates.\n   *\n   * In Android, since version 7.1.0 of the plugin, it is also used to determine the\n   * interval of location updates for `watchPosition`.\n   *\n   * @default 10000\n   * @since 1.0.0\n   */\n  timeout?: number;\n\n  /**\n   * The maximum age in milliseconds of a possible cached position that is acceptable to return\n   *\n   * @default 0\n   * @since 1.0.0\n   */\n  maximumAge?: number;\n\n  /**\n   * The minumum update interval for location updates.\n   *\n   * If location updates are available faster than this interval then an update\n   * will only occur if the minimum update interval has expired since the last location update.\n   *\n   * This parameter is only available for Android. It has no effect on iOS or Web platforms.\n   *\n   * @default 5000\n   * @since 6.1.0\n   */\n  minimumUpdateInterval?: number;\n\n  /**\n   * This option applies to Android only.\n   *\n   * Whether to fall back to the Android framework's `LocationManager` in case Google Play Service's location settings checks fail.\n   * This can happen for multiple reasons - e.g. device has no Play Services or device has no network connection (Airplane Mode)\n   * If set to `false`, failures are propagated to the caller.\n   * Note that `LocationManager` may not be as effective as Google Play Services implementation.\n   * If the device's in airplane mode, only the GPS provider is used, which may take longer to return a location, depending on GPS signal.\n   * This means that to receive location in such circumstances, you may need to provide a higher timeout.\n   *\n   * @default true\n   * @since 8.0.0\n   */\n  enableLocationFallback?: boolean;\n}\n\nexport type WatchPositionCallback = (position: Position | null, err?: any) => void;\n\n/**\n * @deprecated Use `PositionOptions`.\n * @since 1.0.0\n */\nexport type GeolocationOptions = PositionOptions;\n\n/**\n * @deprecated Use `WatchPositionCallback`.\n * @since 1.0.0\n */\nexport type GeolocationWatchCallback = WatchPositionCallback;\n\n/**\n * @deprecated Use `Position`.\n * @since 1.0.0\n */\nexport type GeolocationPosition = Position;\n"]}

package/ios/Sources/GeolocationPlugin/GeolocationCallbackManager.swift

@@ -24,6 +24,7 @@ final class GeolocationCallbackManager {
     private(set) var requestPermissionsCallbacks: [CAPPluginCall]
     private(set) var locationCallbacks: [CAPPluginCall]
     private(set) var watchCallbacks: [String: CAPPluginCall]
+    private(set) var timeout: Int?
     private let capacitorBridge: CAPBridgeProtocol?
 
     private var allCallbackGroups: [GeolocationCallbackGroup] {
@@ -52,11 +53,15 @@ final class GeolocationCallbackManager {
     func addLocationCallback(capacitorCall call: CAPPluginCall) {
         capacitorBridge?.saveCall(call)
         locationCallbacks.append(call)
+        let timeout = call.getInt(Constants.Arguments.timeout)
+        self.timeout = timeout
     }
 
     func addWatchCallback(_ watchId: String, capacitorCall call: CAPPluginCall) {
         capacitorBridge?.saveCall(call)
         watchCallbacks[watchId] = call
+        let timeout = call.getInt(Constants.Arguments.timeout)
+        self.timeout = timeout
     }
 
     func clearRequestPermissionsCallbacks() {
@@ -109,6 +114,10 @@ final class GeolocationCallbackManager {
 
     func sendError(_ error: GeolocationError) {
         createPluginResult(status: .error(error.toCodeMessagePair()))
+
+        if case .timeout = error {
+            watchCallbacks.keys.forEach { clearWatchCallbackIfExists($0) }
+        }
     }
 }
 

package/ios/Sources/GeolocationPlugin/GeolocationConstants.swift

@@ -2,6 +2,7 @@ enum Constants {
     enum Arguments {
         static let enableHighAccuracy = "enableHighAccuracy"
         static let id = "id"
+        static let timeout = "timeout"
     }
 
     enum AuthorisationStatus {

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,16 +30,18 @@ private extension GeolocationError {
             case .watchPosition: 5
             case .clearWatch: 6
             }
+        case .timeout: 10
         }
     }
 
     var description: String {
         switch self {
-        case .positionUnavailable: "There was en error trying to obtain the location."
+        case .positionUnavailable: "There was an error trying to obtain the location."
         case .permissionDenied: "Location permission request was denied."
         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,7 +1,6 @@
 import Capacitor
 import IONGeolocationLib
 import UIKit
-
 import Combine
 
 @objc(GeolocationPlugin)
@@ -19,6 +18,7 @@ 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
@@ -26,7 +26,7 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
     override public func load() {
         self.locationService = IONGLOCManagerWrapper()
         self.callbackManager = .init(capacitorBridge: bridge)
-        
+
         NotificationCenter.default.addObserver(
             self,
             selector: #selector(appDidBecomeActive),
@@ -40,8 +40,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()
@@ -77,6 +79,8 @@ public class GeolocationPlugin: CAPPlugin, CAPBridgedPlugin {
             locationService?.stopMonitoringLocation()
             locationCancellable?.cancel()
             locationCancellable = nil
+            timeoutCancellable?.cancel()
+            timeoutCancellable = nil
             locationInitialized = false
         }
 
@@ -145,7 +149,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 +164,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,10 +213,10 @@ private extension GeolocationPlugin {
             callbackManager?.sendRequestPermissionsSuccess(Constants.AuthorisationStatus.Status.granted)
         }
         if shouldRequestCurrentPosition {
-            locationService?.requestSingleLocation()
+            locationService?.requestSingleLocation(options: IONGLOCRequestOptionsModel(timeout: callbackManager?.timeout))
         }
         if shouldRequestLocationMonitoring {
-            locationService?.startMonitoringLocation()
+            locationService?.startMonitoringLocation(options: IONGLOCRequestOptionsModel(timeout: callbackManager?.timeout))
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/geolocation",
-  "version": "8.0.0-next.2",
+  "version": "8.0.0-next.4",
   "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",
@@ -59,15 +59,15 @@
     "@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",
+    "@semantic-release/github": "^12.0.0",
+    "@semantic-release/npm": "^13.1.1",
     "@types/node": "^20.14.8",
     "eslint": "^8.57.0",
     "prettier": "^3.3.3",
     "prettier-plugin-java": "^2.6.4",
     "rimraf": "^6.0.1",
     "rollup": "^2.78.1",
-    "semantic-release": "^24.0.0",
+    "semantic-release": "^25.0.1",
     "swiftlint": "^2.0.0",
     "typescript": "~5.4.5"
   },