@capacitor/geolocation 7.1.5-dev.5 → 7.1.5-dev.7

package/CapacitorGeolocation.podspec

@@ -11,8 +11,8 @@ Pod::Spec.new do |s|
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
   s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
-  s.ios.deployment_target = '14.0'
+  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

@@ -3,7 +3,7 @@ import PackageDescription
 
 let package = Package(
     name: "CapacitorGeolocation",
-    platforms: [.iOS(.v14)],
+    platforms: [.iOS(.v15)],
     products: [
         .library(
             name: "CapacitorGeolocation",
@@ -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

@@ -23,10 +23,10 @@ apply plugin: 'kotlin-android'
 
 android {
     namespace "com.capacitorjs.plugins.geolocation"
-    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
     defaultConfig {
-        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
-        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
@@ -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

@@ -1,5 +1,5 @@
 import Capacitor
-//import IONGeolocationLib
+import IONGeolocationLib
 
 private enum GeolocationCallbackType {
     case requestPermissions
@@ -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() {

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/GeolocationPlugin.swift

@@ -1,5 +1,5 @@
 import Capacitor
-// import IONGeolocationLib
+import IONGeolocationLib
 import UIKit
 import Combine
 
@@ -58,7 +58,6 @@ 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)
     }
 
@@ -66,7 +65,6 @@ 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)
     }
 
@@ -216,10 +214,10 @@ private extension GeolocationPlugin {
             callbackManager?.sendRequestPermissionsSuccess(Constants.AuthorisationStatus.Status.granted)
         }
         if shouldRequestCurrentPosition {
-            locationService?.requestSingleLocation(options: IONGLOCRequestOptionsModel(timeout: self.timeout))
+            locationService?.requestSingleLocation(options: IONGLOCRequestOptionsModel(timeout: callbackManager?.timeout))
         }
         if shouldRequestLocationMonitoring {
-            locationService?.startMonitoringLocation(options: IONGLOCRequestOptionsModel(timeout: self.timeout))
+            locationService?.startMonitoringLocation(options: IONGLOCRequestOptionsModel(timeout: callbackManager?.timeout))
         }
     }
 

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/geolocation",
-  "version": "7.1.5-dev.5",
+  "version": "7.1.5-dev.7",
   "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",
@@ -46,7 +46,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@capacitor/synapse": "^1.0.3"
+    "@capacitor/synapse": "^1.0.4"
   },
   "devDependencies": {
     "@capacitor/android": "next",
@@ -72,7 +72,7 @@
     "typescript": "~5.4.5"
   },
   "peerDependencies": {
-    "@capacitor/core": ">=7.0.0"
+    "@capacitor/core": ">=8.0.0-alpha.2"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",

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

@@ -1,26 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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/IONGLOCRequestOptionsModel.swift

@@ -1,9 +0,0 @@
-import Foundation
-
-public struct IONGLOCRequestOptionsModel {
-    let timeout: Int
-
-    public init(timeout: Int? = nil) {
-        self.timeout = timeout ?? 5000
-    }
-}

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

@@ -1,45 +0,0 @@
-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(options: IONGLOCRequestOptionsModel)
-}
-
-public protocol IONGLOCMonitorLocationHandler: IONGLOCLocationHandler {
-    func startMonitoringLocation(options: IONGLOCRequestOptionsModel)
-    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

@@ -1,152 +0,0 @@
-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
-
-    // Flag used to indicate that the location request has timed out.
-    // When `true`, the wrapper ignores any location updates received from CLLocationManager.
-    // This prevents "stale" or "ghost" events from being sent to subscribers after the timeout has occurred.
-    private var timeoutTriggered = 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(options: IONGLOCRequestOptionsModel) {
-        timeoutTriggered = false
-        isMonitoringLocation = true
-        locationManager.startUpdatingLocation()
-        self.startTimer(timeout: options.timeout)
-    }
-    
-    public func startMonitoringLocation() {
-        guard !timeoutTriggered else {
-            return
-        }
-        
-        isMonitoringLocation = true
-        locationManager.startUpdatingLocation()
-    }
-
-    public func stopMonitoringLocation() {
-        isMonitoringLocation = false
-        locationManager.stopUpdatingLocation()
-    }
-    
-    public func requestSingleLocation(options: IONGLOCRequestOptionsModel) {
-        timeoutTriggered = false
-        // 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.locationManager.requestLocation()
-        self.startTimer(timeout: options.timeout)
-    }
-    
-    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.timeoutTriggered = true
-                self.locationTimeoutSubject.send(.timeout)
-                
-                if self.isMonitoringLocation {
-                    self.isMonitoringLocation = false
-                    self.stopMonitoringLocation()
-                }
-                
-                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]) {
-        guard !timeoutTriggered else {
-            return
-        }
-     
-        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
-    }
-}