cordova.plugins.diagnostic 7.0.0 → 7.1.1

package/CHANGELOG.md

@@ -1,7 +1,21 @@
 # CHANGELOG
 
-**v7.0.0**
+**v7.1.1**
+* (Android, iOS) feat: Add `isMobileDataEnabled()` to core module.
+    * Based on PR [#478](https://github.com/dpa99c/cordova-diagnostic-plugin/pull/478)
+* (iOS) bugfix: Only allow Bluetooth permission request if not already requested.
+    * Resolves [#477](https://github.com/dpa99c/cordova-diagnostic-plugin/issues/477).
+* (iOS) bugfix: Resolve the correct authorization status after requesting camera roll authorization and granting LIMITED access.
+    * Resolves [#476](https://github.com/dpa99c/cordova-diagnostic-plugin/issues/476).
+
+
+**v7.1.0**
+* (Android, iOS) feat: add support to fetch device OS and build SDK details
 
+
+**v7.0.0**
+* (Android) BREAKING chore: Remove deprecated aliases `cordova.plugins.diagnostic.runtimePermission` and  `cordova.plugins.diagnostic.runtimePermissionStatus`
+    - Use `cordova.plugins.diagnostic.permission` and `cordova.plugins.diagnostic.permissionStatus` instead.
 * (iOS) feat: Add support for Photo Library access levels on iOS 14+
     * Resolves [#473](https://github.com/dpa99c/cordova-diagnostic-plugin/issues/473).
     * Add support to show Limited-Library Selection UI for Photo Roll in iOS 14+

package/README.md

@@ -42,6 +42,9 @@ Cordova diagnostic plugin [![Latest Stable Version](https://img.shields.io/npm/v
     - [enableDebug()](#enabledebug)
     - [getCurrentBatteryLevel()](#getcurrentbatterylevel)
     - [isAirplaneModeEnabled()](#isairplanemodeenabled)
+    - [isMobileDataEnabled()](#ismobiledataenabled)
+    - [getDeviceOSVersion()](#getdeviceosversion)
+    - [getBuildOSVersion()](#getbuildosversion)
   - [Location module](#location-module)
     - [locationMode constants](#locationmode-constants)
     - [locationAuthorizationMode constants](#locationauthorizationmode-constants)
@@ -268,20 +271,20 @@ Before [opening a bug issue](https://github.com/dpa99c/cordova-diagnostic-plugin
 - *DO NOT* open issues related to the  [Ionic Typescript wrapper for this plugin](https://github.com/ionic-team/ionic-native/blob/master/src/%40ionic-native/plugins/diagnostic/index.ts)
     - This is owned/maintained by [Ionic](https://github.com/ionic-team) and is not part of this plugin
     - Please raise such issues/PRs against [Ionic Native](https://github.com/ionic-team/ionic-native/) instead.
-	- To verify an if an issue is caused by this plugin or its Typescript wrapper, please re-test using the vanilla Javascript plugin interface (without the Ionic Native wrapper).
-	- Any issue opened here which is obviously an Ionic Typescript wrapper issue will be closed immediately.
+    - To verify an if an issue is caused by this plugin or its Typescript wrapper, please re-test using the vanilla Javascript plugin interface (without the Ionic Native wrapper).
+    - Any issue opened here which is obviously an Ionic Typescript wrapper issue will be closed immediately.
 - Read the above documentation thoroughly
 - Check the [CHANGELOG](https://github.com/dpa99c/cordova-diagnostic-plugin/blob/master/CHANGELOG.md) for any breaking changes that may be causing your issue.
 - Check a similar issue (open or closed) does not already exist against this plugin.
-	- Duplicates or near-duplicates will be closed immediately.
+    - Duplicates or near-duplicates will be closed immediately.
 - When [creating a new issue](https://github.com/dpa99c/cordova-diagnostic-plugin/issues/new/choose)
     - Choose the "Bug report" template
     - Fill out the relevant sections of the template and delete irrelevant sections
     - *WARNING:* Failure to complete the issue template will result in the issue being closed immediately.
 - Reproduce the issue using the [example project](https://github.com/dpa99c/cordova-diagnostic-plugin-example)
-	- This will eliminate bugs in your code or conflicts with other code as possible causes of the issue
-	- This will also validate your development environment using a known working codebase
-	- If reproducing the issue using the example project is not possible, create an isolated test project that you are able to share
+    - This will eliminate bugs in your code or conflicts with other code as possible causes of the issue
+    - This will also validate your development environment using a known working codebase
+    - If reproducing the issue using the example project is not possible, create an isolated test project that you are able to share
 - Include full verbose console output when reporting build issues
     - If the full console output is too large to insert directly into the Github issue, then post it on an external site such as [Pastebin](https://pastebin.com/) and link to it from the issue
     - Often the details of an error causing a build failure is hidden away when building with the CLI
@@ -774,7 +777,7 @@ Platforms: Android and iOS
 
 Defines constants for the various CPU architectures of the current hardware returned by [getArchitecture()](#getarchitecture).
 
-        cordova.plugins.diagnostic.cpuArchitecture
+    cordova.plugins.diagnostic.cpuArchitecture
 
 #### Android
 
@@ -871,8 +874,9 @@ Enables debug mode, which logs native debug messages to the native and JS consol
 - For iOS, log messages will appear in the native Xcode console output and in the JS console if Safari Web Inspector is connected to the app Webview.
 - Debug mode is initially disabled on plugin initialisation.
 
-
-    cordova.plugins.diagnostic.enableDebug(successCallback);
+```
+cordova.plugins.diagnostic.enableDebug(successCallback);
+```
 
 #### Parameters
 
@@ -929,6 +933,95 @@ The function is passed a single string parameter containing the error message.
         console.log(`Airplane mode is currently ${enabled ? 'enabled' : 'disabled'}%`);
     });
 
+
+=======
+    
+### isMobileDataEnabled()
+
+Platforms: Android and iOS
+
+Checks if mobile (cellular) data is currently enabled on the device.
+
+On Android this requires permission `<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />`
+
+
+    cordova.plugins.diagnostic.isMobileDataEnabled(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 mobile data is enabled.
+- {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.isMobileDataEnabled(function(enabled){
+        console.log(`Mobile data is currently ${enabled ? 'enabled' : 'disabled'}%`);
+    });
+    
+
+### getDeviceOSVersion()
+
+Platforms: Android and iOS
+
+Returns details of the OS of the device on which the app is currently running.
+
+
+    cordova.plugins.diagnostic.getDeviceOSVersion(successCallback, errorCallback);
+
+#### Parameters
+
+- {Function} successCallback -  The callback which will be called when operation is successful.
+The function is  passed a single object parameter with the following fields:
+    - {string} version - version string of the OS e.g. "11.0"
+    - {integer} apiLevel - API level of the OS e.g. 30 on Android / 16000 on iOS
+    - {string} apiName - code name for API level e.g. "FROYO" on Android / "11.0" on iOS
+- {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.getDeviceOSVersion(function(details){
+        console.log(`Version: ${details.version}%`); // "13.0"
+        console.log(`API level: ${details.apiLevel}%`); // 33
+        console.log(`API name: ${details.apiName}%`); // "TIRAMISU"
+    });
+
+### getBuildOSVersion()
+
+Platforms: Android and iOS
+
+Returns details of the SDK levels used to build the app.
+
+
+    cordova.plugins.diagnostic.getBuildOSVersion(successCallback, errorCallback);
+
+#### Parameters
+
+- {Function} successCallback -  The callback which will be called when operation is successful.
+The function is  passed a single object parameter with the following fields:
+    - {integer} targetApiLevel - API level of the target SDK (used to build the app) e.g. 30 on Android / 16000 on iOS
+    - {string} targetApiName - code name for API level of the target SDK e.g. "FROYO" on Android / "11.0" on iOS
+    - {integer} minApiLevel - API level of the minimum SDK (lowest on which the app can be installed) e.g. 30 on Android / 16000 on iOS
+    - {string} minApiName - code name for API level of the minimum SDK e.g. "FROYO" on Android / "11.0" on iOS
+- {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.getBuildOSVersion(function(details){
+        console.log(`Target API level: ${details.targetApiLevel}%`); // 33
+        console.log(`Target API name: ${details.targetApiLevel}%`); // "TIRAMISU"
+        console.log(`Minimum API level: ${details.targetApiLevel}%`); // 21
+        console.log(`Target API name: ${details.targetApiLevel}%`); // "LOLLIPOP"
+    });
+
+
+
 ## Location module
 
 Purpose: Location/GPS functionality
@@ -1003,8 +1096,9 @@ Platforms: Android & iOS
 - Defines constants for the various location accuracy authorization states on iOS 14+ and Android 12+.
 - See [CLAccuracyAuthorization](https://developer.apple.com/documentation/corelocation/claccuracyauthorization) for iOS 14+ and [approximate location](https://developer.android.com/training/location/permissions#approximate-request) for Android 12+
 
-
-    cordova.plugins.diagnostic.locationAccuracyAuthorization
+```
+cordova.plugins.diagnostic.locationAccuracyAuthorization
+```
 
 #### Values
 
@@ -1108,8 +1202,9 @@ Returns true if Location mode is enabled and is set to either:
 - Device only = GPS hardware only (high accuracy)
 - High accuracy = GPS hardware, network triangulation and Wifi network IDs (high and low accuracy)
 
-
-    cordova.plugins.diagnostic.isGpsLocationEnabled(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.isGpsLocationEnabled(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1163,8 +1258,9 @@ Returns true if Location mode is enabled and is set to either:
 - Battery saving = network triangulation and Wifi network IDs (low accuracy)
 - High accuracy = GPS hardware, network triangulation and Wifi network IDs (high and low accuracy)
 
-
-    cordova.plugins.diagnostic.isNetworkLocationEnabled(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.isNetworkLocationEnabled(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1232,7 +1328,9 @@ Notes for Android:
 - This is intended for Android 6 / API 23 and above.
 Calling on Android 5.1 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
 
-    `cordova.plugins.diagnostic.isLocationAuthorized(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.isLocationAuthorized(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1258,13 +1356,14 @@ Platforms: Android and iOS
 
 Returns the location authorization status for the application.
 
-Notes for Android: 
- - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
- - This is the combined location status for both `COARSE` and `FINE` permissions.
- - On Android 10+/API 29+, if `COARSE` or `FINE` permission is `GRANTED` but `BACKGROUND_LOCATION` permission is not `GRANTED`, will return `GRANTED_WHEN_IN_USE`.
+Notes for Android:
+- This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
+- This is the combined location status for both `COARSE` and `FINE` permissions.
+- On Android 10+/API 29+, if `COARSE` or `FINE` permission is `GRANTED` but `BACKGROUND_LOCATION` permission is not `GRANTED`, will return `GRANTED_WHEN_IN_USE`.
 
-    cordova.plugins.diagnostic.getLocationAuthorizationStatus(successCallback, errorCallback);    
-    
+```
+cordova.plugins.diagnostic.getLocationAuthorizationStatus(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1318,19 +1417,19 @@ The function is passed a single string parameter containing the error message.
     }, function(error){
         console.error(error);
     });
-    
+
 ### getLocationAuthorizationStatuses()
 
 Platforms: Android
 
 Returns the individual location authorization status for each type of location access (`FINE`, `COARSE` and `BACKGROUND`).
 
- - Calling on Android 5.1 / API 22 and below will always return `GRANTED` status as permissions are already granted at installation time.
- - Calling on Android 9 / API 28 and below, `BACKGROUND_LOCATION` permission is always implicitly `GRANTED`.
+- Calling on Android 5.1 / API 22 and below will always return `GRANTED` status as permissions are already granted at installation time.
+- Calling on Android 9 / API 28 and below, `BACKGROUND_LOCATION` permission is always implicitly `GRANTED`.
 
-
-    cordova.plugins.diagnostic.getLocationAuthorizationStatus(successCallback, errorCallback);    
-    
+```
+cordova.plugins.diagnostic.getLocationAuthorizationStatuses(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1339,22 +1438,23 @@ The function is passed a single array parameter which contains a list indicating
 - {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.
 
-
-    cordova.plugins.diagnostic.getLocationAuthorizationStatuses(function(statuses){
-        console.log("FINE permission status: " + statuses[cordova.plugins.diagnostic.permission.ACCESS_FINE_LOCATION])
-        console.log("COARSE permission status: " + statuses[cordova.plugins.diagnostic.permission.ACCESS_COARSE_LOCATION])
-        console.log("BACKGROUND permission status: " + statuses[cordova.plugins.diagnostic.permission.ACCESS_BACKGROUND_LOCATION])
-    }, function(error){
-        console.error(error);
-    });    
+```
+cordova.plugins.diagnostic.getLocationAuthorizationStatuses(function(statuses){
+    console.log("FINE permission status: " + statuses[cordova.plugins.diagnostic.permission.ACCESS_FINE_LOCATION])
+    console.log("COARSE permission status: " + statuses[cordova.plugins.diagnostic.permission.ACCESS_COARSE_LOCATION])
+    console.log("BACKGROUND permission status: " + statuses[cordova.plugins.diagnostic.permission.ACCESS_BACKGROUND_LOCATION])
+}, function(error){
+    console.error(error);
+});
+```
 
 ### requestLocationAuthorization()
 
- Platforms: Android and iOS
+Platforms: Android and iOS
 
- Requests location authorization for the application.
+Requests location authorization for the application.
 
- Notes for iOS:
+Notes for iOS:
 
 - Authorization can be requested to use location either "when in use" (only in foreground) or "always" (foreground and background).
 - This should only be called if authorization status is `NOT_REQUESTED` - calling it when in any other state will have no effect.
@@ -1370,7 +1470,7 @@ this plugin provides default messages, but you should override them with your sp
 | WHEN_IN_USE | Allow While Using App | `kCLAuthorizationStatusAuthorizedWhenInUse` | `GRANTED_WHEN_IN_USE` |
 | WHEN_IN_USE | Allow Once | `kCLAuthorizationStatusAuthorizedWhenInUse` | `GRANTED_WHEN_IN_USE` |
 
- Notes for Android:
+Notes for Android:
 
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will have no effect as the permissions are already granted at installation time.
 - For Android 11+ / API 30+), make an initial request with `mode` set to `cordova.plugins.diagnostic.locationAuthorizationMode.ALWAYS` will NOT present the user with a dialog at all and immediately returns a `DENIED` result.
@@ -1381,12 +1481,14 @@ this plugin provides default messages, but you should override them with your sp
 - When the plugin is running on/built with Android 12+ / API 31+, you can specify requested location accuracy using the `accuracy` parameter.
     - If the build SDK/device version is <= Android 11 / API 30, `FULL` accuracy is implicitly granted.
 
-    `cordova.plugins.diagnostic.requestLocationAuthorization(successCallback, errorCallback, mode, accuracy);`
+```
+cordova.plugins.diagnostic.requestLocationAuthorization(successCallback, errorCallback, mode, accuracy);
+```
 
 #### Parameters
 
 - {Function} successCallback - Invoked in response to the user's choice in the permission dialog.
-     - It is passed a single string parameter which defines the [resulting authorisation status](#runtime-permission-statuses).
+    - It is passed a single string parameter which defines the [resulting authorisation status](#runtime-permission-statuses).
 - {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.
 - {String} mode - (optional / iOS & Android >= 10) location authorization mode specified as a [locationAuthorizationMode constant](#locationauthorizationmode-constants).
@@ -1454,7 +1556,7 @@ On iOS, the function is passed a single string parameter indicating the new loca
 
 ### getLocationAccuracyAuthorization()
 
-Platforms: Android & iOS 
+Platforms: Android & iOS
 
 Returns the location accuracy authorization for the application on iOS 14+ and Android 12+.
 Note: calling on iOS <14 or Android <12 will always return `cordova.plugins.diagnostic.locationAccuracyAuthorization.FULL`.
@@ -1510,8 +1612,9 @@ You'll need to add this entry using a `<config-file>` block in your `config.xml`
 - Should only be called if location authorization has been granted, otherwise `errorCallback` will be invoked.
 - See [requestTemporaryFullAccuracyAuthorizationWithPurposeKey](https://developer.apple.com/documentation/corelocation/cllocationmanager/3600217-requesttemporaryfullaccuracyauth?language=objc).
 
-
-    `cordova.plugins.diagnostic.requestTemporaryFullAccuracyAuthorization(purpose, successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.requestTemporaryFullAccuracyAuthorization(purpose, successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1595,7 +1698,7 @@ Platforms: Android and iOS
 
 Defines constants for the various Bluetooth hardware states
 
-        cordova.plugins.diagnostic.bluetoothState
+    cordova.plugins.diagnostic.bluetoothState
 
 #### Android
 
@@ -1824,10 +1927,11 @@ Android:
 
 iOS:
 - On iOS 13+ returns the Bluetooth authorization status of application
-- On iOS 12 and below, always return GRANTED as Bluetooth permission is not required. 
+- On iOS 12 and below, always return GRANTED as Bluetooth permission is not required.
 
-
-  cordova.plugins.diagnostic.getBluetoothAuthorizationStatus(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.getBluetoothAuthorizationStatus(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1844,7 +1948,7 @@ iOS:
         }
     }, function(error){
         console.error(error);
-    }); 
+    });
 
 ### getBluetoothAuthorizationStatuses()
 
@@ -1853,7 +1957,9 @@ Platforms: Android
 - Returns the individual authorization status for each Bluetooth run-time permission on Android 12+ / API 31+
 - On Android 11 / API 30 and below, all will be returned as GRANTED if the manifest has BLUETOOTH since they are implicitly granted at build-time.
 
-  cordova.plugins.diagnostic.getBluetoothAuthorizationStatuses(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.getBluetoothAuthorizationStatuses(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1887,7 +1993,9 @@ Notes for iOS:
 - When calling this function, the message contained in the `NSBluetoothPeripheralUsageDescription` .plist key is displayed to the user;
 this plugin provides a default message, but you should override this with your specific reason for requesting access - see the [iOS usage description messages](#ios-usage-description-messages) section for how to customise it.
 
-    cordova.plugins.diagnostic.requestBluetoothAuthorization(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.requestBluetoothAuthorization(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -1930,9 +2038,9 @@ The function is passed a single string parameter which indicates the Bluetooth s
 #### Example usage
 
     cordova.plugins.diagnostic.registerBluetoothStateChangeHandler(function(state){
-       if(state === cordova.plugins.diagnostic.bluetoothState.POWERED_ON){
-           console.log("Bluetooth is able to connect");
-       }
+        if(state === cordova.plugins.diagnostic.bluetoothState.POWERED_ON){
+            console.log("Bluetooth is able to connect");
+        }
     });
 
 
@@ -2088,10 +2196,11 @@ Notes for Android:
 - On Android by default this checks run-time permission for both `READ_EXTERNAL_STORAGE` and `CAMERA` because [cordova-plugin-camera@2.2+](https://github.com/apache/cordova-plugin-camera) requires both of these permissions.
 - The call signature `cordova.plugins.diagnostic.isCameraAvailable(successCallback, errorCallback, externalStorage)` is also supported for benefit of the [ionic-native Promise API wrapper](https://github.com/driftyco/ionic-native/blob/master/src/%40ionic-native/plugins/diagnostic/index.ts).
 
-
-    cordova.plugins.diagnostic.isCameraAvailable(params);
-    cordova.plugins.diagnostic.isCameraAvailable(successCallback, errorCallback, params)
-    cordova.plugins.diagnostic.isCameraAvailable(successCallback, errorCallback, externalStorage)
+```
+cordova.plugins.diagnostic.isCameraAvailable(params);
+cordova.plugins.diagnostic.isCameraAvailable(successCallback, errorCallback, params)
+cordova.plugins.diagnostic.isCameraAvailable(successCallback, errorCallback, externalStorage)
+```
 
 #### Parameters
 - {Object} params - (optional) parameters:
@@ -2144,10 +2253,11 @@ Notes for Android:
 - By default this checks run-time permission for both `READ_EXTERNAL_STORAGE` and `CAMERA` because [cordova-plugin-camera@2.2+](https://github.com/apache/cordova-plugin-camera) requires both of these permissions.
 - The call signature `cordova.plugins.diagnostic.isCameraAuthorized(successCallback, errorCallback, externalStorage)` is also supported for benefit of the [ionic-native Promise API wrapper](https://github.com/driftyco/ionic-native/blob/master/src/%40ionic-native/plugins/diagnostic/index.ts).
 
-
-    cordova.plugins.diagnostic.isCameraAuthorized(params);
-    cordova.plugins.diagnostic.isCameraAuthorized(successCallback, errorCallback, params)
-    cordova.plugins.diagnostic.isCameraAuthorized(successCallback, errorCallback, externalStorage)
+```
+cordova.plugins.diagnostic.isCameraAuthorized(params);
+cordova.plugins.diagnostic.isCameraAuthorized(successCallback, errorCallback, params)
+cordova.plugins.diagnostic.isCameraAuthorized(successCallback, errorCallback, externalStorage)
+```
 
 #### Parameters
 - {Object} params - (optional) parameters:
@@ -2199,10 +2309,11 @@ Notes for Android:
 - By default this checks run-time permission for both `READ_EXTERNAL_STORAGE` and `CAMERA` because [cordova-plugin-camera@2.2+](https://github.com/apache/cordova-plugin-camera) requires both of these permissions.
 - The call signature `cordova.plugins.diagnostic.getCameraAuthorizationStatus(successCallback, errorCallback, externalStorage)` is also supported for benefit of the [ionic-native Promise API wrapper](https://github.com/driftyco/ionic-native/blob/master/src/%40ionic-native/plugins/diagnostic/index.ts).
 
-
-    cordova.plugins.diagnostic.getCameraAuthorizationStatus(params);
-    cordova.plugins.diagnostic.getCameraAuthorizationStatus(successCallback, errorCallback, params)
-    cordova.plugins.diagnostic.getCameraAuthorizationStatus(successCallback, errorCallback, externalStorage)
+```
+cordova.plugins.diagnostic.getCameraAuthorizationStatus(params);
+cordova.plugins.diagnostic.getCameraAuthorizationStatus(successCallback, errorCallback, params)
+cordova.plugins.diagnostic.getCameraAuthorizationStatus(successCallback, errorCallback, externalStorage)
+```
 
 #### Parameters
 - {Object} params - (optional) parameters:
@@ -2268,10 +2379,11 @@ Notes for Android:
 - Requested run-time permissions which must be added to `AndroidManifest.xml` - see [Android camera permissions](#android-camera-permissions).
 - The call signature `cordova.plugins.diagnostic.requestCameraAuthorization(successCallback, errorCallback, externalStorage)` is also supported for benefit of the [ionic-native Promise API wrapper](https://github.com/driftyco/ionic-native/blob/master/src/%40ionic-native/plugins/diagnostic/index.ts).
 
-
-    cordova.plugins.diagnostic.requestCameraAuthorization(params);
-    cordova.plugins.diagnostic.requestCameraAuthorization(successCallback, errorCallback, params)
-    cordova.plugins.diagnostic.requestCameraAuthorization(successCallback, errorCallback, externalStorage)
+```
+cordova.plugins.diagnostic.requestCameraAuthorization(params);
+cordova.plugins.diagnostic.requestCameraAuthorization(successCallback, errorCallback, params)
+cordova.plugins.diagnostic.requestCameraAuthorization(successCallback, errorCallback, externalStorage)
+```
 
 #### Parameters
 
@@ -2693,7 +2805,9 @@ Checks if the application is authorized to use the microphone.
 Notes for Android:
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return TRUE as permissions are already granted at installation time.
 
-    `cordova.plugins.diagnostic.isMicrophoneAuthorized(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.isMicrophoneAuthorized(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -2720,8 +2834,9 @@ Returns the microphone authorization status for the application.
 Notes for Android:
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
 
-
-    `cordova.plugins.diagnostic.getMicrophoneAuthorizationStatus(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.getMicrophoneAuthorizationStatus(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -2755,7 +2870,9 @@ Notes for Android:
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will have no effect as the permissions are already granted at installation time.
 - This requests permission for `RECORD_AUDIO` which must be added to `AndroidManifest.xml` - see [Android permissions](#android-permissions).
 
-    cordova.plugins.diagnostic.requestMicrophoneAuthorization(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.requestMicrophoneAuthorization(successCallback, errorCallback);
+```
 
 #### Parameters
 - {Function} successCallback - The callback which will be called when operation is successful.
@@ -2790,7 +2907,9 @@ Checks if the application is authorized to use contacts (address book).
 Notes for Android:
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return TRUE as permissions are already granted at installation time.
 
-    `cordova.plugins.diagnostic.isContactsAuthorized(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.isContactsAuthorized(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -2817,7 +2936,9 @@ Returns the contacts authorization status for the application.
 Notes for Android:
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
 
-    `cordova.plugins.diagnostic.getContactsAuthorizationStatus(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.getContactsAuthorizationStatus(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -2852,7 +2973,9 @@ Notes for Android:
 - This requests permission for `READ_CONTACTS` run-time permission
 - Required permissions must be added to `AndroidManifest.xml` as appropriate - see [Android permissions](#android-permissions): `READ_CONTACTS, WRITE_CONTACTS, GET_ACCOUNTS`
 
-    cordova.plugins.diagnostic.requestContactsAuthorization(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.requestContactsAuthorization(successCallback, errorCallback);
+```
 
 #### Parameters
 - {Function} successCallback - The callback which will be called when operation is successful.
@@ -2891,7 +3014,9 @@ Notes for Android:
 Notes for iOS:
 - This relates to Calendar Events (not Calendar Reminders)
 
-    `cordova.plugins.diagnostic.isCalendarAuthorized(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.isCalendarAuthorized(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -2921,7 +3046,9 @@ Notes for Android:
 Notes for iOS:
 - This relates to Calendar Events (not Calendar Reminders)
 
-    `cordova.plugins.diagnostic.getCalendarAuthorizationStatus(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.getCalendarAuthorizationStatus(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -2957,7 +3084,9 @@ Notes for Android:
 - This requests permission for `READ_CALENDAR` run-time permission
 - Required permissions must be added to `AndroidManifest.xml` as appropriate - see [Android permissions](#android-permissions): `READ_CALENDAR, WRITE_CALENDAR`
 
-    cordova.plugins.diagnostic.requestCalendarAuthorization(successCallback, errorCallback);
+```
+cordova.plugins.diagnostic.requestCalendarAuthorization(successCallback, errorCallback);
+```
 
 #### Parameters
 - {Function} successCallback - The callback which will be called when operation is successful.
@@ -3247,11 +3376,11 @@ Defines constants for the various NFC power states.
 
 #### Values
 
-- `UNKNOWN` - Bluetooth hardware state is unknown or unavailable
-- `POWERED_OFF` - Bluetooth hardware is switched off
-- `POWERED_ON` - Bluetooth hardware is switched on and available for use
-- `POWERING_OFF`- Bluetooth hardware is currently switching off
-- `POWERING_ON`- Bluetooth hardware is currently switching on
+- `UNKNOWN` - NFC hardware state is unknown or unavailable
+- `POWERED_OFF` - NFC hardware is switched off
+- `POWERED_ON` - NFC hardware is switched on and available for use
+- `POWERING_OFF`- NFC hardware is currently switching off
+- `POWERING_ON`- NFC hardware is currently switching on
 
 #### Example
 
@@ -3312,7 +3441,7 @@ Checks if the device setting for NFC is switched on.
 
 Note: this operation **does not** require NFC permission in the manifest.
 
-    cordova.plugins.diagnostic.isNFCAvailable(successCallback, errorCallback);
+    cordova.plugins.diagnostic.isNFCEnabled(successCallback, errorCallback);
 
 #### Parameters
 
@@ -3407,7 +3536,9 @@ Notes for Android:
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return TRUE as permissions are already granted at installation time.
 - This checks for `READ_EXTERNAL_STORAGE` `CAMERA` run-time permission.
 
-    `cordova.plugins.diagnostic.isExternalStorageAuthorized(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.isExternalStorageAuthorized(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -3435,7 +3566,9 @@ Notes for Android:
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will always return GRANTED status as permissions are already granted at installation time.
 - This checks for `READ_EXTERNAL_STORAGE` run-time permission.
 
-    `cordova.plugins.diagnostic.getExternalStorageAuthorizationStatus(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.getExternalStorageAuthorizationStatus(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -3463,7 +3596,9 @@ Requests external storage authorization for the application.
 - This is intended for Android 6 / API 23 and above. Calling on Android 5.1 / API 22 and below will have no effect as the permissions are already granted at installation time.
 - This requests permission for `READ_EXTERNAL_STORAGE` run-time permission which must be added to `AndroidManifest.xml`.
 
-    `cordova.plugins.diagnostic.requestExternalStorageAuthorization(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.requestExternalStorageAuthorization(successCallback, errorCallback);
+```
 
 #### Parameters
 
@@ -3492,34 +3627,36 @@ This differs from the "external directories" returned by [cordova-plugin-file](h
 
 For example, on a Samsung Galaxy S4 running Android 7.1.1:
 
- - `cordova.file.externalRootDirectory` returns `file:///storage/emulated/0/`
- - `cordova.file.externalApplicationStorageDirectory` returns `file:///storage/emulated/0/Android/data/cordova.plugins.diagnostic.example/`
+- `cordova.file.externalRootDirectory` returns `file:///storage/emulated/0/`
+- `cordova.file.externalApplicationStorageDirectory` returns `file:///storage/emulated/0/Android/data/cordova.plugins.diagnostic.example/`
 
- which are on non-removable internal storage.
+which are on non-removable internal storage.
 
- Whereas this method returns:
+Whereas this method returns:
 
-    ```
-    [{
-        "path": "/storage/4975-1401/Android/data/cordova.plugins.diagnostic.example/files",
-        "filePath": "file:///storage/4975-1401/Android/data/cordova.plugins.diagnostic.example/files",
-        "canWrite": true,
-        "freeSpace": 16254009344,
-        "type": "application"
-    }, {
-        "path": "/storage/4975-1401",
-        "filePath": "file:///storage/4975-1401",
-        "canWrite": false,
-        "freeSpace": 16254009344,
-        "type": "root"
-    }]
-    ```
+```
+[{
+    "path": "/storage/4975-1401/Android/data/cordova.plugins.diagnostic.example/files",
+    "filePath": "file:///storage/4975-1401/Android/data/cordova.plugins.diagnostic.example/files",
+    "canWrite": true,
+    "freeSpace": 16254009344,
+    "type": "application"
+}, {
+    "path": "/storage/4975-1401",
+    "filePath": "file:///storage/4975-1401",
+    "canWrite": false,
+    "freeSpace": 16254009344,
+    "type": "root"
+}]
+```
 
- which are on external removable storage.
+which are on external removable storage.
 
 - Requires permission for `READ_EXTERNAL_STORAGE` run-time permission which must be added to `AndroidManifest.xml`.
 
-    `cordova.plugins.diagnostic.getExternalSdCardDetails(successCallback, errorCallback);`
+```
+cordova.plugins.diagnostic.getExternalSdCardDetails(successCallback, errorCallback);
+```
 
 - Note: this function is intended to find paths of external removable SD cards on which the SD card adapter is directly mounted on the device, such as those in the Samsung Galaxy S range of devices. It explicitly attempts to filter out non-SD card storage paths such as OTG devices since access to these devices on Android 6.+ via the File API requires root access and normal access requires use of the Storage Access Framework.
 

package/cordova.plugins.diagnostic.d.ts

@@ -305,6 +305,55 @@ interface Diagnostic {
         successCallback: () => void
     ) => void;
 
+
+    /**
+     * ANDROID ONLY
+     *
+     * Checks if airplane mode is enabled on device.
+     *
+     * @param successCallback
+     * @param errorCallback
+     */
+    isAirplaneModeEnabled?: (
+        successCallback: () => boolean,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * ANDROID ONLY
+     *
+     * Checks if mobile data is enabled on device.
+     *
+     * @param successCallback
+     * @param errorCallback
+     */
+    isMobileDataEnabled?: (
+        successCallback: () => boolean,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * Returns details of the OS of the device on which the app is currently running
+     *
+     * @param successCallback
+     * @param errorCallback
+     */
+    getDeviceOSVersion?: (
+        successCallback: (details: {version: string, apiLevel: number, apiName: string}) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
+    /**
+     * Returns details of the SDK levels used to build the app.
+     *
+     * @param successCallback
+     * @param errorCallback
+     */
+    getBuildOSVersion?: (
+        successCallback: (details: {targetApiLevel: number, targetApiName: string, minApiLevel: number, minApiName: string}) => void,
+        errorCallback: (error: string) => void
+    ) => void;
+
     /**
      * Returns true if the device setting for location is on.
      * On Android this returns true if Location Mode is switched on.

package/package.json

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

package/src/android/Diagnostic.java

@@ -26,6 +26,7 @@ import static android.content.Context.BATTERY_SERVICE;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.InputStreamReader;
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.HashMap;
@@ -47,7 +48,9 @@ import android.app.Activity;
 import android.app.AlarmManager;
 import android.app.PendingIntent;
 import android.content.SharedPreferences;
+import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
+import android.net.ConnectivityManager;
 import android.net.Uri;
 import android.os.BatteryManager;
 import android.os.Build;
@@ -276,6 +279,8 @@ public class Diagnostic extends CordovaPlugin{
                 callbackContext.success(isADBModeEnabled() ? 1 : 0);
             } else if(action.equals("isDeviceRooted")) {
                 callbackContext.success(isDeviceRooted() ? 1 : 0);
+            } else if(action.equals("isMobileDataEnabled")) {
+                callbackContext.success(isMobileDataEnabled() ? 1 : 0);
             } else if(action.equals("restart")) {
                 this.restart(args);
             } else if(action.equals("getArchitecture")) {
@@ -284,6 +289,10 @@ public class Diagnostic extends CordovaPlugin{
                 callbackContext.success(getCurrentBatteryLevel());
             } else if(action.equals("isAirplaneModeEnabled")) {
                 callbackContext.success(isAirplaneModeEnabled() ? 1 : 0);
+            } else if(action.equals("getDeviceOSVersion")) {
+                callbackContext.success(getDeviceOSVersion());
+            } else if(action.equals("getBuildOSVersion")) {
+                callbackContext.success(getBuildOSVersion());
             } else {
                 handleError("Invalid action");
                 return false;
@@ -439,12 +448,27 @@ public class Diagnostic extends CordovaPlugin{
         return false;
     }
 
+    // https://stackoverflow.com/a/12864897/777265
+    public boolean isMobileDataEnabled(){
+        boolean mobileDataEnabled = false; // Assume disabled
+        ConnectivityManager cm = (ConnectivityManager) cordova.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
+        try {
+            Class cmClass = Class.forName(cm.getClass().getName());
+            Method method = cmClass.getDeclaredMethod("getMobileDataEnabled");
+            method.setAccessible(true);
+            mobileDataEnabled = (Boolean)method.invoke(cm);
+        } catch (Exception e) {
+            logDebug(e.getMessage());
+        }
+        return mobileDataEnabled;
+    }
 
     /************
      * Internals
      ***********/
 
     public void logDebug(String msg) {
+        if(msg == null) return;
         if(debugEnabled){
             Log.d(TAG, msg);
             executeGlobalJavascript("console.log(\""+TAG+"[native]: "+escapeDoubleQuotes(msg)+"\")");
@@ -452,6 +476,7 @@ public class Diagnostic extends CordovaPlugin{
     }
 
     public void logInfo(String msg){
+        if(msg == null) return;
         Log.i(TAG, msg);
         if(debugEnabled){
             executeGlobalJavascript("console.info(\""+TAG+"[native]: "+escapeDoubleQuotes(msg)+"\")");
@@ -459,6 +484,7 @@ public class Diagnostic extends CordovaPlugin{
     }
 
     public void logWarning(String msg){
+        if(msg == null) return;
         Log.w(TAG, msg);
         if(debugEnabled){
             executeGlobalJavascript("console.warn(\""+TAG+"[native]: "+escapeDoubleQuotes(msg)+"\")");
@@ -466,6 +492,7 @@ public class Diagnostic extends CordovaPlugin{
     }
 
     public void logError(String msg){
+        if(msg == null) return;
         Log.e(TAG, msg);
         if(debugEnabled){
             executeGlobalJavascript("console.error(\""+TAG+"[native]: "+escapeDoubleQuotes(msg)+"\")");
@@ -823,7 +850,45 @@ public class Diagnostic extends CordovaPlugin{
                 Settings.Global.AIRPLANE_MODE_ON, 0) != 0;
     }
 
+    public JSONObject getDeviceOSVersion() throws Exception{
+        JSONObject details = new JSONObject();
+        details.put("version", Build.VERSION.RELEASE);
+        details.put("apiLevel", Build.VERSION.SDK_INT);
+        details.put("apiName", getNameForApiLevel(Build.VERSION.SDK_INT));
+        return details;
+    }
+
+    public JSONObject getBuildOSVersion() throws Exception{
+        JSONObject details = new JSONObject();
+        int targetVersion = 0;
+        int minVersion = 0;
+        Activity activity = instance.cordova.getActivity();
+        ApplicationInfo applicationInfo = activity.getPackageManager().getApplicationInfo(activity.getPackageName(), 0);
+        if (applicationInfo != null) {
+            targetVersion = applicationInfo.targetSdkVersion;
+            if(Build.VERSION.SDK_INT >= 24){
+                minVersion = applicationInfo.minSdkVersion;
+            }
+        }
+
+        details.put("targetApiLevel", targetVersion);
+        details.put("targetApiName", getNameForApiLevel(targetVersion));
+        details.put("minApiLevel", minVersion);
+        details.put("minApiName", getNameForApiLevel(minVersion));
+        return details;
+    }
 
+    // https://stackoverflow.com/a/55946200/777265
+    protected String getNameForApiLevel(int apiLevel) throws Exception{
+        Field[] fields = Build.VERSION_CODES.class.getFields();
+        String codeName = "UNKNOWN";
+        for (Field field : fields) {
+            if (field.getInt(Build.VERSION_CODES.class) == apiLevel) {
+                codeName = field.getName();
+            }
+        }
+        return codeName;
+    }
 
     /************
      * Overrides

package/src/ios/Diagnostic.h

@@ -35,6 +35,9 @@ extern NSString*const AUTHORIZATION_LIMITED;
 - (void) getBackgroundRefreshStatus: (CDVInvokedUrlCommand*)command;
 - (void) getArchitecture: (CDVInvokedUrlCommand*)command;
 - (void) getCurrentBatteryLevel: (CDVInvokedUrlCommand*)command;
+- (void) getDeviceOSVersion: (CDVInvokedUrlCommand*)command;
+- (void) getBuildOSVersion: (CDVInvokedUrlCommand*)command;
+- (void) isMobileDataEnabled: (CDVInvokedUrlCommand*)command;
 
 // Utilities
 + (id) getInstance;

package/src/ios/Diagnostic.m

@@ -7,6 +7,7 @@
  */
 
 #import "Diagnostic.h"
+#import <CoreTelephony/CTCellularData.h>
 
 @implementation Diagnostic
 
@@ -29,7 +30,9 @@ static NSString*const CPU_ARCH_ARMv8 = @"ARMv8";
 static NSString*const CPU_ARCH_X86 = @"X86";
 static NSString*const CPU_ARCH_X86_64 = @"X86_64";
 
+// Internal properties
 static Diagnostic* diagnostic = nil;
+static CTCellularData* cellularData;
 
 /********************************/
 #pragma mark - Public static functions
@@ -111,6 +114,7 @@ static Diagnostic* diagnostic = nil;
 
     self.debugEnabled = false;
     self.osVersion = [[[UIDevice currentDevice] systemVersion] floatValue];
+    cellularData = [[CTCellularData alloc] init];
 }
 
 // https://stackoverflow.com/a/38441011/777265
@@ -171,6 +175,60 @@ static Diagnostic* diagnostic = nil;
     }];
 }
 
+- (void) getDeviceOSVersion: (CDVInvokedUrlCommand*)command {
+    [self.commandDelegate runInBackground:^{
+        @try {
+            NSString* s_version = [UIDevice currentDevice].systemVersion;
+            float f_version = [s_version floatValue];
+            
+            NSDictionary* details = @{
+                @"version": s_version,
+                @"apiLevel" : [NSNumber numberWithFloat:f_version*10000],
+                @"apiName": s_version
+            };
+              
+            [self sendPluginResultObject:details:command];
+        }@catch (NSException *exception) {
+            [self handlePluginException:exception :command];
+        }
+    }];
+}
+
+- (void) getBuildOSVersion: (CDVInvokedUrlCommand*)command {
+    [self.commandDelegate runInBackground:^{
+        @try {
+            int i_min_version = __IPHONE_OS_VERSION_MIN_REQUIRED;
+            NSString* s_min_version = [NSString stringWithFormat:@"%.01f", (float) i_min_version/10000];
+            int i_target_version = __IPHONE_OS_VERSION_MAX_ALLOWED;
+            NSString* s_target_version = [NSString stringWithFormat:@"%.01f", (float) i_target_version/10000];
+            
+            NSDictionary* details = @{
+                @"targetApiLevel": [NSNumber numberWithInt:i_target_version],
+                @"targetApiName": s_target_version,
+                @"minApiLevel": [NSNumber numberWithInt:i_min_version],
+                @"minApiName": s_min_version
+            };
+              
+            [self sendPluginResultObject:details:command];
+        }@catch (NSException *exception) {
+            [self handlePluginException:exception :command];
+        }
+    }];
+}
+
+- (void) isMobileDataEnabled: (CDVInvokedUrlCommand*)command
+{
+    [self.commandDelegate runInBackground:^{
+        @try {
+            bool isEnabled = cellularData.restrictedState == kCTCellularDataNotRestricted;;
+            [diagnostic sendPluginResultBool:isEnabled :command];
+        }
+        @catch (NSException *exception) {
+            [diagnostic handlePluginException:exception :command];
+        }
+    }];
+}
+
 
 /********************************/
 #pragma mark - Send results
@@ -214,6 +272,12 @@ static Diagnostic* diagnostic = nil;
     [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
 }
 
+- (void) sendPluginResultObject: (NSDictionary*)result :(CDVInvokedUrlCommand*)command
+{
+    CDVPluginResult* pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsDictionary:result];
+    [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
+}
+
 - (void) sendPluginError: (NSString*) errorMessage :(CDVInvokedUrlCommand*)command
 {
     CDVPluginResult* pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR messageAsString:errorMessage];

package/src/ios/Diagnostic_Bluetooth.m

@@ -65,20 +65,17 @@ static NSString*const LOG_TAG = @"Diagnostic_Bluetooth[native]";
 {
     [self.commandDelegate runInBackground:^{
         @try {
-            NSString* state = [self getBluetoothState];
-
-            if([state isEqual: @"unauthorized"]){
-                /*
-                 When the application requests to start scanning for bluetooth devices that is when the user is presented with a consent dialog.
-                 */
-                [diagnostic logDebug:@"Requesting bluetooth authorization"];
-                [self ensureBluetoothManager];
-                [self.bluetoothManager scanForPeripheralsWithServices:nil options:nil];
-                [self.bluetoothManager stopScan];
-            }else{
-                [diagnostic logDebug:@"Bluetooth authorization is already granted"];
+            
+            NSString* authState = [self getAuthorizationStatus];
+            
+            if([authState isEqual:AUTHORIZATION_GRANTED]){
+                [diagnostic sendPluginError:@"Bluetooth authorization is already granted" :command];
+            }else if([authState isEqual:AUTHORIZATION_DENIED]){
+                [diagnostic sendPluginError:@"Bluetooth authorization has been denied" :command];
+            }else{ // AUTHORIZATION_NOT_DETERMINED
+                [self ensureBluetoothManager]; // invoke Bluetooth manager to trigger permission dialog
+                [diagnostic sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK] :command];
             }
-            [diagnostic sendPluginResult:[CDVPluginResult resultWithStatus:CDVCommandStatus_OK] :command];
         }
         @catch (NSException *exception) {
             [diagnostic handlePluginException:exception :command];

package/www/android/diagnostic.js

@@ -473,6 +473,61 @@ var Diagnostic = (function(){
             []);
     };
 
+    /**
+     * Checks if mobile data is enabled on device.
+     *
+     * @param {Function} successCallback -  The callback which will be called when the operation is successful.
+     * This callback function is passed a single boolean parameter which is TRUE if mobile data is enabled.
+     * @param {Function} errorCallback -  The callback which will be called when the operation encounters an error.
+     *  This callback function is passed a single string parameter containing the error message.
+     */
+    Diagnostic.isMobileDataEnabled = function(successCallback, errorCallback) {
+        return cordova.exec(Diagnostic._ensureBoolean(successCallback),
+            errorCallback,
+            'Diagnostic',
+            'isMobileDataEnabled',
+            []);
+    };
+
+    /**
+     * Returns details of the OS of the device on which the app is currently running
+     *
+     * @param {Function} successCallback -  The callback which will be called when the operation is successful.
+     * This callback function is passed a single object parameter with the following fields:
+     * - {string} version - version string of the OS e.g. "11.0"
+     * - {integer} apiLevel - API level of the OS e.g. 30
+     * - {string} apiName - code name for API level e.g. "FROYO"
+     * @param {Function} errorCallback -  The callback which will be called when the operation encounters an error.
+     *  This callback function is passed a single string parameter containing the error message.
+     */
+    Diagnostic.getDeviceOSVersion = function(successCallback, errorCallback) {
+        return cordova.exec(successCallback,
+            errorCallback,
+            'Diagnostic',
+            'getDeviceOSVersion',
+            []);
+    };
+
+    /**
+     * Returns details of the SDK levels used to build the app.
+     *
+     * @param {Function} successCallback -  The callback which will be called when the operation is successful.
+     * This callback function is passed a single object parameter with the following fields:
+     * - {integer} targetApiLevel - API level of the target SDK (used to build the app)
+     * - {string} targetApiName - code name for API level of the target SDK e.g. "FROYO"
+     * - {integer} minApiLevel - API level of the minimum SDK (lowest on which the app can be installed)
+     * - {string} minApiName - code name for API level of the minimum SDK e.g. "FROYO"
+     * @param {Function} errorCallback -  The callback which will be called when the operation encounters an error.
+     *  This callback function is passed a single string parameter containing the error message.
+     */
+    Diagnostic.getBuildOSVersion = function(successCallback, errorCallback) {
+        return cordova.exec(successCallback,
+            errorCallback,
+            'Diagnostic',
+            'getBuildOSVersion',
+            []);
+    };
+
     /************
      * Location *
      ************/

package/www/ios/diagnostic.camera.js

@@ -210,8 +210,7 @@ var Diagnostic_Camera = (function(){
      * Should only be called if authorization status is NOT_REQUESTED. Calling it when in any other state will have no effect.
      *
      * @param {Function} successCallback - The callback which will be called when operation is successful.
-     * This callback function is passed a single string parameter indicating the new authorization status:
-     * `cordova.plugins.diagnostic.permissionStatus.GRANTED` or `cordova.plugins.diagnostic.permissionStatus.DENIED_ALWAYS`
+     * This callback function is passed a single string parameter indicating the new authorization status
      * @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 {Function} accessLevel - (optional) On iOS 14+, specifies the level of access to the photo library to request as a constant in cordova.plugins.diagnostic.photoLibraryAccessLevel`
@@ -222,9 +221,8 @@ var Diagnostic_Camera = (function(){
      * - Has no effect on iOS 13 or below
      */
     Diagnostic_Camera.requestCameraRollAuthorization = function(successCallback, errorCallback, accessLevel) {
-        return cordova.exec(function(status){
-                successCallback(status === "authorized" ? Diagnostic.permissionStatus.GRANTED : Diagnostic.permissionStatus.DENIED_ALWAYS);
-            },
+        return cordova.exec(
+            successCallback,
             errorCallback,
             'Diagnostic_Camera',
             'requestCameraRollAuthorization',

package/www/ios/diagnostic.js

@@ -153,6 +153,61 @@ var Diagnostic = (function(){
             []);
     };
 
+    /**
+     * Checks if mobile data is enabled on device.
+     *
+     * @param {Function} successCallback -  The callback which will be called when the operation is successful.
+     * This callback function is passed a single boolean parameter which is TRUE if mobile data is enabled.
+     * @param {Function} errorCallback -  The callback which will be called when the operation encounters an error.
+     *  This callback function is passed a single string parameter containing the error message.
+     */
+    Diagnostic.isMobileDataEnabled = function(successCallback, errorCallback) {
+        return cordova.exec(Diagnostic._ensureBoolean(successCallback),
+            errorCallback,
+            'Diagnostic',
+            'isMobileDataEnabled',
+            []);
+    };
+
+    /**
+     * Returns details of the OS of the device on which the app is currently running
+     *
+     * @param {Function} successCallback -  The callback which will be called when the operation is successful.
+     * This callback function is passed a single object parameter with the following fields:
+     * - {string} version - version string of the OS e.g. "11.0"
+     * - {integer} apiLevel - API level of the OS e.g. 30
+     * - {string} apiName - code name for API level e.g. "FROYO"
+     * @param {Function} errorCallback -  The callback which will be called when the operation encounters an error.
+     *  This callback function is passed a single string parameter containing the error message.
+     */
+    Diagnostic.getDeviceOSVersion = function(successCallback, errorCallback) {
+        return cordova.exec(successCallback,
+            errorCallback,
+            'Diagnostic',
+            'getDeviceOSVersion',
+            []);
+    };
+
+    /**
+     * Returns details of the SDK levels used to build the app.
+     *
+     * @param {Function} successCallback -  The callback which will be called when the operation is successful.
+     * This callback function is passed a single object parameter with the following fields:
+     * - {integer} targetApiLevel - API level of the target SDK (used to build the app)
+     * - {string} targetApiName - code name for API level of the target SDK e.g. "FROYO"
+     * - {integer} minApiLevel - API level of the minimum SDK (lowest on which the app can be installed)
+     * - {string} minApiName - code name for API level of the minimum SDK e.g. "FROYO"
+     * @param {Function} errorCallback -  The callback which will be called when the operation encounters an error.
+     *  This callback function is passed a single string parameter containing the error message.
+     */
+    Diagnostic.getBuildOSVersion = function(successCallback, errorCallback) {
+        return cordova.exec(successCallback,
+            errorCallback,
+            'Diagnostic',
+            'getBuildOSVersion',
+            []);
+    };
+
     /************
      * Location *
      ************/