cordova.plugins.diagnostic 7.2.4 → 7.2.5

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+**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)
@@ -2442,6 +2451,98 @@ 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.
+
+    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.
+
+
+#### 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);
+    });
+
+### 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.
+
+    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.
+
+
+#### 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){
+        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.
+
+    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} 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);
+    });
+
 ### setWifiState()
 
 Platforms: Android

package/cordova.plugins.diagnostic.d.ts

@@ -1263,6 +1263,39 @@ 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
+    ) => 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
+    ) => 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.5",
     "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.5">
 
     <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,8 +11,30 @@
 #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>
 
-@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,
+};
+@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;
@@ -25,10 +47,242 @@ static NSString*const LOG_TAG = @"Diagnostic_Wifi[native]";
     [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;
+            }
+
+            // 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:@"Starting local network permission status check"];
+                // 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) {
+                            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;
+                            }
+                        });
+
+                        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];
+
+                    // 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];
+                    }];
+                });
+            }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;
+                    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;
+                    }
+                });
+                
+                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];
+    }
 }
 
 /********************************/
-#pragma mark - Plugin API
+#pragma mark - Wifi Plugin API
 /********************************/
 
 - (void) isWifiAvailable: (CDVInvokedUrlCommand*)command
@@ -105,4 +359,23 @@ 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 resetLocalNetwork];
+    if (_localNetworkTimer) {
+        [_localNetworkTimer invalidate];
+        _localNetworkTimer = nil;
+    }
+    _isPublishing = NO;
+    
+    // cache granted
+    [[NSUserDefaults standardUserDefaults] setInteger:LocalNetworkPermissionStateGranted forKey:kLocalNetworkPermissionKey];
+    [[NSUserDefaults standardUserDefaults] synchronize];
+
+    [self callLocalNetworkCallbacks:LocalNetworkPermissionStateGranted];
+}
 @end

package/www/ios/diagnostic.js

@@ -647,6 +647,62 @@ 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.
+     */
+    Diagnostic.isLocalNetworkAuthorized = function(successCallback, errorCallback) {
+        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.
+     * 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.
+     * @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.getLocalNetworkAuthorizationStatus = function(successCallback, errorCallback) {
+        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.
+     * @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,22 @@ 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 0: // LocalNetworkPermissionStateUnknown
+            default:
+                status = Diagnostic.permissionStatus.NOT_REQUESTED;
+                break;
+        }
+        successCallback(status);
+    }
 
     /*****************************
      *
@@ -75,6 +91,70 @@ 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.
+     */
+    Diagnostic_Wifi.isLocalNetworkAuthorized = function(successCallback, errorCallback) {
+        return cordova.exec(function(status) {
+                var authorized = (status === 1); // LocalNetworkPermissionStateAuthorized
+                successCallback(authorized);
+            },
+            errorCallback,
+            'Diagnostic_Wifi',
+            'getLocalNetworkAuthorizationStatus',
+            []);
+    };
+
+
+    /**     
+     * 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 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.
+     * @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.getLocalNetworkAuthorizationStatus = function(successCallback, errorCallback) {
+        return cordova.exec(function(nativeStatus) {
+                processLocalNetworkStatus(nativeStatus, successCallback);
+            },
+            errorCallback,
+            'Diagnostic_Wifi',
+            'getLocalNetworkAuthorizationStatus',
+            []);
+    };
+
+    /**
+     * 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.
+     * @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();