cordova.plugins.diagnostic 7.2.4 → 7.2.6

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+**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)
+
 **v7.2.4**
 * (android & ios) feat: add `isCompassAvailable()` to detect availability of compass for device heading.
 * (doc) update getCameraRollAuthorizationStatus example to include accessLevel parameter

package/README.md

@@ -206,145 +206,154 @@ Cordova diagnostic plugin [![Latest Stable Version](https://img.shields.io/npm/v
     - [isWifiEnabled()](#iswifienabled)
       - [Parameters](#parameters-51)
       - [Example usage](#example-usage-51)
-    - [setWifiState()](#setwifistate)
+    - [isLocalNetworkAuthorized()](#islocalnetworkauthorized)
       - [Parameters](#parameters-52)
       - [Example usage](#example-usage-52)
-    - [switchToWifiSettings()](#switchtowifisettings)
-  - [Camera module](#camera-module)
-    - [isCameraPresent()](#iscamerapresent)
+    - [getLocalNetworkAuthorizationStatus()](#getlocalnetworkauthorizationstatus)
       - [Parameters](#parameters-53)
       - [Example usage](#example-usage-53)
-    - [isCameraAvailable()](#iscameraavailable)
+    - [requestLocalNetworkAuthorization()](#requestlocalnetworkauthorization)
       - [Parameters](#parameters-54)
       - [Example usage](#example-usage-54)
-    - [isCameraAuthorized()](#iscameraauthorized)
+    - [setWifiState()](#setwifistate)
       - [Parameters](#parameters-55)
       - [Example usage](#example-usage-55)
-    - [getCameraAuthorizationStatus()](#getcameraauthorizationstatus)
+    - [switchToWifiSettings()](#switchtowifisettings)
+  - [Camera module](#camera-module)
+    - [isCameraPresent()](#iscamerapresent)
       - [Parameters](#parameters-56)
       - [Example usage](#example-usage-56)
-    - [getCameraAuthorizationStatuses()](#getcameraauthorizationstatuses)
+    - [isCameraAvailable()](#iscameraavailable)
       - [Parameters](#parameters-57)
       - [Example usage](#example-usage-57)
-    - [requestCameraAuthorization()](#requestcameraauthorization)
+    - [isCameraAuthorized()](#iscameraauthorized)
       - [Parameters](#parameters-58)
       - [Example usage](#example-usage-58)
-    - [isCameraRollAuthorized()](#iscamerarollauthorized)
+    - [getCameraAuthorizationStatus()](#getcameraauthorizationstatus)
       - [Parameters](#parameters-59)
       - [Example usage](#example-usage-59)
-    - [getCameraRollAuthorizationStatus()](#getcamerarollauthorizationstatus)
+    - [getCameraAuthorizationStatuses()](#getcameraauthorizationstatuses)
       - [Parameters](#parameters-60)
       - [Example usage](#example-usage-60)
-    - [requestCameraRollAuthorization()](#requestcamerarollauthorization)
+    - [requestCameraAuthorization()](#requestcameraauthorization)
       - [Parameters](#parameters-61)
       - [Example usage](#example-usage-61)
-    - [presentLimitedLibraryPicker()](#presentlimitedlibrarypicker)
+    - [isCameraRollAuthorized()](#iscamerarollauthorized)
       - [Parameters](#parameters-62)
       - [Example usage](#example-usage-62)
-  - [Notifications module](#notifications-module)
-    - [remoteNotificationType constants](#remotenotificationtype-constants)
-      - [Example](#example-4)
-    - [isRemoteNotificationsEnabled()](#isremotenotificationsenabled)
+    - [getCameraRollAuthorizationStatus()](#getcamerarollauthorizationstatus)
       - [Parameters](#parameters-63)
       - [Example usage](#example-usage-63)
-    - [isRegisteredForRemoteNotifications()](#isregisteredforremotenotifications)
+    - [requestCameraRollAuthorization()](#requestcamerarollauthorization)
       - [Parameters](#parameters-64)
       - [Example usage](#example-usage-64)
-    - [getRemoteNotificationTypes()](#getremotenotificationtypes)
+    - [presentLimitedLibraryPicker()](#presentlimitedlibrarypicker)
       - [Parameters](#parameters-65)
       - [Example usage](#example-usage-65)
-    - [getRemoteNotificationsAuthorizationStatus()](#getremotenotificationsauthorizationstatus)
+  - [Notifications module](#notifications-module)
+    - [remoteNotificationType constants](#remotenotificationtype-constants)
+      - [Example](#example-4)
+    - [isRemoteNotificationsEnabled()](#isremotenotificationsenabled)
       - [Parameters](#parameters-66)
       - [Example usage](#example-usage-66)
-    - [requestRemoteNotificationsAuthorization()](#requestremotenotificationsauthorization)
+    - [isRegisteredForRemoteNotifications()](#isregisteredforremotenotifications)
       - [Parameters](#parameters-67)
       - [Example usage](#example-usage-67)
-    - [switchToNotificationSettings()](#switchtonotificationsettings)
-  - [Microphone module](#microphone-module)
-    - [isMicrophoneAuthorized()](#ismicrophoneauthorized)
+    - [getRemoteNotificationTypes()](#getremotenotificationtypes)
       - [Parameters](#parameters-68)
       - [Example usage](#example-usage-68)
-    - [getMicrophoneAuthorizationStatus()](#getmicrophoneauthorizationstatus)
+    - [getRemoteNotificationsAuthorizationStatus()](#getremotenotificationsauthorizationstatus)
       - [Parameters](#parameters-69)
       - [Example usage](#example-usage-69)
-    - [requestMicrophoneAuthorization()](#requestmicrophoneauthorization)
+    - [requestRemoteNotificationsAuthorization()](#requestremotenotificationsauthorization)
       - [Parameters](#parameters-70)
       - [Example usage](#example-usage-70)
-  - [Contacts module](#contacts-module)
-    - [isContactsAuthorized()](#iscontactsauthorized)
+    - [switchToNotificationSettings()](#switchtonotificationsettings)
+  - [Microphone module](#microphone-module)
+    - [isMicrophoneAuthorized()](#ismicrophoneauthorized)
       - [Parameters](#parameters-71)
       - [Example usage](#example-usage-71)
-    - [getContactsAuthorizationStatus()](#getcontactsauthorizationstatus)
+    - [getMicrophoneAuthorizationStatus()](#getmicrophoneauthorizationstatus)
       - [Parameters](#parameters-72)
       - [Example usage](#example-usage-72)
-    - [requestContactsAuthorization()](#requestcontactsauthorization)
+    - [requestMicrophoneAuthorization()](#requestmicrophoneauthorization)
       - [Parameters](#parameters-73)
       - [Example usage](#example-usage-73)
-  - [Calendar module](#calendar-module)
-    - [isCalendarAuthorized()](#iscalendarauthorized)
+  - [Contacts module](#contacts-module)
+    - [isContactsAuthorized()](#iscontactsauthorized)
       - [Parameters](#parameters-74)
       - [Example usage](#example-usage-74)
-    - [getCalendarAuthorizationStatus()](#getcalendarauthorizationstatus)
+    - [getContactsAuthorizationStatus()](#getcontactsauthorizationstatus)
       - [Parameters](#parameters-75)
       - [Example usage](#example-usage-75)
-    - [requestCalendarAuthorization()](#requestcalendarauthorization)
+    - [requestContactsAuthorization()](#requestcontactsauthorization)
       - [Parameters](#parameters-76)
       - [Example usage](#example-usage-76)
-  - [Reminders module](#reminders-module)
-    - [isRemindersAuthorized()](#isremindersauthorized)
+  - [Calendar module](#calendar-module)
+    - [isCalendarAuthorized()](#iscalendarauthorized)
       - [Parameters](#parameters-77)
       - [Example usage](#example-usage-77)
-    - [getRemindersAuthorizationStatus()](#getremindersauthorizationstatus)
+    - [getCalendarAuthorizationStatus()](#getcalendarauthorizationstatus)
       - [Parameters](#parameters-78)
       - [Example usage](#example-usage-78)
-    - [requestRemindersAuthorization()](#requestremindersauthorization)
+    - [requestCalendarAuthorization()](#requestcalendarauthorization)
       - [Parameters](#parameters-79)
       - [Example usage](#example-usage-79)
-  - [Motion module](#motion-module)
-    - [motionStatus constants](#motionstatus-constants)
-      - [Example](#example-5)
-    - [isMotionAvailable()](#ismotionavailable)
+  - [Reminders module](#reminders-module)
+    - [isRemindersAuthorized()](#isremindersauthorized)
       - [Parameters](#parameters-80)
       - [Example usage](#example-usage-80)
-    - [isMotionRequestOutcomeAvailable()](#ismotionrequestoutcomeavailable)
+    - [getRemindersAuthorizationStatus()](#getremindersauthorizationstatus)
       - [Parameters](#parameters-81)
       - [Example usage](#example-usage-81)
-    - [requestMotionAuthorization()](#requestmotionauthorization)
+    - [requestRemindersAuthorization()](#requestremindersauthorization)
       - [Parameters](#parameters-82)
       - [Example usage](#example-usage-82)
-    - [getMotionAuthorizationStatus()](#getmotionauthorizationstatus)
+  - [Motion module](#motion-module)
+    - [motionStatus constants](#motionstatus-constants)
+      - [Example](#example-5)
+    - [isMotionAvailable()](#ismotionavailable)
       - [Parameters](#parameters-83)
       - [Example usage](#example-usage-83)
-  - [NFC module](#nfc-module)
-    - [NFCState constants](#nfcstate-constants)
-      - [Values](#values-3)
-      - [Example](#example-6)
-    - [isNFCPresent()](#isnfcpresent)
+    - [isMotionRequestOutcomeAvailable()](#ismotionrequestoutcomeavailable)
       - [Parameters](#parameters-84)
       - [Example usage](#example-usage-84)
-    - [isNFCEnabled()](#isnfcenabled)
+    - [requestMotionAuthorization()](#requestmotionauthorization)
       - [Parameters](#parameters-85)
       - [Example usage](#example-usage-85)
-    - [isNFCAvailable()](#isnfcavailable)
+    - [getMotionAuthorizationStatus()](#getmotionauthorizationstatus)
       - [Parameters](#parameters-86)
       - [Example usage](#example-usage-86)
-    - [registerNFCStateChangeHandler()](#registernfcstatechangehandler)
+  - [NFC module](#nfc-module)
+    - [NFCState constants](#nfcstate-constants)
+      - [Values](#values-3)
+      - [Example](#example-6)
+    - [isNFCPresent()](#isnfcpresent)
       - [Parameters](#parameters-87)
       - [Example usage](#example-usage-87)
-    - [switchToNFCSettings()](#switchtonfcsettings)
-  - [External storage module](#external-storage-module)
-    - [isExternalStorageAuthorized()](#isexternalstorageauthorized)
+    - [isNFCEnabled()](#isnfcenabled)
       - [Parameters](#parameters-88)
       - [Example usage](#example-usage-88)
-    - [getExternalStorageAuthorizationStatus()](#getexternalstorageauthorizationstatus)
+    - [isNFCAvailable()](#isnfcavailable)
       - [Parameters](#parameters-89)
       - [Example usage](#example-usage-89)
-    - [requestExternalStorageAuthorization()](#requestexternalstorageauthorization)
+    - [registerNFCStateChangeHandler()](#registernfcstatechangehandler)
       - [Parameters](#parameters-90)
       - [Example usage](#example-usage-90)
-    - [getExternalSdCardDetails()](#getexternalsdcarddetails)
+    - [switchToNFCSettings()](#switchtonfcsettings)
+  - [External storage module](#external-storage-module)
+    - [isExternalStorageAuthorized()](#isexternalstorageauthorized)
       - [Parameters](#parameters-91)
       - [Example usage](#example-usage-91)
+    - [getExternalStorageAuthorizationStatus()](#getexternalstorageauthorizationstatus)
+      - [Parameters](#parameters-92)
+      - [Example usage](#example-usage-92)
+    - [requestExternalStorageAuthorization()](#requestexternalstorageauthorization)
+      - [Parameters](#parameters-93)
+      - [Example usage](#example-usage-93)
+    - [getExternalSdCardDetails()](#getexternalsdcarddetails)
+      - [Parameters](#parameters-94)
+      - [Example usage](#example-usage-94)
 - [Platform Notes](#platform-notes)
   - [Android](#android-3)
     - [Android permissions](#android-permissions)
@@ -630,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
 
@@ -2442,6 +2454,120 @@ The function is passed a single string parameter containing the error message.
         console.error("The following error occurred: "+error);
     });
 
+### isLocalNetworkAuthorized()
+
+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> }`.
+
+    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.
+
+
+#### 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 }
+);
+```
+
+### 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.
+
+    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.
+
+
+#### 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){
+        console.error("The following error occurred: "+error);
+    });
+
+### requestLocalNetworkAuthorization()
+
+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.
+
+    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} 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);
+    });
+
 ### setWifiState()
 
 Platforms: Android

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";
     };
 
     /**
@@ -1263,6 +1264,45 @@ interface Diagnostic {
         successCallback: (status: string) => void,
         errorCallback: (error: string) => void
     ) => void;
+
+    /**
+     * iOS ONLY
+     * Checks if the application is authorized to use local network.
+     * @param successCallback
+     * @param errorCallback
+     */
+    isLocalNetworkAuthorized?: (
+        successCallback: (authorized: boolean) => void,
+        errorCallback: (error: string) => void,
+        options?: {
+            timeoutMs?: number;
+        }
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Returns the local network authorization status for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    getLocalNetworkAuthorizationStatus?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void,
+        options?: {
+            timeoutMs?: number;
+        }
+    ) => void;
+
+    /**
+     * iOS ONLY
+     * Requests local network authorization for the application.
+     * @param successCallback
+     * @param errorCallback
+     */
+    requestLocalNetworkAuthorization?: (
+        successCallback: (status: string) => void,
+        errorCallback: (error: string) => void
+    ) => void;
 }
 
 interface CordovaPlugins {

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "7.2.4",
+    "version": "7.2.6",
     "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.4">
+    version="7.2.6">
 
     <name>Diagnostic</name>
     <description>Cordova/Phonegap plugin to check the state of Location/WiFi/Camera/Bluetooth device settings.</description>
@@ -104,6 +104,17 @@
 
         <header-file src="src/ios/Diagnostic_Wifi.h" />
         <source-file src="src/ios/Diagnostic_Wifi.m" />
+
+        <config-file parent="NSLocalNetworkUsageDescription" platform="ios" target="*-Info.plist">
+            <string>This app requires access to your local network in order to discover and connect to devices on the same network.</string>
+        </config-file>
+
+        <config-file parent="NSBonjourServices" platform="ios" target="*-Info.plist">
+            <array>
+                <string>_lnp._tcp.</string>
+                <string>_bonjour._tcp.</string>
+            </array>
+        </config-file>
         <!--END_MODULE WIFI-->
 
         <!--BEGIN_MODULE CAMERA-->

package/src/ios/Diagnostic.h

@@ -47,6 +47,8 @@ extern NSString*const AUTHORIZATION_LIMITED;
 - (void) sendPluginResultSuccess:(CDVInvokedUrlCommand*)command;
 - (void) sendPluginNoResultAndKeepCallback:(CDVInvokedUrlCommand*)command;
 - (void) sendPluginResultBool: (BOOL)result :(CDVInvokedUrlCommand*)command;
+- (void) sendPluginResultInt: (int)result :(CDVInvokedUrlCommand*)command;
+- (void) sendPluginResultObject: (NSDictionary*)result :(CDVInvokedUrlCommand*)command;
 - (void) sendPluginResultString: (NSString*)result :(CDVInvokedUrlCommand*)command;
 - (void) sendPluginError: (NSString*) errorMessage :(CDVInvokedUrlCommand*)command;
 - (void) handlePluginException: (NSException*) exception :(CDVInvokedUrlCommand*)command;

package/src/ios/Diagnostic_Wifi.h

@@ -10,10 +10,11 @@
 #import <Cordova/CDVPlugin.h>
 #import "Diagnostic.h"
 
-
-@interface Diagnostic_Wifi : CDVPlugin
+@interface Diagnostic_Wifi : CDVPlugin <NSNetServiceDelegate>
 
 - (void) isWifiAvailable: (CDVInvokedUrlCommand*)command;
 - (void) isWifiEnabled: (CDVInvokedUrlCommand*)command;
+- (void) requestLocalNetworkAuthorization: (CDVInvokedUrlCommand*)command;
+- (void) getLocalNetworkAuthorizationStatus: (CDVInvokedUrlCommand*)command;
 
 @end

package/src/ios/Diagnostic_Wifi.m

@@ -11,24 +11,331 @@
 #import <arpa/inet.h> // For AF_INET, etc.
 #import <ifaddrs.h> // For getifaddrs()
 #import <net/if.h> // For IFF_LOOPBACK
+#import <Network/Network.h>
+#import <Network/browser.h>
+#import <errno.h>
 
-@implementation Diagnostic_Wifi
+// UserDefaults key for caching local network permission
+static NSString*const kLocalNetworkPermissionKey = @"Diagnostic_LocalNetworkPermission";
+
+typedef NS_ENUM(NSInteger, LocalNetworkPermissionState) {
+    LocalNetworkPermissionStateUnknown = 0,
+    LocalNetworkPermissionStateGranted = 1,
+    LocalNetworkPermissionStateDenied = -1,
+    LocalNetworkPermissionStateIndeterminate = -2,
+};
+@implementation Diagnostic_Wifi {
+    nw_browser_t _browser;
+    NSNetService *_netService;
+    // Completion callbacks stored as CDV callbacks (we'll send results to all when done)
+    NSMutableArray<CDVInvokedUrlCommand*> *_localNetworkCommands;
+    NSTimer* _localNetworkTimer;
+    
+    // If we have a cached granted/denied value, fall through to the normal path which will verify current status
+    // (this may trigger a prompt only if requestLocalNetworkAuthorization was previously called).
+    BOOL _isPublishing;
+
+    BOOL _isRequesting;
+}
 
 // Internal reference to Diagnostic singleton instance
 static Diagnostic* diagnostic;
 
 // Internal constants
 static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
+static NSTimeInterval const kLocalNetworkDefaultTimeoutSeconds = 2.0;
 
 - (void)pluginInitialize {
     
     [super pluginInitialize];
 
     diagnostic = [Diagnostic getInstance];
+    // initialize commands array
+    _localNetworkCommands = [NSMutableArray new];
+}
+
+/**************************************/
+#pragma mark - Local Network Plugin API
+/**************************************/
+
+- (void) getLocalNetworkAuthorizationStatus: (CDVInvokedUrlCommand*)command
+{
+    [self.commandDelegate runInBackground:^{
+        @try {
+
+            // Read cached permission state first
+            NSInteger cached = [[NSUserDefaults standardUserDefaults] integerForKey:kLocalNetworkPermissionKey];
+            LocalNetworkPermissionState state = (LocalNetworkPermissionState)cached;
+
+            if (state == LocalNetworkPermissionStateUnknown) {
+                // If unknown, do not attempt to start browsing/publishing (that would trigger the system prompt).
+                // respond with NO (unauthorized) when never requested.
+                [diagnostic sendPluginResultInt:LocalNetworkPermissionStateUnknown :command];
+                [diagnostic logDebug:@"Local network permission status is NOT_REQUESTED"];
+                return;
+            }
+        
+            // Store command so we can send the result later
+            @synchronized(self->_localNetworkCommands) {
+                [self->_localNetworkCommands addObject:command];
+            }
+
+            if(self->_isRequesting){
+                // A request is already in progress so await the result
+                [diagnostic logDebug:@"A request is already in progress, will return result when done"];
+                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.
+                nw_parameters_t parameters = nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL, NW_PARAMETERS_DEFAULT_CONFIGURATION);
+                nw_parameters_set_include_peer_to_peer(parameters, true);
+                
+                // Browse for a custom service type.
+                nw_browse_descriptor_t descriptor =
+                nw_browse_descriptor_create_bonjour_service("_bonjour._tcp", NULL);
+                self->_browser = nw_browser_create(descriptor, parameters);
+                
+                nw_browser_set_queue(self->_browser, dispatch_get_main_queue());
+                
+                self->_netService = [[NSNetService alloc] initWithDomain:@"local." type:@"_lnp._tcp." name:@"LocalNetworkPrivacy" port:1100];
+                
+                self->_isRequesting = YES;
+                self->_isPublishing = NO;
+
+               [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;
+
+                    __strong __typeof__(weakSelf) strongSelf = weakSelf;
+                    if (!strongSelf) return;
+
+                    // Ensure we only start once for this check
+                    if (strongSelf->_isPublishing) {
+                        [diagnostic logDebug:@"Local network permission request already publishing, skipping start"];
+                        return;
+                    }
+
+                    strongSelf->_isPublishing = YES;
+                    strongSelf->_netService.delegate = strongSelf;
+
+                    // 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) {
+                            __strong __typeof__(weakSelf) innerSelf = weakSelf;
+                            if (!innerSelf) {
+                                return;
+                            }
+                            [innerSelf handleBrowserState:newState error:error context:@"status check"];
+                        });
+
+                        nw_browser_start(strongSelf->_browser);
+                    } else {
+                        [diagnostic logDebug:@"Attempted to start browser but browser is null"];
+                    }
+
+                    [strongSelf->_netService publish];
+                    [strongSelf->_netService scheduleInRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+
+                    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"];
+                [self callLocalNetworkCallbacks:LocalNetworkPermissionStateGranted];
+            }
+        }
+        @catch (NSException *exception) {
+            [diagnostic handlePluginException:exception :command];
+        }
+    }];
+}
+
+// This code is based on https://stackoverflow.com/a/67758105/2618437 with slight modifications
+- (void) requestLocalNetworkAuthorization: (CDVInvokedUrlCommand*)command
+{
+    [self.commandDelegate runInBackground:^{
+        @try {
+            if(self->_isRequesting){
+                // A request is already in progress
+                [diagnostic sendPluginError:@"A request is already in progress" :command];
+                return;
+            }
+            self->_isRequesting = YES;
+
+            // Store command so we can send the result later
+            @synchronized(self->_localNetworkCommands) {
+                [self->_localNetworkCommands addObject:command];
+            }
+            
+            if (@available(iOS 14.0, *)) {
+                // Create parameters, and allow browsing over peer-to-peer link.
+                nw_parameters_t parameters = nw_parameters_create_secure_tcp(NW_PARAMETERS_DISABLE_PROTOCOL, NW_PARAMETERS_DEFAULT_CONFIGURATION);
+                nw_parameters_set_include_peer_to_peer(parameters, true);
+                
+                // Browse for a custom service type.
+                nw_browse_descriptor_t descriptor =
+                nw_browse_descriptor_create_bonjour_service("_bonjour._tcp", NULL);
+                self->_browser = nw_browser_create(descriptor, parameters);
+                
+                nw_browser_set_queue(self->_browser, dispatch_get_main_queue());
+                
+                __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;
+                    if (!strongSelf) {
+                        return;
+                    }
+                    [strongSelf handleBrowserState:newState error:error context:@"authorization request"];
+                });
+                
+                self->_netService = [[NSNetService alloc] initWithDomain:@"local." type:@"_lnp._tcp." name:@"LocalNetworkPrivacy" port:1100];
+                self->_netService.delegate = self;
+                
+                // Start browsing on main queue
+                nw_browser_start(self->_browser);
+                [self->_netService publish];
+                // the netService needs to be scheduled on a run loop, in this case the main runloop
+                [self->_netService scheduleInRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+            }else{
+                // iOS version < 14.0, so local network permission is not required
+                [self callLocalNetworkCallbacks:LocalNetworkPermissionStateGranted];
+            }
+        } @catch (NSException *exception) {
+            [diagnostic handlePluginException:exception :command];
+        }
+    }];
+}
+
+- (void) resetLocalNetwork
+{
+    [diagnostic logDebug:@"resetting"];
+    // stop the timer if active so it doesn't keep firing
+    if (_localNetworkTimer) {
+        [_localNetworkTimer invalidate];
+        _localNetworkTimer = nil;
+    }
+
+    // reset state flags
+    self->_isPublishing = NO;
+    self->_isRequesting = NO;
+
+    if (_browser) {
+        if (@available(iOS 13.0, *)) {
+            nw_browser_cancel(_browser);
+        }
+        _browser = nil;
+    }
+    if (_netService) {
+        [_netService stop];
+        _netService = nil;
+    }
+}
+
+- (void) callLocalNetworkCallbacks:(LocalNetworkPermissionState)result
+{
+    @synchronized(self->_localNetworkCommands) {
+        for (CDVInvokedUrlCommand *c in self->_localNetworkCommands) {
+            [diagnostic sendPluginResultInt:(int)result :c];
+        }
+        [self->_localNetworkCommands removeAllObjects];
+    }
+}
+
+- (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);
+    return (errorDomain == nw_error_domain_posix && errorCode == EPERM);
+}
+
+- (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 - Plugin API
+#pragma mark - Wifi Plugin API
 /********************************/
 
 - (void) isWifiAvailable: (CDVInvokedUrlCommand*)command
@@ -105,4 +412,19 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
 }
 
 
+/********************************/
+#pragma mark - NetServiceDelegate
+/********************************/
+
+- (void)netServiceDidPublish:(NSNetService *)sender {
+    [diagnostic logDebug:@"netServiceDidPublish: Local network permission has been granted"];
+    [self completeLocalNetworkFlowWithState:LocalNetworkPermissionStateGranted shouldCache:YES];
+}
+
+- (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
@@ -647,6 +648,65 @@ var Diagnostic = (function(){
         }
     };
 
+    /**
+     * Checks if the app is authorized to use Local Network.
+     * On iOS 14+ this returns true if the user has authorized the app to access devices on the local network.
+     * On iOS versions prior to 14, this always returns true 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 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, options) {
+        if(cordova.plugins.diagnostic.wifi){
+            cordova.plugins.diagnostic.wifi.isLocalNetworkAuthorized.apply(this, arguments);
+        }else{
+            throw "Diagnostic Wifi module is not installed";
+        }
+    };
+
+     /**     
+     * 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, 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, 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, options) {
+        if(cordova.plugins.diagnostic.wifi){
+            cordova.plugins.diagnostic.wifi.getLocalNetworkAuthorizationStatus.apply(this, arguments);
+        }else{
+            throw "Diagnostic Wifi module is not installed";
+        }
+    };
+
+    /**
+     * Requests the user to authorize the app to use Local Network.
+     * On iOS 14+ this will prompt the user to authorize the app to access devices on the local network.
+     * On iOS versions prior to 14, this does nothing as no authorization is required and will return success.
+     *
+     * @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, 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.
+     */
+    Diagnostic.requestLocalNetworkAuthorization = function(successCallback, errorCallback) {
+        if(cordova.plugins.diagnostic.wifi){
+            cordova.plugins.diagnostic.wifi.requestLocalNetworkAuthorization.apply(this, arguments);
+        }else{
+            throw "Diagnostic Wifi module is not installed";
+        }
+    };
+
     /***************
      * Bluetooth   *
      ***************/

package/www/ios/diagnostic.wifi.js

@@ -27,6 +27,37 @@ var Diagnostic_Wifi = (function(){
      * Internal functions
      *
      ********************/
+    function processLocalNetworkStatus(nativeStatus, successCallback) {
+        let status;
+        switch (nativeStatus) {
+            case 1: // LocalNetworkPermissionStateGranted
+                status = Diagnostic.permissionStatus.GRANTED;
+                break;
+            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;
+                break;
+        }
+        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 [];
+    }
 
     /*****************************
      *
@@ -75,6 +106,75 @@ var Diagnostic_Wifi = (function(){
             []);
     };
 
+    /**
+     * Checks if the app is authorized to use Local Network.
+     * On iOS 14+ this returns true if the user has authorized the app to access devices on the local network.
+     * On iOS versions prior to 14, this always returns true 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 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, options) {
+        var args = buildLocalNetworkArgs(options);
+        return cordova.exec(function(status) {
+                var authorized = (status === 1); // LocalNetworkPermissionStateAuthorized
+                successCallback(authorized);
+            },
+            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, 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, 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, options) {
+        var args = buildLocalNetworkArgs(options);
+        return cordova.exec(function(nativeStatus) {
+                processLocalNetworkStatus(nativeStatus, successCallback);
+            },
+            errorCallback,
+            'Diagnostic_Wifi',
+            'getLocalNetworkAuthorizationStatus',
+            args);
+    };
+
+    /**
+     * Requests the user to authorize the app to use Local Network.
+     * On iOS 14+ this will prompt the user to authorize the app to access devices on the local network.
+     * On iOS versions prior to 14, this does nothing as no authorization is required and will return success.
+     *
+     * @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, 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.
+     */
+    Diagnostic_Wifi.requestLocalNetworkAuthorization = function(successCallback, errorCallback) {
+        return cordova.exec(function(nativeStatus) {
+                processLocalNetworkStatus(nativeStatus, successCallback);
+            },
+            errorCallback,
+            'Diagnostic_Wifi',
+            'requestLocalNetworkAuthorization',
+            []);
+    };
+
     return Diagnostic_Wifi;
 });
-module.exports = new Diagnostic_Wifi();
+module.exports = new Diagnostic_Wifi();