cordova.plugins.diagnostic 7.2.9 → 7.2.10

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # CHANGELOG
 
+**v7.2.10**
+(ios) feat: support optional specification of desired location accuracy when requesting location accuracy permission.
+
 **v7.2.9**
 (ios) crashfix: Refactored local-network permission flow to use one deterministic start path with guarded callback handling:
 - Consolidated duplicated browse/publish start logic into a single helper used by both status and authorisation APIs.

package/README.md

@@ -639,17 +639,17 @@ App can never ask for permission again.
 The only way around this is to instruct the user to manually change the permission in Settings.
 - `RESTRICTED` - Permission is unavailable and user cannot enable it.
 For example, when parental controls are in effect for the current user.
-- `GRANTED` - User granted access to this permission.
-For location permission, this indicates the user has granted access to the permission "always" (when app is both in foreground and background).
-- `GRANTED_WHEN_IN_USE` - Used only for location permission.
-Indicates the user has granted access to the permission "when in use" (only when the app is in the foreground).
-
-Addtionally, for notifications permissions:
-- `PROVISIONAL` - The app is provisionally authorized to post non-interruptive user notifications.
-- `EPHEMERAL` - The app is authorized to schedule or receive notifications for a limited amount of time.
-
-For cases where the platform cannot return a definitive answer, the plugin also exposes:
-- `UNKNOWN` (Android and iOS) - Returned when the underlying OS has not yet provided a concrete status (for example, if an iOS Local Network probe timed out). Treat this as a transient state and retry before surfacing a denial to the user.
+- `GRANTED` - User granted access to this permission.
+For location permission, this indicates the user has granted access to the permission "always" (when app is both in foreground and background).
+- `GRANTED_WHEN_IN_USE` - Used only for location permission.
+Indicates the user has granted access to the permission "when in use" (only when the app is in the foreground).
+
+Addtionally, for notifications permissions:
+- `PROVISIONAL` - The app is provisionally authorized to post non-interruptive user notifications.
+- `EPHEMERAL` - The app is authorized to schedule or receive notifications for a limited amount of time.
+
+For cases where the platform cannot return a definitive answer, the plugin also exposes:
+- `UNKNOWN` (Android and iOS) - Returned when the underlying OS has not yet provided a concrete status (for example, if an iOS Local Network probe timed out). Treat this as a transient state and retry before surfacing a denial to the user.
 
 #### Example
 
@@ -1411,6 +1411,7 @@ Platforms: Android & iOS
 
 - Defines constants for the various location accuracy authorization states on iOS 14+ and Android 12+.
 - See [CLAccuracyAuthorization](https://developer.apple.com/documentation/corelocation/claccuracyauthorization) for iOS 14+ and [approximate location](https://developer.android.com/training/location/permissions#approximate-request) for Android 12+
+- On iOS, these values can also be passed to `requestLocationAuthorization()` to set the desired [CLLocationAccuracy](https://developer.apple.com/documentation/corelocation/cllocationaccuracy).
 
 ```
 cordova.plugins.diagnostic.locationAccuracyAuthorization
@@ -1418,8 +1419,14 @@ cordova.plugins.diagnostic.locationAccuracyAuthorization
 
 #### Values
 
-- `FULL` - The user authorized the app to access location data with full accuracy.
-- `REDUCED` - The user authorized the app to access location data with reduced accuracy.
+- `FULL` - The user authorized the app to access location data with full accuracy. Alias for `BEST`. On iOS, sets `kCLLocationAccuracyBest`.
+- `REDUCED` - The user authorized the app to access location data with reduced accuracy. On iOS, sets `kCLLocationAccuracyReduced` - approximate location preserving region/city, typically within 1-20km, no GPS hardware engagement.
+- `BEST` - On iOS, sets `kCLLocationAccuracyBest`. May engage GPS hardware.
+- `BEST_FOR_NAVIGATION` - On iOS, sets `kCLLocationAccuracyBestForNavigation`. Highest accuracy using additional sensor data.
+- `NEAREST_TEN_METERS` - On iOS, sets `kCLLocationAccuracyNearestTenMeters`.
+- `HUNDRED_METERS` - On iOS, sets `kCLLocationAccuracyHundredMeters`.
+- `KILOMETER` - On iOS, sets `kCLLocationAccuracyKilometer`.
+- `THREE_KILOMETERS` - On iOS, sets `kCLLocationAccuracyThreeKilometers`.
 
 
 ### isLocationAvailable()
@@ -1821,6 +1828,16 @@ Notes for Android:
 - When the plugin is running on/built with Android 12+ / API 31+, you can specify requested location accuracy using the `accuracy` parameter.
     - If the build SDK/device version is <= Android 11 / API 30, `FULL` accuracy is implicitly granted.
 
+On iOS, the `accuracy` parameter sets the `desiredAccuracy` of the internal `CLLocationManager` used by the plugin:
+- `FULL` / `BEST` (default) - sets `kCLLocationAccuracyBest`, which may engage GPS hardware.
+- `REDUCED` - sets `kCLLocationAccuracyReduced`, providing approximate location (typically within 1-20km) without engaging GPS hardware.
+- `BEST_FOR_NAVIGATION` - sets `kCLLocationAccuracyBestForNavigation`, the highest accuracy using additional sensor data.
+- `NEAREST_TEN_METERS` - sets `kCLLocationAccuracyNearestTenMeters`.
+- `HUNDRED_METERS` - sets `kCLLocationAccuracyHundredMeters`.
+- `KILOMETER` - sets `kCLLocationAccuracyKilometer`.
+- `THREE_KILOMETERS` - sets `kCLLocationAccuracyThreeKilometers`.
+- Apps that only need the location permission for non-location purposes (e.g. to access the Wi-Fi SSID) should use `REDUCED` to avoid unnecessary battery drain.
+
 ```
 cordova.plugins.diagnostic.requestLocationAuthorization(successCallback, errorCallback, mode, accuracy);
 ```
@@ -1833,9 +1850,10 @@ cordova.plugins.diagnostic.requestLocationAuthorization(successCallback, errorCa
     - The function is passed a single string parameter containing the error message.
 - {String} mode - (optional / iOS & Android >= 10) location authorization mode specified as a [locationAuthorizationMode constant](#locationauthorizationmode-constants).
     - If not specified, defaults to `WHEN_IN_USE`.
-- {String} accuracy - (optional / Android 12+) requested location accuracy as a constant in `cordova.plugins.diagnostic.locationAccuracyAuthorization`
+- {String} accuracy - (optional / iOS & Android 12+) requested location accuracy as a constant in `cordova.plugins.diagnostic.locationAccuracyAuthorization`
     - If not specified, defaults to `cordova.plugins.diagnostic.locationAccuracyAuthorization.FULL`
-    - On Android <12 & iOS, has no effect.
+    - On iOS, sets the CLLocationManager's desiredAccuracy - see [locationAccuracyAuthorization constants](#locationaccuracyauthorization-constants) for the full list of available values.
+    - On Android <12, has no effect.
 
 #### Example usage
 
@@ -2458,80 +2476,80 @@ The function is passed a single string parameter containing the error message.
 
 Platforms: iOS
 
-Checks if the app is authorised to access devices on the local network (iOS 14+).
-On iOS versions prior to 14 this will always return TRUE as no local network authorization is required.
-An optional third argument allows you to override the fallback timeout (defaults to 2 seconds) by passing `{ timeoutMs: <number> }`.
+Checks if the app is authorised to access devices on the local network (iOS 14+).
+On iOS versions prior to 14 this will always return TRUE as no local network authorization is required.
+An optional third argument allows you to override the fallback timeout (defaults to 2 seconds) by passing `{ timeoutMs: <number> }`.
 
     cordova.plugins.diagnostic.isLocalNetworkAuthorized(successCallback, errorCallback);
 
-#### Parameters
-
-- {Function} successCallback - The callback which will be called when operation is successful.
-  The function is passed a single boolean parameter which is TRUE if the app is authorised to use the Local Network.
-- {Function} errorCallback - The callback which will be called when operation encounters an error.
-  The function is passed a single string parameter containing the error message.
-- {Object} [options] - Optional timeout control object. Provide `timeoutMs` (milliseconds) to override the default 2000 ms timeout.
+#### Parameters
+
+- {Function} successCallback - The callback which will be called when operation is successful.
+  The function is passed a single boolean parameter which is TRUE if the app is authorised to use the Local Network.
+- {Function} errorCallback - The callback which will be called when operation encounters an error.
+  The function is passed a single string parameter containing the error message.
+- {Object} [options] - Optional timeout control object. Provide `timeoutMs` (milliseconds) to override the default 2000 ms timeout.
 
 
 #### Example usage
 
-    cordova.plugins.diagnostic.isLocalNetworkAuthorized(function(authorized){
-        console.log("Local Network is " + (authorized ? "authorized" : "unauthorised"));
-    }, function(error){
-        console.error("The following error occurred: "+error);
-    });
-
-To wait longer before treating a slow response as indeterminate:
-
-```
-cordova.plugins.diagnostic.isLocalNetworkAuthorized(
-    function(authorized){
-        console.log("Local Network authorized? " + authorized);
-    },
-    console.error,
-    { timeoutMs: 8000 }
-);
-```
+    cordova.plugins.diagnostic.isLocalNetworkAuthorized(function(authorized){
+        console.log("Local Network is " + (authorized ? "authorized" : "unauthorised"));
+    }, function(error){
+        console.error("The following error occurred: "+error);
+    });
+
+To wait longer before treating a slow response as indeterminate:
+
+```
+cordova.plugins.diagnostic.isLocalNetworkAuthorized(
+    function(authorized){
+        console.log("Local Network authorized? " + authorized);
+    },
+    console.error,
+    { timeoutMs: 8000 }
+);
+```
 
 ### getLocalNetworkAuthorizationStatus()
 
 Platforms: iOS
 
-Returns the app's Local Network authorization status.
-On iOS 14+ this returns one of the values in `cordova.plugins.diagnostic.permissionStatus`: `NOT_REQUESTED`, `GRANTED`, `DENIED_ALWAYS`, `UNKNOWN`.
-`UNKNOWN` indicates that iOS did not return a definitive answer before the timeout elapsed, so the app can retry before warning the user.
-On iOS versions prior to 14 this will always return `GRANTED` as no authorization is required.
+Returns the app's Local Network authorization status.
+On iOS 14+ this returns one of the values in `cordova.plugins.diagnostic.permissionStatus`: `NOT_REQUESTED`, `GRANTED`, `DENIED_ALWAYS`, `UNKNOWN`.
+`UNKNOWN` indicates that iOS did not return a definitive answer before the timeout elapsed, so the app can retry before warning the user.
+On iOS versions prior to 14 this will always return `GRANTED` as no authorization is required.
 
     cordova.plugins.diagnostic.getLocalNetworkAuthorizationStatus(successCallback, errorCallback);
 
 #### Parameters
 
-- {Function} successCallback - The callback which will be called when operation is successful.
-  The function is passed a single string parameter which is one of the values in `cordova.plugins.diagnostic.permissionStatus`:
-  `NOT_REQUESTED`, `GRANTED`, `DENIED_ALWAYS`, `UNKNOWN`.
-- {Function} errorCallback - The callback which will be called when operation encounters an error.
-  The function is passed a single string parameter containing the error message.
-- {Object} [options] - Optional timeout override (defaults to 2 seconds). Provide `timeoutMs` (milliseconds) to customize the fallback duration.
+- {Function} successCallback - The callback which will be called when operation is successful.
+  The function is passed a single string parameter which is one of the values in `cordova.plugins.diagnostic.permissionStatus`:
+  `NOT_REQUESTED`, `GRANTED`, `DENIED_ALWAYS`, `UNKNOWN`.
+- {Function} errorCallback - The callback which will be called when operation encounters an error.
+  The function is passed a single string parameter containing the error message.
+- {Object} [options] - Optional timeout override (defaults to 2 seconds). Provide `timeoutMs` (milliseconds) to customize the fallback duration.
 
 
 #### Example usage
 
     cordova.plugins.diagnostic.getLocalNetworkAuthorizationStatus(function(status){
-        switch(status){
-            case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
-                console.log("Local Network permission not requested");
-                break;
-            case cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS:
-                console.log("Local Network permission denied");
-                break;
-            case cordova.plugins.diagnostic.permissionStatus.UNKNOWN:
-                console.log("Local Network permission could not be determined (retry recommended)");
-                break;
-            case cordova.plugins.diagnostic.permissionStatus.GRANTED:
-                console.log("Local Network permission granted");
-                break;
-        }
-    }, function(error){
+        switch(status){
+            case cordova.plugins.diagnostic.permissionStatus.NOT_REQUESTED:
+                console.log("Local Network permission not requested");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS:
+                console.log("Local Network permission denied");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.UNKNOWN:
+                console.log("Local Network permission could not be determined (retry recommended)");
+                break;
+            case cordova.plugins.diagnostic.permissionStatus.GRANTED:
+                console.log("Local Network permission granted");
+                break;
+        }
+    }, function(error){
         console.error("The following error occurred: "+error);
     });
 
@@ -2539,34 +2557,34 @@ On iOS versions prior to 14 this will always return `GRANTED` as no authorizatio
 
 Platforms: iOS
 
-Requests the user to authorise the app to access devices on the local network (iOS 14+).
-On iOS versions prior to 14 this does nothing and will return success as no authorization is required.
-May return `UNKNOWN` if iOS does not respond before the native APIs time out, allowing the app to retry.
+Requests the user to authorise the app to access devices on the local network (iOS 14+).
+On iOS versions prior to 14 this does nothing and will return success as no authorization is required.
+May return `UNKNOWN` if iOS does not respond before the native APIs time out, allowing the app to retry.
 
     cordova.plugins.diagnostic.requestLocalNetworkAuthorization(successCallback, errorCallback);
 
 #### Parameters
 
-- {Function} successCallback - The callback which will be called when operation is successful.
-  The function is passed a single string parameter which is one of the values in `cordova.plugins.diagnostic.permissionStatus`:
-  `NOT_REQUESTED`, `GRANTED`, `DENIED_ALWAYS`, `UNKNOWN`.
+- {Function} successCallback - The callback which will be called when operation is successful.
+  The function is passed a single string parameter which is one of the values in `cordova.plugins.diagnostic.permissionStatus`:
+  `NOT_REQUESTED`, `GRANTED`, `DENIED_ALWAYS`, `UNKNOWN`.
 - {Function} errorCallback - The callback which will be called when operation encounters an error.
   The function is passed a single string parameter containing the error message.
 
 
 #### Example usage
 
-    cordova.plugins.diagnostic.requestLocalNetworkAuthorization(function(status){
-        if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
-            console.log("Local Network access granted");
-        }else if(status === cordova.plugins.diagnostic.permissionStatus.UNKNOWN){
-            console.log("Local Network status could not be determined, retrying may succeed");
-        }else{
-            console.log("Local Network access not granted: " + status);
-        }
-    }, function(error){
-        console.error("The following error occurred: "+error);
-    });
+    cordova.plugins.diagnostic.requestLocalNetworkAuthorization(function(status){
+        if(status === cordova.plugins.diagnostic.permissionStatus.GRANTED){
+            console.log("Local Network access granted");
+        }else if(status === cordova.plugins.diagnostic.permissionStatus.UNKNOWN){
+            console.log("Local Network status could not be determined, retrying may succeed");
+        }else{
+            console.log("Local Network access not granted: " + status);
+        }
+    }, function(error){
+        console.error("The following error occurred: "+error);
+    });
 
 ### setWifiState()
 

package/cordova.plugins.diagnostic.d.ts

@@ -110,8 +110,22 @@ interface Diagnostic {
      * @type {Object}
      */
     locationAccuracyAuthorization: {
+        /** Alias for BEST. Sets kCLLocationAccuracyBest on iOS. */
         "FULL": "full";
+        /** Sets kCLLocationAccuracyReduced on iOS - approximate location, no GPS. */
         "REDUCED": "reduced";
+        /** Sets kCLLocationAccuracyBest on iOS - may engage GPS hardware. */
+        "BEST": "best";
+        /** Sets kCLLocationAccuracyBestForNavigation on iOS - highest accuracy with additional sensors. */
+        "BEST_FOR_NAVIGATION": "bestForNavigation";
+        /** Sets kCLLocationAccuracyNearestTenMeters on iOS. */
+        "NEAREST_TEN_METERS": "nearestTenMeters";
+        /** Sets kCLLocationAccuracyHundredMeters on iOS. */
+        "HUNDRED_METERS": "hundredMeters";
+        /** Sets kCLLocationAccuracyKilometer on iOS. */
+        "KILOMETER": "kilometer";
+        /** Sets kCLLocationAccuracyThreeKilometers on iOS. */
+        "THREE_KILOMETERS": "threeKilometers";
     };
 
 
@@ -464,7 +478,17 @@ interface Diagnostic {
      * @param successCallback
      * @param errorCallback
      * @param mode - (optional / iOS & Android >= 10) location authorization mode specified as a locationAuthorizationMode constant. If not specified, defaults to WHEN_IN_USE.
-     * @param accuracy
+     * @param accuracy - (optional / iOS & Android 12+) desired location accuracy as a locationAccuracyAuthorization constant.
+     * If not specified, defaults to FULL.
+     * On iOS, this sets the CLLocationManager's desiredAccuracy:
+     * - FULL / BEST - kCLLocationAccuracyBest (may engage GPS hardware)
+     * - REDUCED - kCLLocationAccuracyReduced (approximate location, no GPS)
+     * - BEST_FOR_NAVIGATION - kCLLocationAccuracyBestForNavigation
+     * - NEAREST_TEN_METERS - kCLLocationAccuracyNearestTenMeters
+     * - HUNDRED_METERS - kCLLocationAccuracyHundredMeters
+     * - KILOMETER - kCLLocationAccuracyKilometer
+     * - THREE_KILOMETERS - kCLLocationAccuracyThreeKilometers
+     * On Android < 12, has no effect.
      */
     requestLocationAuthorization?: (
         successCallback: (status: string) => void,

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "7.2.9",
+    "version": "7.2.10",
     "name": "cordova.plugins.diagnostic",
     "cordova_name": "Diagnostic",
     "description": "Cordova/Phonegap plugin to check the state of Location/WiFi/Camera/Bluetooth device settings.",

package/plugin.xml

@@ -2,7 +2,7 @@
 <plugin xmlns="http://www.phonegap.com/ns/plugins/1.0"
     xmlns:android="http://schemas.android.com/apk/res/android"
     id="cordova.plugins.diagnostic"
-    version="7.2.9">
+    version="7.2.10">
 
     <name>Diagnostic</name>
     <description>Cordova/Phonegap plugin to check the state of Location/WiFi/Camera/Bluetooth device settings.</description>

package/src/ios/Diagnostic_Location.m

@@ -78,6 +78,41 @@ static NSString*const LOG_TAG = @"Diagnostic_Location[native]";
         @try {
             if ([CLLocationManager instancesRespondToSelector:@selector(requestWhenInUseAuthorization)])
             {
+                // Apply desired accuracy if specified (argument at index 1).
+                // Maps string values to CLLocationAccuracy constants.
+                // If not specified or unrecognised, defaults to kCLLocationAccuracyBest to maintain backward
+                // compatibility. Apps that do not require precise location (e.g. only need the Wi-Fi SSID)
+                // should pass "reduced" to avoid engaging GPS hardware and unnecessary battery drain.
+                NSString* accuracy = [command argumentAtIndex:1 withDefault:nil];
+                if(accuracy != nil){
+                    if([accuracy isEqualToString:@"reduced"]){
+                        self.locationManager.desiredAccuracy = kCLLocationAccuracyReduced;
+                        [diagnostic logDebug:@"Setting location accuracy: reduced"];
+                    }else if([accuracy isEqualToString:@"bestForNavigation"]){
+                        self.locationManager.desiredAccuracy = kCLLocationAccuracyBestForNavigation;
+                        [diagnostic logDebug:@"Setting location accuracy: bestForNavigation"];
+                    }else if([accuracy isEqualToString:@"nearestTenMeters"]){
+                        self.locationManager.desiredAccuracy = kCLLocationAccuracyNearestTenMeters;
+                        [diagnostic logDebug:@"Setting location accuracy: nearestTenMeters"];
+                    }else if([accuracy isEqualToString:@"hundredMeters"]){
+                        self.locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters;
+                        [diagnostic logDebug:@"Setting location accuracy: hundredMeters"];
+                    }else if([accuracy isEqualToString:@"kilometer"]){
+                        self.locationManager.desiredAccuracy = kCLLocationAccuracyKilometer;
+                        [diagnostic logDebug:@"Setting location accuracy: kilometer"];
+                    }else if([accuracy isEqualToString:@"threeKilometers"]){
+                        self.locationManager.desiredAccuracy = kCLLocationAccuracyThreeKilometers;
+                        [diagnostic logDebug:@"Setting location accuracy: threeKilometers"];
+                    }else{
+                        // "full", "best", or any unrecognised value
+                        self.locationManager.desiredAccuracy = kCLLocationAccuracyBest;
+                        [diagnostic logDebug:@"Setting location accuracy: best"];
+                    }
+                }else{
+                    self.locationManager.desiredAccuracy = kCLLocationAccuracyBest;
+                    [diagnostic logDebug:@"Setting location accuracy: best (default)"];
+                }
+
                 BOOL always = [[command argumentAtIndex:0] boolValue];
                 if(always){
                     NSAssert([[[NSBundle mainBundle] infoDictionary] valueForKey:@"NSLocationAlwaysAndWhenInUseUsageDescription"], @"Your app must have a value for NSLocationAlwaysAndWhenInUseUsageDescription in its Info.plist");

package/www/ios/diagnostic.js

@@ -371,8 +371,18 @@ var Diagnostic = (function(){
      * This callback function is passed a single string parameter containing the error message.
      * @param {String} mode - (optional) location authorization mode as a constant in `cordova.plugins.diagnostic.locationAuthorizationMode`.
      * If not specified, defaults to `cordova.plugins.diagnostic.locationAuthorizationMode.WHEN_IN_USE`.
+     * @param {String} accuracy - (optional) desired location accuracy as a constant in `cordova.plugins.diagnostic.locationAccuracyAuthorization`.
+     * If not specified, defaults to `cordova.plugins.diagnostic.locationAccuracyAuthorization.FULL`.
+     * On iOS, this sets the CLLocationManager's desiredAccuracy:
+     * - `FULL` / `BEST` - kCLLocationAccuracyBest (may engage GPS hardware)
+     * - `REDUCED` - kCLLocationAccuracyReduced (approximate location, no GPS)
+     * - `BEST_FOR_NAVIGATION` - kCLLocationAccuracyBestForNavigation (highest accuracy with additional sensors)
+     * - `NEAREST_TEN_METERS` - kCLLocationAccuracyNearestTenMeters
+     * - `HUNDRED_METERS` - kCLLocationAccuracyHundredMeters
+     * - `KILOMETER` - kCLLocationAccuracyKilometer
+     * - `THREE_KILOMETERS` - kCLLocationAccuracyThreeKilometers
      */
-    Diagnostic.requestLocationAuthorization = function(successCallback, errorCallback, mode) {
+    Diagnostic.requestLocationAuthorization = function(successCallback, errorCallback, mode, accuracy) {
         if(cordova.plugins.diagnostic.location){
             cordova.plugins.diagnostic.location.requestLocationAuthorization.apply(this, arguments);
         }else{

package/www/ios/diagnostic.location.js

@@ -29,7 +29,13 @@ var Diagnostic_Location = (function(){
 
     Diagnostic.locationAccuracyAuthorization = Diagnostic_Location.locationAccuracyAuthorization = {
         "FULL": "full",
-        "REDUCED": "reduced"
+        "REDUCED": "reduced",
+        "BEST": "best",
+        "BEST_FOR_NAVIGATION": "bestForNavigation",
+        "NEAREST_TEN_METERS": "nearestTenMeters",
+        "HUNDRED_METERS": "hundredMeters",
+        "KILOMETER": "kilometer",
+        "THREE_KILOMETERS": "threeKilometers"
     };
 
     /********************
@@ -161,13 +167,23 @@ var Diagnostic_Location = (function(){
      * This callback function is passed a single string parameter containing the error message.
      * @param {String} mode - (optional) location authorization mode as a constant in `cordova.plugins.diagnostic.locationAuthorizationMode`.
      * If not specified, defaults to `cordova.plugins.diagnostic.locationAuthorizationMode.WHEN_IN_USE`.
+     * @param {String} accuracy - (optional) desired location accuracy as a constant in `cordova.plugins.diagnostic.locationAccuracyAuthorization`.
+     * If not specified, defaults to `cordova.plugins.diagnostic.locationAccuracyAuthorization.FULL`.
+     * On iOS, this sets the CLLocationManager's desiredAccuracy:
+     * - `FULL` / `BEST` - kCLLocationAccuracyBest (may engage GPS hardware)
+     * - `REDUCED` - kCLLocationAccuracyReduced (approximate location, no GPS)
+     * - `BEST_FOR_NAVIGATION` - kCLLocationAccuracyBestForNavigation (highest accuracy with additional sensors)
+     * - `NEAREST_TEN_METERS` - kCLLocationAccuracyNearestTenMeters
+     * - `HUNDRED_METERS` - kCLLocationAccuracyHundredMeters
+     * - `KILOMETER` - kCLLocationAccuracyKilometer
+     * - `THREE_KILOMETERS` - kCLLocationAccuracyThreeKilometers
      */
-    Diagnostic_Location.requestLocationAuthorization = function(successCallback, errorCallback, mode) {
+    Diagnostic_Location.requestLocationAuthorization = function(successCallback, errorCallback, mode, accuracy) {
         return cordova.exec(successCallback,
             errorCallback,
             'Diagnostic_Location',
             'requestLocationAuthorization',
-            [mode && mode === Diagnostic_Location.locationAuthorizationMode.ALWAYS]);
+            [mode && mode === Diagnostic_Location.locationAuthorizationMode.ALWAYS, accuracy]);
     };
 
     /**