cordova.plugins.diagnostic 7.2.5 → 7.2.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+**v7.2.7**
+(ios) bugfix: Handle DNS PolicyDenied like EPERM for local network permission detection
+
+**v7.2.6**
+* (ios) fix: Local Network status check now accepts a configurable timeout, detects permission denials via NWBrowser errors/NSNetService failures, and returns `UNKNOWN` instead of `DENIED_ALWAYS` when the probe times out. This works around an issue where, if the network stack is under load, local network permission may be falsely reported as denied because iOS fails to resolve the Bonjour service within the default timeout period.
+
 **v7.2.5**
 * (ios) feat: add check/request local network authorization to Wifi module
   * Resolves [#524](https://github.com/dpa99c/cordova-diagnostic-plugin/issues/524)

package/README.md

@@ -639,14 +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.
+- `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
 
@@ -2455,61 +2458,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.
+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.
+#### 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);
-    });
+    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`.
-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`.
-- {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.
+- {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.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);
     });
 
@@ -2517,31 +2539,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.
+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`.
+- {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{
-            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

@@ -78,6 +78,7 @@ interface Diagnostic {
         "GRANTED_WHEN_IN_USE": "authorized_when_in_use";
         "NOT_REQUESTED": "not_determined"|"NOT_REQUESTED";
         "DENIED_ALWAYS": "denied_always"|"DENIED_ALWAYS";
+        "UNKNOWN": "unknown"|"UNKNOWN";
     };
 
     /**
@@ -1272,7 +1273,10 @@ interface Diagnostic {
      */
     isLocalNetworkAuthorized?: (
         successCallback: (authorized: boolean) => void,
-        errorCallback: (error: string) => void
+        errorCallback: (error: string) => void,
+        options?: {
+            timeoutMs?: number;
+        }
     ) => void;
 
     /**
@@ -1283,7 +1287,10 @@ interface Diagnostic {
      */
     getLocalNetworkAuthorizationStatus?: (
         successCallback: (status: string) => void,
-        errorCallback: (error: string) => void
+        errorCallback: (error: string) => void,
+        options?: {
+            timeoutMs?: number;
+        }
     ) => void;
 
     /**

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "7.2.5",
+    "version": "7.2.7",
     "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.5">
+    version="7.2.7">
 
     <name>Diagnostic</name>
     <description>Cordova/Phonegap plugin to check the state of Location/WiFi/Camera/Bluetooth device settings.</description>

package/src/ios/Diagnostic_Wifi.m

@@ -13,6 +13,8 @@
 #import <net/if.h> // For IFF_LOOPBACK
 #import <Network/Network.h>
 #import <Network/browser.h>
+#import <dns_sd.h>
+#import <errno.h>
 
 // UserDefaults key for caching local network permission
 static NSString*const kLocalNetworkPermissionKey = @"Diagnostic_LocalNetworkPermission";
@@ -21,6 +23,7 @@ typedef NS_ENUM(NSInteger, LocalNetworkPermissionState) {
     LocalNetworkPermissionStateUnknown = 0,
     LocalNetworkPermissionStateGranted = 1,
     LocalNetworkPermissionStateDenied = -1,
+    LocalNetworkPermissionStateIndeterminate = -2,
 };
 @implementation Diagnostic_Wifi {
     nw_browser_t _browser;
@@ -41,6 +44,7 @@ static Diagnostic* diagnostic;
 
 // Internal constants
 static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
+static NSTimeInterval const kLocalNetworkDefaultTimeoutSeconds = 2.0;
 
 - (void)pluginInitialize {
     
@@ -83,6 +87,8 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
                 return;
             }
 
+            NSTimeInterval timeoutSeconds = [self resolveLocalNetworkTimeoutFromCommand:command];
+
             // Create parameters, and allow browsing over peer-to-peer link.
             if (@available(iOS 14.0, *)) {
                 // Create parameters, and allow browsing over peer-to-peer link.
@@ -101,7 +107,7 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
                 self->_isRequesting = YES;
                 self->_isPublishing = NO;
 
-               [diagnostic logDebug:@"Starting local network permission status check"];
+               [diagnostic logDebug:[NSString stringWithFormat:@"Starting local network permission status check (timeout %.2fs)", timeoutSeconds]];
                 // Start the browsing/publish flow on the main queue immediately and create a single-shot timeout.
                 dispatch_async(dispatch_get_main_queue(), ^{
                     __weak __typeof__(self) weakSelf = self;
@@ -121,19 +127,11 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
                     // Install a state handler so the browser emits state changes (silences the warning about missing handlers)
                     if (strongSelf->_browser) {
                         nw_browser_set_state_changed_handler(strongSelf->_browser, ^(nw_browser_state_t newState, nw_error_t error) {
-                            switch (newState) {
-                                case nw_browser_state_failed:
-                                    if (error) {
-                                        nw_error_domain_t errorDomain = nw_error_get_error_domain(error);
-                                        [diagnostic logDebug:[NSString stringWithFormat:@"Browser failed (status check): domain=%d", (int)errorDomain]];
-                                    }
-                                    break;
-                                case nw_browser_state_ready:
-                                case nw_browser_state_cancelled:
-                                case nw_browser_state_waiting:
-                                default:
-                                    break;
+                            __strong __typeof__(weakSelf) innerSelf = weakSelf;
+                            if (!innerSelf) {
+                                return;
                             }
+                            [innerSelf handleBrowserState:newState error:error context:@"status check"];
                         });
 
                         nw_browser_start(strongSelf->_browser);
@@ -144,17 +142,17 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
                     [strongSelf->_netService publish];
                     [strongSelf->_netService scheduleInRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
 
-                    // Set a single-shot timeout to consider the permission request failed
-                    strongSelf->_localNetworkTimer = [NSTimer scheduledTimerWithTimeInterval:2.0
-                                                                                       repeats:NO
-                                                                                         block:^(NSTimer * _Nonnull timer) {
-                        __strong __typeof__(weakSelf) innerSelf = weakSelf;
-                        if (!innerSelf) return;
-
-                        [diagnostic logDebug:@"Local network permission request timed out"];
-                        [self callLocalNetworkCallbacks:LocalNetworkPermissionStateDenied];
-                        [innerSelf resetLocalNetwork];
-                    }];
+                    if (timeoutSeconds > 0) {
+                        strongSelf->_localNetworkTimer = [NSTimer scheduledTimerWithTimeInterval:timeoutSeconds
+                                                                                           repeats:NO
+                                                                                             block:^(NSTimer * _Nonnull timer) {
+                            __strong __typeof__(weakSelf) innerSelf = weakSelf;
+                            if (!innerSelf) return;
+
+                            [diagnostic logDebug:[NSString stringWithFormat:@"Local network permission status check timed out after %.2fs", timeoutSeconds]];
+                            [innerSelf completeLocalNetworkFlowWithState:LocalNetworkPermissionStateIndeterminate shouldCache:NO];
+                        }];
+                    }
                 });
             }else{
                 [diagnostic logDebug:@"iOS version < 14.0, so local network permission is not required"];
@@ -199,33 +197,10 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
                 __weak __typeof__(self) weakSelf = self;
                 nw_browser_set_state_changed_handler(self->_browser, ^(nw_browser_state_t newState, nw_error_t error) {
                     __strong __typeof__(weakSelf) strongSelf = weakSelf;
-                    switch (newState) {
-                        case nw_browser_state_failed:
-                            if (error) {
-                                nw_error_domain_t errorDomain = nw_error_get_error_domain(error);
-                                [diagnostic logDebug:[NSString stringWithFormat:@"Browser failed: domain=%d", (int)errorDomain]];
-                            }
-                            break;
-                        case nw_browser_state_ready:
-                        case nw_browser_state_cancelled:
-                            break;
-                        case nw_browser_state_waiting:
-                            if (error) {
-                                nw_error_domain_t errorDomain = nw_error_get_error_domain(error);
-                                [diagnostic logDebug:[NSString stringWithFormat:@"Local network permission has been denied: domain=%d", (int)errorDomain]];
-                            } else {
-                                [diagnostic logDebug:@"Local network permission has been denied"];
-                            }
-                            [strongSelf resetLocalNetwork];
-                            // cache denied
-                            [[NSUserDefaults standardUserDefaults] setInteger:LocalNetworkPermissionStateDenied forKey:kLocalNetworkPermissionKey];
-                            [[NSUserDefaults standardUserDefaults] synchronize];
-                            // send false result to all waiting commands
-                            [self callLocalNetworkCallbacks:LocalNetworkPermissionStateDenied];
-                            break;
-                        default:
-                            break;
+                    if (!strongSelf) {
+                        return;
                     }
+                    [strongSelf handleBrowserState:newState error:error context:@"authorization request"];
                 });
                 
                 self->_netService = [[NSNetService alloc] initWithDomain:@"local." type:@"_lnp._tcp." name:@"LocalNetworkPrivacy" port:1100];
@@ -281,6 +256,93 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
     }
 }
 
+- (void)completeLocalNetworkFlowWithState:(LocalNetworkPermissionState)state shouldCache:(BOOL)shouldCache
+{
+    dispatch_block_t completion = ^{
+        [self resetLocalNetwork];
+        if (shouldCache && (state == LocalNetworkPermissionStateGranted || state == LocalNetworkPermissionStateDenied)) {
+            [[NSUserDefaults standardUserDefaults] setInteger:state forKey:kLocalNetworkPermissionKey];
+            [[NSUserDefaults standardUserDefaults] synchronize];
+        }
+        [self callLocalNetworkCallbacks:state];
+    };
+
+    if ([NSThread isMainThread]) {
+        completion();
+    } else {
+        dispatch_async(dispatch_get_main_queue(), completion);
+    }
+}
+
+- (NSTimeInterval)resolveLocalNetworkTimeoutFromCommand:(CDVInvokedUrlCommand*)command
+{
+    NSTimeInterval timeout = kLocalNetworkDefaultTimeoutSeconds;
+    if (!command || !command.arguments || command.arguments.count == 0) {
+        return timeout;
+    }
+
+    id rawValue = command.arguments[0];
+    if (![rawValue isKindOfClass:[NSDictionary class]]) {
+        return timeout;
+    }
+
+    NSDictionary *dict = (NSDictionary *)rawValue;
+    id timeoutMsValue = dict[@"timeoutMs"];
+    if ([timeoutMsValue isKindOfClass:[NSNumber class]]) {
+        double milliseconds = [timeoutMsValue doubleValue];
+        if (milliseconds < 0) {
+            milliseconds = 0;
+        }
+        return milliseconds / 1000.0;
+    }
+
+    return timeout;
+}
+
+- (BOOL)isPermissionDeniedError:(nw_error_t)error
+{
+	if (!error) {
+		return NO;
+	}
+
+	nw_error_domain_t errorDomain = nw_error_get_error_domain(error);
+	int errorCode = (int)nw_error_get_error_code(error);
+	if (errorDomain == nw_error_domain_posix && errorCode == EPERM) {
+		return YES;
+	}
+
+	if (errorDomain == nw_error_domain_dns && errorCode == kDNSServiceErr_PolicyDenied) {
+		return YES;
+	}
+
+	return NO;
+}
+
+- (void)handleBrowserState:(nw_browser_state_t)newState error:(nw_error_t)error context:(NSString *)context
+{
+    if (newState == nw_browser_state_waiting || newState == nw_browser_state_failed) {
+        if ([self isPermissionDeniedError:error]) {
+            nw_error_domain_t domain = nw_error_get_error_domain(error);
+            int code = (int)nw_error_get_error_code(error);
+            [diagnostic logDebug:[NSString stringWithFormat:@"Local network permission denied during %@ (domain=%d, code=%d)", context, (int)domain, code]];
+            [self completeLocalNetworkFlowWithState:LocalNetworkPermissionStateDenied shouldCache:YES];
+            return;
+        }
+
+        if (error) {
+            nw_error_domain_t domain = nw_error_get_error_domain(error);
+            int code = (int)nw_error_get_error_code(error);
+            [diagnostic logDebug:[NSString stringWithFormat:@"Local network browser %@ state %ld error domain=%d code=%d", context, (long)newState, (int)domain, code]];
+        } else {
+            [diagnostic logDebug:[NSString stringWithFormat:@"Local network browser %@ entered state %ld without error", context, (long)newState]];
+        }
+
+        if (newState == nw_browser_state_failed) {
+            [self completeLocalNetworkFlowWithState:LocalNetworkPermissionStateIndeterminate shouldCache:NO];
+        }
+    }
+}
+
 /********************************/
 #pragma mark - Wifi Plugin API
 /********************************/
@@ -365,17 +427,13 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
 
 - (void)netServiceDidPublish:(NSNetService *)sender {
     [diagnostic logDebug:@"netServiceDidPublish: Local network permission has been granted"];
-    [self resetLocalNetwork];
-    if (_localNetworkTimer) {
-        [_localNetworkTimer invalidate];
-        _localNetworkTimer = nil;
-    }
-    _isPublishing = NO;
-    
-    // cache granted
-    [[NSUserDefaults standardUserDefaults] setInteger:LocalNetworkPermissionStateGranted forKey:kLocalNetworkPermissionKey];
-    [[NSUserDefaults standardUserDefaults] synchronize];
+    [self completeLocalNetworkFlowWithState:LocalNetworkPermissionStateGranted shouldCache:YES];
+}
 
-    [self callLocalNetworkCallbacks:LocalNetworkPermissionStateGranted];
+- (void)netService:(NSNetService *)sender didNotPublish:(NSDictionary<NSString *,NSNumber *> *)errorDict {
+    NSNumber *errorDomain = errorDict[NSNetServicesErrorDomain];
+    NSNumber *errorCode = errorDict[NSNetServicesErrorCode];
+    [diagnostic logDebug:[NSString stringWithFormat:@"netService didNotPublish (domain=%@, code=%@)", errorDomain, errorCode]];
+    [self completeLocalNetworkFlowWithState:LocalNetworkPermissionStateDenied shouldCache:YES];
 }
 @end

package/www/android/diagnostic.js

@@ -89,6 +89,8 @@ var Diagnostic = (function(){
         "DENIED_ALWAYS": "DENIED_ALWAYS",
         // App has not yet requested access to this permission.
         "NOT_REQUESTED": "NOT_REQUESTED",
+        // Platform has not provided a definitive status (e.g. timeout/indeterminate)
+        "UNKNOWN": "unknown",
         // Limited access to the photo library on Android 14 (API 34) and above
         "LIMITED": "LIMITED"
     };

package/www/ios/diagnostic.js

@@ -22,6 +22,7 @@ var Diagnostic = (function(){
      */
     Diagnostic.permissionStatus = {
         "NOT_REQUESTED": "not_determined", // App has not yet requested this permission
+        "UNKNOWN": "unknown", // Platform has not provided a definitive status (e.g. timeout/indeterminate)
         "DENIED_ALWAYS": "denied_always", // User denied access to this permission
         "RESTRICTED": "restricted", // Permission is unavailable and user cannot enable it.  For example, when parental controls are in effect for the current user.
         "GRANTED": "authorized", //  User granted access to this permission
@@ -656,8 +657,9 @@ var Diagnostic = (function(){
      * This callback function is passed a single boolean parameter which is TRUE if the app is authorized to use Local Network.
      * @param {Function} errorCallback -  The callback which will be called when operation encounters an error.
      * This callback function is passed a single string parameter containing the error message.
+     * @param {Object} [options] - Optional timeout control object containing an optional `timeoutMs` number, matching the options accepted by `getLocalNetworkAuthorizationStatus()`.
      */
-    Diagnostic.isLocalNetworkAuthorized = function(successCallback, errorCallback) {
+    Diagnostic.isLocalNetworkAuthorized = function(successCallback, errorCallback, options) {
         if(cordova.plugins.diagnostic.wifi){
             cordova.plugins.diagnostic.wifi.isLocalNetworkAuthorized.apply(this, arguments);
         }else{
@@ -667,16 +669,18 @@ var Diagnostic = (function(){
 
      /**     
      * Returns the app's Local Network authorization status.
-     * On iOS 14+ this returns one of the values in Diagnostic.permissionStatus: NOT_REQUESTED, GRANTED, DENIED_ALWAYS.
+     * On iOS 14+ this returns one of the values in Diagnostic.permissionStatus: NOT_REQUESTED, GRANTED, DENIED_ALWAYS, UNKNOWN.
      * On iOS versions prior to 14, this always returns GRANTED as no authorization is required.
      *
      * @param {Function} successCallback -  The callback which will be called when operation is successful.
      * This callback function is passed a single string parameter which is one of the values in Diagnostic.permissionStatus:
-     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS.
+     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS, UNKNOWN.
      * @param {Function} errorCallback -  The callback which will be called when operation encounters an error.
      * This callback function is passed a single string parameter containing the error message.
+     * @param {Object} [options] - Optional control over the timeout (defaults to 2 seconds) used when inferring the permission state.
+     * Provide `{ timeoutMs: <number> }` to override the timeout in milliseconds.
      */   
-    Diagnostic.getLocalNetworkAuthorizationStatus = function(successCallback, errorCallback) {
+    Diagnostic.getLocalNetworkAuthorizationStatus = function(successCallback, errorCallback, options) {
         if(cordova.plugins.diagnostic.wifi){
             cordova.plugins.diagnostic.wifi.getLocalNetworkAuthorizationStatus.apply(this, arguments);
         }else{
@@ -691,7 +695,7 @@ var Diagnostic = (function(){
      *
      * @param {Function} successCallback -  The callback which will be called when operation is successful.
      * This callback function is passed a single string parameter which is one of the values in Diagnostic.permissionStatus:
-     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS.
+     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS, UNKNOWN.
      * @param {Function} errorCallback -  The callback which will be called when operation encounters an error.
      * This callback function is passed a single string parameter containing the error message.
      */

package/www/ios/diagnostic.wifi.js

@@ -36,6 +36,9 @@ var Diagnostic_Wifi = (function(){
             case -1: // LocalNetworkPermissionStateDenied
                 status = Diagnostic.permissionStatus.DENIED_ALWAYS;
                 break;
+            case -2: // LocalNetworkPermissionStateIndeterminate
+                status = Diagnostic.permissionStatus.UNKNOWN;
+                break;
             case 0: // LocalNetworkPermissionStateUnknown
             default:
                 status = Diagnostic.permissionStatus.NOT_REQUESTED;
@@ -44,6 +47,18 @@ var Diagnostic_Wifi = (function(){
         successCallback(status);
     }
 
+    function buildLocalNetworkArgs(options) {
+        if (options && typeof options === "object" && options.timeoutMs != null) {
+            var timeoutMs = Number(options.timeoutMs);
+            if (isFinite(timeoutMs)) {
+                return [{
+                    timeoutMs: Math.max(0, timeoutMs)
+                }];
+            }
+        }
+        return [];
+    }
+
     /*****************************
      *
      * Protected member functions
@@ -100,8 +115,10 @@ var Diagnostic_Wifi = (function(){
      * This callback function is passed a single boolean parameter which is TRUE if the app is authorized to use Local Network.
      * @param {Function} errorCallback -  The callback which will be called when operation encounters an error.
      * This callback function is passed a single string parameter containing the error message.
+     * @param {Object} [options] - Optional timeout control object containing an optional `timeoutMs` number.
      */
-    Diagnostic_Wifi.isLocalNetworkAuthorized = function(successCallback, errorCallback) {
+    Diagnostic_Wifi.isLocalNetworkAuthorized = function(successCallback, errorCallback, options) {
+        var args = buildLocalNetworkArgs(options);
         return cordova.exec(function(status) {
                 var authorized = (status === 1); // LocalNetworkPermissionStateAuthorized
                 successCallback(authorized);
@@ -109,29 +126,32 @@ var Diagnostic_Wifi = (function(){
             errorCallback,
             'Diagnostic_Wifi',
             'getLocalNetworkAuthorizationStatus',
-            []);
+            args);
     };
 
 
     /**     
      * Returns the app's Local Network authorization status.
-     * On iOS 14+ this returns one of the values in Diagnostic.permissionStatus: NOT_REQUESTED, GRANTED, DENIED_ALWAYS.
+     * On iOS 14+ this returns one of the values in Diagnostic.permissionStatus: NOT_REQUESTED, GRANTED, DENIED_ALWAYS, UNKNOWN.
      * On iOS versions prior to 14, this always returns GRANTED as no authorization is required.
      *
      * @param {Function} successCallback -  The callback which will be called when operation is successful.
      * This callback function is passed a single string parameter which is one of the values in Diagnostic.permissionStatus:
-     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS.
+     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS, UNKNOWN.
      * @param {Function} errorCallback -  The callback which will be called when operation encounters an error.
      * This callback function is passed a single string parameter containing the error message.
+     * @param {Object} [options] - Optional control over the timeout used when inferring the permission state.
+     * Defaults to 2 seconds when omitted. Provide `{ timeoutMs: <number> }` to override the timeout in milliseconds.
      */
-    Diagnostic_Wifi.getLocalNetworkAuthorizationStatus = function(successCallback, errorCallback) {
+    Diagnostic_Wifi.getLocalNetworkAuthorizationStatus = function(successCallback, errorCallback, options) {
+        var args = buildLocalNetworkArgs(options);
         return cordova.exec(function(nativeStatus) {
                 processLocalNetworkStatus(nativeStatus, successCallback);
             },
             errorCallback,
             'Diagnostic_Wifi',
             'getLocalNetworkAuthorizationStatus',
-            []);
+            args);
     };
 
     /**
@@ -141,7 +161,7 @@ var Diagnostic_Wifi = (function(){
      *
      * @param {Function} successCallback -  The callback which will be called when operation is successful.
      * This callback function is passed a single string parameter which is one of the values in Diagnostic.permissionStatus:
-     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS.
+     * NOT_REQUESTED, GRANTED, DENIED_ALWAYS, UNKNOWN.
      * @param {Function} errorCallback -  The callback which will be called when operation encounters an error.
      * This callback function is passed a single string parameter containing the error message.
      */
@@ -157,4 +177,4 @@ var Diagnostic_Wifi = (function(){
 
     return Diagnostic_Wifi;
 });
-module.exports = new Diagnostic_Wifi();
+module.exports = new Diagnostic_Wifi();