Initial commit

CHANGELOG.md

+## 8.2.5
+
+* Fixed broken link in the README.md.
+
+## 8.2.4
+
+* Solved bug where output would log that there is no permission in manifest for BLUETOOTH_SCAN, BLUETOOTH_ADVERTISE and BLUETOOTH_CONNECT on Android 11 devices and lower(see issue [#691](https://github.com/Baseflow/flutter-permission-handler/issues/691)).
+
+## 8.2.3
+
+* iOS: Enhanced the `bluetooth` permission for iOS 13 and up, so the user gets prompted with the "bluetooth" permission dialog (see issue [#591](https://github.com/Baseflow/flutter-permission-handler/issues/591)).
+
+## 8.2.2
+
+* Updated the README.md to mention setting the `compileSdkVersion` to `31`;
+* Added an additional note to version 8.2.0 release notes to inform people to update the `compileSdkVersion`.
+
+## 8.2.1
+
+* Resolved an issue where checking permissions on pre Android M devices always resolved to `PermissionStatus.denied` (see issue [#60](https://github.com/Baseflow/flutter-permission-plugins/issues/60));
+* Updated the url_launcher dependency in the example App to `^6.0.12`.
+
+## 8.2.0
+
+> **IMPORTANT:** when updating to version 8.2.0 make sure to also set the `compileSdkVersion` in the `app/build.gradle` file to `31`.
+
+* Added support for the new Android 12 Bluetooth permissions: BLUETOOTH_SCAN, BLUETOOTH_ADVERTISE and BLUETOOTH_CONNECT.
+* Updated Android compile and target SDK to 31 (Android 12 (S)).
+* Updated Gradle and dependencies of Android project.
+* Updated applicationID of example app
+
+## 8.1.6
+
+* Android: Fixed a `NullPointerException` when changing permissions in the Location Settings intent.
+
+## 8.1.5
+* Android: Fixed deprecation warnings/errors when `compileSdkVersion` was set to 31 (Android S/12).
+
+## 8.1.4+2
+
+* iOS: fixed memory error that occurred on iOS 12.2 and below (see issue [#638](https://github.com/Baseflow/flutter-permission-handler/issues/638)).
+
+## 8.1.4+1
+
+* Fix a bug where after allowing the `location` permission and requesting it again would lead to a memory error.
+
+## 8.1.4
+
+* Fix bug where requesting `locationAlways` permission sometimes returns `PermissionStatus.Denied` instead of `PermissionStatus.Granted`.
+
+## 8.1.3
+
+* Fix bug where `locationAlways` returns `PermanentlyDenied`;
+* Updated the `README.md` for requesting the `locationAlways` permission the correct way.
+
+## 8.1.2
+
+* Suppress deprecation warnings on iOS for code that specifically targets older iOS versions (see issue [#607](https://github.com/Baseflow/flutter-permission-handler/issues/607)). 
+
+## 8.1.1
+
+* Fixed deprecation issue when checking phone capabilities on iOS (see issue [#597](https://github.com/Baseflow/flutter-permission-handler/issues/597)).
+
+## 8.1.0
+
+* Added support for iOS 12+ Critical Alerts permission requesting.
+    * NOTE: This requires applying to Apple and receiving a special entitlement from them inorder to work. See [this article](https://medium.com/@shashidharyamsani/implementing-ios-critical-alerts-7d82b4bb5026) for an explination on how to use Critical Alerts.
+* Added support for Android M+ Access Notification Policy permission requesting (ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS).
+    * Note: This opens a general page in settings, not specific to the package. 
+
+## 8.0.1
+
+* Updated API documentation for the `PermissionStatus.permanentlyDenied` status.
+
+## 8.0.0+2
+
+* Fix broken Podfile link noted at `8.0.0`.
+* Fix the information link noted at [Podfile](permission_handler/example/ios/Podfile).
+
+## 8.0.0+1
+
+* Updated the README.md setup section about the Podfile and changed a minor spelling mistake.
+
+## 8.0.0
+
+This release contains the following **breaking changes**: 
+* Starting from this version the permissions on iOS are disabled by default. To enable a permission, specify the correct `GCC_PREPROCESSOR_DEFINITIONS` in the `ios/Podfile` file. For an example check out the [Podfile](permission_handler/example/ios/Podfile) of the example application. 
+* Added support for the "AppTrackingTransparency" permission on iOS.
+
+## 7.2.0
+
+* Added support for the "REQUEST_INSTALL_PACKAGES" permission on Android.
+
+## 7.1.1
+
+* Improved the example app by using the Baseflow Plugin Template and move all the functionality to the `main.dart` file.
+
+## 7.1.0
+
+* Added support for the "SYSTEM_ALERT_WINDOW" permission on Android.
+
+## 7.0.0
+
+This release contains the following **breaking changes**: 
+* Updated compile SDK version to 30 in the build.gradle for handling the MANAGE_EXTERNAL_STORAGE permission;
+* Added the MANAGE_EXTERNAL_STORAGE permission for Android R and up;
+* Registered listeners on the plugin level to prevent memory leaks or unwanted behaviour.
+
+## 6.1.3
+
+* Implement equality operator on the `Permission` class;
+* Updated the README.md with instructions on enabling/ disabling the bluetooth permissions on iOS;
+* Corrected some spelling mistakes in the `CHANGELOG.md`.
+
+## 6.1.2
+
+* Correctly handle the ACCESS_MEDIA_LOCATION and ACCESS_ACTIVITY_RECOGNITION permissions on pre Android Q devices (permissions should be implicitly granted on pre Android Q). 
+
+## 6.1.1
+
+* Added unit-tests to guard API against breaking changes.
+
+## 6.1.0
+
+* Added support for bluetooth permissions;
+* Workaround for ignore battery optimizations on pre-M Android devices (see PR [#376](https://github.com/Baseflow/flutter-permission-handler/pull/376)). 
+
+## 6.0.1+1
+
+* Fixed content of the README.md file.
+
+## 6.0.1
+
+* Fixed deprecation warning when building Android project.
+
+## 6.0.0
+
+This release includes the following **breaking changes**:
+* Migrated to null safety 
+* Removed PermissionStatus.undetermined, PermissionStatus.denied will be used instead (see our "[Changes in 6.0.0](https://github.com/Baseflow/flutter-permission-handler/wiki/Changes-in-6.0.0)" wiki page for more details).
+
+## 5.1.0+2
+
+* Solve mismatch with permission constants between Dart and Android (due to addition of permission on iOS);
+* Fix compile error which occurred when on iOS the "PERMISSION_PHOTOS" macro is deactivated (meaning code dealing with the `PHPhotoLibrary` library is removed from the code base).
+
+## 5.1.0+1
+
+* Recreate the iOS part of the example project based on the Flutter stable channel (previous version was accidentally created with the Flutter beta channel).
+
+## 5.1.0
+
+* Added support for the limited photos permission available on iOS 14 and up;
+* Fixed deprecated warning on iOS;
+* Added support for the "READ_PHONE_NUMBERS" permission on Android;
+* Fix a link to the contribution guide in the README.md.
+
+## 5.0.1+2
+
+* Pin dependency on permission_handler_platform_interface on version 2.0.1.
+
+## 5.0.1+1
+
+* Fixes Typo
+* Issue #233 - on 5.0: Solved a bug that prevented Android applications running in the background to check the permission status.
+
+## 5.0.1
+
+* Update `permission_handler_platform_interface 2.0.1`
+
+## 5.0.0+hotfix.10
+
+* Revert pull-request [#317](https://github.com/Baseflow/flutter-permission-handler/pull/317)
+
+## 5.0.0+hotfix.9
+
+* Solved an issue where kCLAuthorizationStatusAuthorizedWhenInUse was returning PermissionStatusDenied (see [#317](https://github.com/Baseflow/flutter-permission-handler/pull/317))
+
+## 5.0.0+hotfix.8
+
+* Solved an issue on iOS where requesting notification permissions returned prematurely (see pull-request [#297](https://github.com/Baseflow/flutter-permission-handler/pull/297))
+
+## 5.0.0+hotfix.7
+
+* ** Mistake release please don't use this version **
+
+## 5.0.0+hotfix.6
+
+* Solved an issue on iOS where requesting notification permissions always resulted in a "granted" result (see pull-request [#289](https://github.com/Baseflow/flutter-permission-handler/pull/289))
+
+## 5.0.0+hotfix.5
+
+* Remove use of the deprecated pre iOS 8 API causing users compile issues (see issue [#277](https://github.com/Baseflow/flutter-permission-handler/issues/277)).
+
+## 5.0.0+hotfix.4
+
+* Solve issue on Android causing an IllegalStateException ([#267](https://github.com/Baseflow/flutter-permission-handler/issues/267)).
+
+## 5.0.0+hotfix.3
+
+* Includes the changes of 4.4.0+hotfix.4 (which was released to be backwards compatible).
+
+## 5.0.0+hotfix.2
+
+* Removed some residual usages of the `PermissionStatusUnknown` constants in #ifdef statements that were not found by the compiler.
+
+## 5.0.0+hotfix.1
+
+* Make sure all enums from `permission_handler_platform_interface: 2.0.0` are exposed through the `permission_handler`.
+
+## 5.0.0
+
+* **BREAKING**: Implemented more intuitive API exposed by `permission_handler_platform_interface: 2.0.0` ([#230](https://github.com/Baseflow/flutter-permission-handler/issues/230)).
+
+## 4.4.0+hotfix.4
+
+* Android: solved issue where `permission_handler` is used in a service (see [#251](https://github.com/Baseflow/flutter-permission-handler/issues/251))
+
+## 4.4.0+hotfix.3
+
+IGNORE THIS VERSION, it was released by accident and contains the same code as 4.4.0+hotfix.2
+
+## 4.4.0+hotfix.2
+
+* Issue #235: Solved a bug which made it impossible to request service status on Android 7;
+* Issue #237: Solved a bug which crashes the application when cancelling the "Ignore battery optimizations" request for permissions.
+
+## 4.4.0+hotfix.1
+
+* Issue #233: Solved a bug that prevented Android applications running in the background to check the permission status.
+
+## 4.4.0
+
+* Updated plugin structure to confirm to the Flutter federated plugin architecture. This will make it easier to add new platform implementations (see: https://medium.com/flutter/how-to-write-a-flutter-web-plugin-part-2-afdddb69ece6);
+* Android: Migrate to FlutterPlugin Android API (better support for Add-to-App);
+* Android: Suppress JAVA warnings which are generated to old platform code (only executes on older platforms);
+* Android: Fixed issue which sometimes resulting in illegal cast exception.
+
+## 4.3.0
+
+* Allow requesting location permissions when location services are disabled (on iOS this will redirect the user to the Location settings page);
+* Android: Add support for requesting Activity Recognition permissions;
+* Confirm to Effective Dart guidelines;
+* Documented all public API members;
+* Fixed several typos in the README.md.
+
+## 4.2.0+hotfix.3
+
+* Android: Fixes a bug which in some cases caused the permission `neverAskAgain` to be returned incorrectly.
+
+## 4.2.0+hotfix.2
+
+* Android: Fixes a bug where permissions are reported as `neverAskAgain` incorrectly after calling `requestPermissions` method.
+
+
+## 4.2.0+hotfix.1
+
+* Android: Fixes a bug where permissions are reported as `neverAskAgain` incorrectly.
+
+## 4.2.0
+
+* Android: Methods `checkPermissionStatus` and `requestPermissions` now support addition `neverAskAgain` status.
+
+## 4.1.0
+
+* iOS: Added option to exclude permissions logic using macros. This allows developers to submit their app to the AppStore without having to include all permissions in their Info.plist;
+* Android: Support ANSWER_PHONE_CALLS permission for API 26 and higher;
+* Android: Support ACCESS_MEDIA_LOCATION permission for API 26 and higher;
+* Android: Synchronized Gradle version with Flutter stable (1.12.13+hotfix.5).
+
+## 4.0.0
+
+* iOS: Added support for requesting permissions on the DOCUMENTS and DOWNLOADS folder (thanks to @phranck);
+* Android: Fix the PROCESS_OUTGOING_CALLS permissions which have been deprecated in API 29.
+
+## 3.3.0
+
+* Android: Add support for requesting the background location permission within the `locationAlways` group.
+* Android: Update AGP, Gradle and AndroidX dependencies
+
+## 3.2.2
+
+* Fixed problem with dependency on specific version of gradle wrapper on Android.
+
+## 3.2.1+1
+
+* Reverted the update of the 'meta' plugin since Flutter SDK depends on version 1.1.6
+
+## 3.2.1
+
+* Updated dependency on 'meta' to latest version.
+
+## 3.2.0
+
+* Add support for Androids' "ignore battery optimizations" permission;
+* Improve error logging;
+* Documented support for AndroidX.
+
+## 3.1.0
+
+* Support service status inquiry for phone permission on iOS & Android.
+
+## 3.0.2
+
+* Fixed bug when rapidly requesting permissions (#23);
+* Rename Enums.h to PermissionHandlerEnums.h to prevent conflicts with geolocator (#104);
+* Update the Android permission request code to prevent conflicts with geolocator (#111);
+* Update Gradle infrastructure.
+
+## 3.0.1
+
+* Mark the Swift pod as static
+
+## 3.0.0
+
+* Converted the iOS version from Swift to Objective-C, reducing the size of the final binary considerably.
+
+## 2.2.0
+
+* Added new method `checkServiceStatus` to allow users to check if the location services (on Android and iOS) and motion services (iOS only) are enabled;
+* When checking permission status (using `checkPermissionStatus`) return `PermissionStatus.disabled` when permissions are granted or denied and the location services (on Android and iOS) or the motion services (iOS only) are disabled.
+
+## 2.1.3
+
+* Fixed bug on iOS where result of the `openAppSettings` call always returned `false`;
+* Upgrade Android plugin to support AndroidX and latest Gradle and Kotlin versions;
+* Added Swift version number to the Podfile of the plugin;
+* Updated flutter static analyzes to conform to latest recommendations.
+
+## 2.1.2
+
+* Make sure the Permission Handler compiles with latest iOS SDK
+
+## 2.1.1
+
+* Update to the latest version of Swift (4.2);
+* Make sure that the correct Swift version is set in the `Podfile` of consuming Apps;
+* Updated configuration for static code analyses, so it complies with the Flutter recommendations.
+
+## 2.1.0
+
+* Added Android support to check if location services are enabled. If location services are not running the permission check returns `PermissionStatus.DISABLED`.
+
+## 2.0.1
+
+* Fix bug with dependency on `com.android.support:support-compat` library
+* Update used Kotlin and Gradle versions
+
+## 2.0.0
+
+* Make methods non static so users can create an instance or override
+
+## 1.0.1
+
+* Converted the plugin into a library so that developers don't have to import additional files;
+* Updated the README.md to fix example code.
+
+## 1.0.0
+
+* Initial release.

LICENSE

+MIT License
+
+Copyright (c) 2018 Baseflow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

+[![pub package](https://img.shields.io/pub/v/permission_handler.svg)](https://pub.dartlang.org/packages/permission_handler) [![Build status](https://github.com/Baseflow/flutter-permission-handler/actions/workflows/permission_handler.yaml/badge.svg?branch=master)](https://github.com/Baseflow/flutter-permission-handler/actions/workflows/permission_handler.yaml) [![style: effective dart](https://img.shields.io/badge/style-effective_dart-40c4ff.svg)](https://github.com/tenhobi/effective_dart) [![codecov](https://codecov.io/gh/Baseflow/flutter-permission-handler/branch/master/graph/badge.svg)](https://codecov.io/gh/Baseflow/flutter-permission-handler)
+
+On most operating systems, permissions aren't just granted to apps at install time.
+Rather, developers have to ask the user for permissions while the app is running.
+
+This plugin provides a cross-platform (iOS, Android) API to request permissions and check their status.
+You can also open the device's app settings so users can grant a permission.  
+On Android, you can show a rationale for requesting a permission.
+
+## Setup
+
+While the permissions are being requested during runtime, you'll still need to tell the OS which permissions your app might potentially use. That requires adding permission configuration to Android- and iOS-specific files.
+
+<details>
+<summary>Android</summary>
+  
+**Upgrade pre 1.12 Android projects**
+  
+Since version 4.4.0 this plugin is implemented using the Flutter 1.12 Android plugin APIs. Unfortunately this means App developers also need to migrate their Apps to support the new Android infrastructure. You can do so by following the [Upgrading pre 1.12 Android projects](https://github.com/flutter/flutter/wiki/Upgrading-pre-1.12-Android-projects) migration guide. Failing to do so might result in unexpected behaviour. Most common known error is the permission_handler not returning after calling the `.request()` method on a permission. 
+
+**AndroidX**
+
+As of version 3.1.0 the <kbd>permission_handler</kbd> plugin switched to the AndroidX version of the Android Support Libraries. This means you need to make sure your Android project is also upgraded to support AndroidX. Detailed instructions can be found [here](https://flutter.dev/docs/development/packages-and-plugins/androidx-compatibility).
+
+The TL;DR version is:
+1. Add the following to your "gradle.properties" file:
+```
+android.useAndroidX=true
+android.enableJetifier=true
+```
+2. Make sure you set the `compileSdkVersion` in your "android/app/build.gradle" file to 31:
+```
+android {
+  compileSdkVersion 31
+  ...
+}
+```
+3. Make sure you replace all the `android.` dependencies to their AndroidX counterparts (a full list can be found here: https://developer.android.com/jetpack/androidx/migrate).
+
+Add permissions to your `AndroidManifest.xml` file.
+There's a `debug`, `main` and `profile` version which are chosen depending on how you start your app.
+In general, it's sufficient to add permission only to the `main` version.
+[Here](https://github.com/Baseflow/flutter-permission-handler/blob/master/permission_handler/example/android/app/src/main/AndroidManifest.xml)'s an example `AndroidManifest.xml` with a complete list of all possible permissions.
+
+</details>
+
+<details>
+<summary>iOS</summary>
+
+Add permission to your `Info.plist` file.
+[Here](https://github.com/Baseflow/flutter-permission-handler/blob/master/permission_handler/example/ios/Runner/Info.plist)'s an example `Info.plist` with a complete list of all possible permissions.
+
+> IMPORTANT: ~~You will have to include all permission options when you want to submit your App.~~ This is because the `permission_handler` plugin touches all different SDKs and because the static code analyser (run by Apple upon App submission) detects this and will assert if it cannot find a matching permission option in the `Info.plist`. More information about this can be found [here](https://github.com/Baseflow/flutter-permission-handler/issues/26).
+
+The <kbd>permission_handler</kbd> plugin use [macros](https://github.com/Baseflow/flutter-permission-handler/blob/master/permission_handler/ios/Classes/PermissionHandlerEnums.h) to control whether a permission is enabled.
+
+You must list permission you want to use in your application :
+
+1. Add the following to your `Podfile` file:
+   ```ruby
+   post_install do |installer|
+     installer.pods_project.targets.each do |target|
+       target.build_configurations.each do |config|
+         ... # Here are some configurations automatically generated by flutter
+   
+         # You can enable the permissions needed here. For example to enable camera
+         # permission, just remove the `#` character in front so it looks like this:
+         #
+         # ## dart: PermissionGroup.camera
+         # 'PERMISSION_CAMERA=1'
+         #
+         #  Preprocessor definitions can be found in: https://github.com/Baseflow/flutter-permission-handler/blob/master/permission_handler/ios/Classes/PermissionHandlerEnums.h
+         config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
+           '$(inherited)',
+  
+           ## dart: PermissionGroup.calendar
+           # 'PERMISSION_EVENTS=1',
+  
+           ## dart: PermissionGroup.reminders
+           # 'PERMISSION_REMINDERS=1',
+  
+           ## dart: PermissionGroup.contacts
+           # 'PERMISSION_CONTACTS=1',
+  
+           ## dart: PermissionGroup.camera
+           # 'PERMISSION_CAMERA=1',
+  
+           ## dart: PermissionGroup.microphone
+           # 'PERMISSION_MICROPHONE=1',
+  
+           ## dart: PermissionGroup.speech
+           # 'PERMISSION_SPEECH_RECOGNIZER=1',
+  
+           ## dart: PermissionGroup.photos
+           # 'PERMISSION_PHOTOS=1',
+  
+           ## dart: [PermissionGroup.location, PermissionGroup.locationAlways, PermissionGroup.locationWhenInUse]
+           # 'PERMISSION_LOCATION=1',
+          
+           ## dart: PermissionGroup.notification
+           # 'PERMISSION_NOTIFICATIONS=1',
+  
+           ## dart: PermissionGroup.mediaLibrary
+           # 'PERMISSION_MEDIA_LIBRARY=1',
+  
+           ## dart: PermissionGroup.sensors
+           # 'PERMISSION_SENSORS=1',   
+           
+           ## dart: PermissionGroup.bluetooth
+           # 'PERMISSION_BLUETOOTH=1',
+   
+           ## dart: PermissionGroup.appTrackingTransparency
+           # 'PERMISSION_APP_TRACKING_TRANSPARENCY=1',
+   
+           ## dart: PermissionGroup.criticalAlerts
+           # 'PERMISSION_CRITICAL_ALERTS=1'
+         ]
+  
+       end
+     end
+   end
+   ```
+2. Remove the `#` character in front of the permission you do want to use. For example if you need access to the calendar make sure the code looks like this:
+   ```ruby
+           ## dart: PermissionGroup.calendar
+           'PERMISSION_EVENTS=1',
+   ```
+3. Delete the corresponding permission description in `Info.plist`
+   e.g. when you don't need camera permission, just delete 'NSCameraUsageDescription'
+   The following lists the relationship between `Permission` and `The key of Info.plist`:
+   | Permission                                                                                  | Info.plist                                                                                                    | Macro                                |
+   | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
+   | PermissionGroup.calendar                                                                    | NSCalendarsUsageDescription                                                                                   | PERMISSION_EVENTS                    |
+   | PermissionGroup.reminders                                                                   | NSRemindersUsageDescription                                                                                   | PERMISSION_REMINDERS                 |
+   | PermissionGroup.contacts                                                                    | NSContactsUsageDescription                                                                                    | PERMISSION_CONTACTS                  |
+   | PermissionGroup.camera                                                                      | NSCameraUsageDescription                                                                                      | PERMISSION_CAMERA                    |
+   | PermissionGroup.microphone                                                                  | NSMicrophoneUsageDescription                                                                                  | PERMISSION_MICROPHONE                |
+   | PermissionGroup.speech                                                                      | NSSpeechRecognitionUsageDescription                                                                           | PERMISSION_SPEECH_RECOGNIZER         |
+   | PermissionGroup.photos                                                                      | NSPhotoLibraryUsageDescription                                                                                | PERMISSION_PHOTOS                    |
+   | PermissionGroup.location, PermissionGroup.locationAlways, PermissionGroup.locationWhenInUse | NSLocationUsageDescription, NSLocationAlwaysAndWhenInUseUsageDescription, NSLocationWhenInUseUsageDescription | PERMISSION_LOCATION                  |
+   | PermissionGroup.notification                                                                | PermissionGroupNotification                                                                                   | PERMISSION_NOTIFICATIONS             |
+   | PermissionGroup.mediaLibrary                                                                | NSAppleMusicUsageDescription, kTCCServiceMediaLibrary                                                         | PERMISSION_MEDIA_LIBRARY             |
+   | PermissionGroup.sensors                                                                     | NSMotionUsageDescription                                                                                      | PERMISSION_SENSORS                   |
+   | PermissionGroup.bluetooth                                                                   | NSBluetoothAlwaysUsageDescription, NSBluetoothPeripheralUsageDescription                                      | PERMISSION_BLUETOOTH                 |
+   | PermissionGroup.appTrackingTransparency                                                     | NSUserTrackingUsageDescription                                                                                | PERMISSION_APP_TRACKING_TRANSPARENCY |   
+   | PermissionGroup.criticalAlerts                                                              | PermissionGroupCriticalAlerts                                                                                 | PERMISSION_CRITICAL_ALERTS           |
+4. Clean & Rebuild
+
+</details>
+
+
+
+## How to use
+
+There are a number of [`Permission`](https://pub.dev/documentation/permission_handler_platform_interface/latest/permission_handler_platform_interface/Permission-class.html#constants)s.
+You can get a `Permission`'s `status`, which is either `granted`, `denied`, `restricted` or `permanentlyDenied`.
+
+```dart
+var status = await Permission.camera.status;
+if (status.isDenied) {
+  // We didn't ask for permission yet or the permission has been denied before but not permanently.
+}
+
+// You can can also directly ask the permission about its status.
+if (await Permission.location.isRestricted) {
+  // The OS restricts access, for example because of parental controls.
+}
+```
+
+Call `request()` on a `Permission` to request it.
+If it has already been granted before, nothing happens.  
+`request()` returns the new status of the `Permission`.
+
+```dart
+if (await Permission.contacts.request().isGranted) {
+  // Either the permission was already granted before or the user just granted it.
+}
+
+// You can request multiple permissions at once.
+Map<Permission, PermissionStatus> statuses = await [
+  Permission.location,
+  Permission.storage,
+].request();
+print(statuses[Permission.location]);
+```
+
+Some permissions, for example location or acceleration sensor permissions, have an associated service, which can be `enabled` or `disabled`.
+
+```dart
+if (await Permission.locationWhenInUse.serviceStatus.isEnabled) {
+  // Use location.
+}
+```
+
+You can also open the app settings:
+
+```dart
+if (await Permission.speech.isPermanentlyDenied) {
+  // The user opted to never again see the permission request dialog for this
+  // app. The only way to change the permission's status now is to let the
+  // user manually enable it in the system settings.
+  openAppSettings();
+}
+```
+
+On Android, you can show a rationale for using a permission:
+
+```dart
+bool isShown = await Permission.contacts.shouldShowRequestRationale;
+```
+
+Some permissions will not show a dialog asking the user to allow or deny the requested permission.  
+This is because the OS setting(s) of the app are being retrieved for the corresponding permission.  
+The status of the setting will determine whether the permission is `granted` or `denied`.  
+
+The following permissions will show no dialog:  
+
+- Notification
+- Bluetooth
+
+The following permissions will show no dialog, but will open the corresponding setting intent for the user to change the permission status:  
+
+- manageExternalStorage
+- systemAlertWindow
+- requestInstallPackages
+- accessNotificationPolicy
+
+The `locationAlways` permission can not be requested directly, the user has to request the `locationWhenInUse` permission first.
+Accepting this permission by clicking on the 'Allow While Using App' gives the user the possibility to request the `locationAlways` permission.
+This will then bring up another permission popup asking you to `Keep Only While Using` or to `Change To Always Allow`.
+
+## Issues
+
+Please file any issues, bugs or feature request as an issue on our [GitHub](https://github.com/Baseflow/flutter-permission-handler/issues) page. Commercial support is available if you need help with integration with your app or services. You can contact us at [hello@baseflow.com](mailto:hello@baseflow.com).
+
+## Want to contribute
+
+If you would like to contribute to the plugin (e.g. by improving the documentation, solving a bug or adding a cool new feature), please carefully review our [contribution guide](../CONTRIBUTING.md) and send us your [pull request](https://github.com/Baseflow/flutter-permission-handler/pulls).
+
+## Author
+
+This Permission handler plugin for Flutter is developed by [Baseflow](https://baseflow.com). You can contact us at <hello@baseflow.com>

android/build.gradle

+group 'com.baseflow.permissionhandler'
+version '1.0-SNAPSHOT'
+def args = ["-Xlint:deprecation","-Xlint:unchecked","-Werror"]
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+        maven { url 'https://maven.google.com' }
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.5.4'
+    }
+}
+
+rootProject.allprojects {
+    repositories {
+        google()
+        jcenter()
+    }
+}
+
+project.getTasks().withType(JavaCompile){
+    options.compilerArgs.addAll(args)
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 30
+
+    defaultConfig {
+        minSdkVersion 16
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    lintOptions {
+        disable 'InvalidPackage'
+    }
+    compileOptions {
+        sourceCompatibility = '1.8'
+        targetCompatibility = '1.8'
+    }
+}
+
+dependencies {
+    implementation 'androidx.annotation:annotation:1.2.0'
+    implementation 'androidx.core:core:1.6.0'
+}
+
+repositories {
+    google()
+}
\ No newline at end of file

android/gradle.properties

+org.gradle.jvmargs=-Xmx1536M
+android.useAndroidX=true

android/gradle/wrapper/gradle-wrapper.properties

+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

android/settings.gradle

+rootProject.name = 'permission_handler'

android/src/main/AndroidManifest.xml

+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.baseflow.permissionhandler">
+</manifest>

android/src/main/java/com/baseflow/permissionhandler/AppSettingsManager.java

+package com.baseflow.permissionhandler;
+
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+final class AppSettingsManager {
+    @FunctionalInterface
+    interface OpenAppSettingsSuccessCallback {
+        void onSuccess(boolean appSettingsOpenedSuccessfully);
+    }
+
+    void openAppSettings(
+            Context context,
+            OpenAppSettingsSuccessCallback successCallback,
+            ErrorCallback errorCallback) {
+        if(context == null) {
+            Log.d(PermissionConstants.LOG_TAG, "Context cannot be null.");
+            errorCallback.onError("PermissionHandler.AppSettingsManager", "Android context cannot be null.");
+            return;
+        }
+
+        try {
+            Intent settingsIntent = new Intent();
+            settingsIntent.setAction(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
+            settingsIntent.addCategory(Intent.CATEGORY_DEFAULT);
+            settingsIntent.setData(android.net.Uri.parse("package:" + context.getPackageName()));
+            settingsIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+            settingsIntent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
+            settingsIntent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
+
+            context.startActivity(settingsIntent);
+
+            successCallback.onSuccess(true);
+        } catch (Exception ex) {
+            successCallback.onSuccess(false);
+        }
+    }
+}

android/src/main/java/com/baseflow/permissionhandler/ErrorCallback.java

+package com.baseflow.permissionhandler;
+
+@FunctionalInterface
+interface ErrorCallback {
+    void onError(String errorCode, String errorDescription);
+}

android/src/main/java/com/baseflow/permissionhandler/MethodCallHandlerImpl.java

+package com.baseflow.permissionhandler;
+
+import android.app.Activity;
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+
+import androidx.annotation.Nullable;
+import io.flutter.plugin.common.MethodCall;
+import io.flutter.plugin.common.MethodChannel;
+import io.flutter.plugin.common.MethodChannel.Result;
+
+import java.util.List;
+
+final class MethodCallHandlerImpl implements MethodChannel.MethodCallHandler {
+    private final Context applicationContext;
+    private final AppSettingsManager appSettingsManager;
+    private final PermissionManager permissionManager;
+    private final ServiceManager serviceManager;
+
+    MethodCallHandlerImpl(
+            Context applicationContext,
+            AppSettingsManager appSettingsManager,
+            PermissionManager permissionManager,
+            ServiceManager serviceManager) {
+        this.applicationContext = applicationContext;
+        this.appSettingsManager = appSettingsManager;
+        this.permissionManager = permissionManager;
+        this.serviceManager = serviceManager;
+    }
+
+    @Nullable
+    private Activity activity;
+
+    public void setActivity(@Nullable Activity activity) {
+      this.activity = activity;
+    }
+
+  @Override
+    public void onMethodCall(@NonNull MethodCall call, @NonNull final Result result)
+    {
+        switch (call.method) {
+            case "checkServiceStatus": {
+                @PermissionConstants.PermissionGroup final int permission = Integer.parseInt(call.arguments.toString());
+                serviceManager.checkServiceStatus(
+                        permission,
+                        applicationContext,
+                        result::success,
+                        (String errorCode, String errorDescription) -> result.error(
+                                errorCode,
+                                errorDescription,
+                                null));
+
+                break;
+            }
+            case "checkPermissionStatus": {
+                @PermissionConstants.PermissionGroup final int permission = Integer.parseInt(call.arguments.toString());
+                permissionManager.checkPermissionStatus(
+                        permission,
+                        applicationContext,
+                        result::success);
+                break;
+            }
+            case "requestPermissions":
+                final List<Integer> permissions = call.arguments();
+                permissionManager.requestPermissions(
+                        permissions,
+                        activity,
+                        result::success,
+                        (String errorCode, String errorDescription) -> result.error(
+                                errorCode,
+                                errorDescription,
+                                null));
+
+                break;
+            case "shouldShowRequestPermissionRationale": {
+                @PermissionConstants.PermissionGroup final int permission = Integer.parseInt(call.arguments.toString());
+                permissionManager.shouldShowRequestPermissionRationale(
+                        permission,
+                        activity,
+                        result::success,
+                        (String errorCode, String errorDescription) -> result.error(
+                                errorCode,
+                                errorDescription,
+                                null));
+
+                break;
+            }
+            case "openAppSettings":
+                appSettingsManager.openAppSettings(
+                        applicationContext,
+                        result::success,
+                        (String errorCode, String errorDescription) -> result.error(
+                                errorCode,
+                                errorDescription,
+                                null));
+
+                break;
+            default:
+                result.notImplemented();
+                break;
+        }
+    }
+}

android/src/main/java/com/baseflow/permissionhandler/PermissionConstants.java

+package com.baseflow.permissionhandler;
+
+import androidx.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+final class PermissionConstants {
+    static final String LOG_TAG = "permissions_handler";
+    static final int PERMISSION_CODE = 24;
+    static final int PERMISSION_CODE_IGNORE_BATTERY_OPTIMIZATIONS = 209;
+    static final int PERMISSION_CODE_MANAGE_EXTERNAL_STORAGE = 210;
+    static final int PERMISSION_CODE_SYSTEM_ALERT_WINDOW = 211;
+    static final int PERMISSION_CODE_REQUEST_INSTALL_PACKAGES = 212;
+    static final int PERMISSION_CODE_ACCESS_NOTIFICATION_POLICY = 213;
+
+    //PERMISSION_GROUP
+    static final int PERMISSION_GROUP_CALENDAR = 0;
+    static final int PERMISSION_GROUP_CAMERA = 1;
+    static final int PERMISSION_GROUP_CONTACTS = 2;
+    static final int PERMISSION_GROUP_LOCATION = 3;
+    static final int PERMISSION_GROUP_LOCATION_ALWAYS = 4;
+    static final int PERMISSION_GROUP_LOCATION_WHEN_IN_USE = 5;
+    static final int PERMISSION_GROUP_MEDIA_LIBRARY = 6;
+    static final int PERMISSION_GROUP_MICROPHONE = 7;
+    static final int PERMISSION_GROUP_PHONE = 8;
+    static final int PERMISSION_GROUP_PHOTOS = 9;
+    static final int PERMISSION_GROUP_PHOTOS_ADD_ONLY = 10;
+    static final int PERMISSION_GROUP_REMINDERS = 11;
+    static final int PERMISSION_GROUP_SENSORS = 12;
+    static final int PERMISSION_GROUP_SMS = 13;
+    static final int PERMISSION_GROUP_SPEECH = 14;
+    static final int PERMISSION_GROUP_STORAGE = 15;
+    static final int PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS = 16;
+    static final int PERMISSION_GROUP_NOTIFICATION = 17;
+    static final int PERMISSION_GROUP_ACCESS_MEDIA_LOCATION = 18;
+    static final int PERMISSION_GROUP_ACTIVITY_RECOGNITION = 19;
+    static final int PERMISSION_GROUP_UNKNOWN = 20;
+    static final int PERMISSION_GROUP_BLUETOOTH = 21;
+    static final int PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE = 22;
+    static final int PERMISSION_GROUP_SYSTEM_ALERT_WINDOW = 23;
+    static final int PERMISSION_GROUP_REQUEST_INSTALL_PACKAGES = 24;
+    static final int PERMISSION_GROUP_APP_TRACK_TRANSPARENCY = 25;
+    static final int PERMISSION_GROUP_CRITICAL_ALERTS = 26;
+    static final int PERMISSION_GROUP_ACCESS_NOTIFICATION_POLICY = 27;
+    static final int PERMISSION_GROUP_BLUETOOTH_SCAN = 28;
+    static final int PERMISSION_GROUP_BLUETOOTH_ADVERTISE = 29;
+    static final int PERMISSION_GROUP_BLUETOOTH_CONNECT = 30;
+
+
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef({
+            PERMISSION_GROUP_CALENDAR,
+            PERMISSION_GROUP_CAMERA,
+            PERMISSION_GROUP_CONTACTS,
+            PERMISSION_GROUP_LOCATION,
+            PERMISSION_GROUP_LOCATION_ALWAYS,
+            PERMISSION_GROUP_LOCATION_WHEN_IN_USE,
+            PERMISSION_GROUP_MEDIA_LIBRARY,
+            PERMISSION_GROUP_MICROPHONE,
+            PERMISSION_GROUP_PHONE,
+            PERMISSION_GROUP_PHOTOS,
+            PERMISSION_GROUP_REMINDERS,
+            PERMISSION_GROUP_SENSORS,
+            PERMISSION_GROUP_SMS,
+            PERMISSION_GROUP_SPEECH,
+            PERMISSION_GROUP_STORAGE,
+            PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS,
+            PERMISSION_GROUP_NOTIFICATION,
+            PERMISSION_GROUP_ACCESS_MEDIA_LOCATION,
+            PERMISSION_GROUP_ACTIVITY_RECOGNITION,
+            PERMISSION_GROUP_UNKNOWN,
+            PERMISSION_GROUP_BLUETOOTH,
+            PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE,
+            PERMISSION_GROUP_SYSTEM_ALERT_WINDOW,
+            PERMISSION_GROUP_REQUEST_INSTALL_PACKAGES,
+            PERMISSION_GROUP_ACCESS_NOTIFICATION_POLICY,
+            PERMISSION_GROUP_BLUETOOTH_SCAN,
+            PERMISSION_GROUP_BLUETOOTH_ADVERTISE,
+            PERMISSION_GROUP_BLUETOOTH_CONNECT
+    })
+    @interface PermissionGroup {
+    }
+
+    //PERMISSION_STATUS
+    static final int PERMISSION_STATUS_DENIED = 0;
+    static final int PERMISSION_STATUS_GRANTED = 1;
+    static final int PERMISSION_STATUS_RESTRICTED = 2;
+    static final int PERMISSION_STATUS_LIMITED = 3;
+    static final int PERMISSION_STATUS_NEVER_ASK_AGAIN = 4;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef({
+            PERMISSION_STATUS_DENIED,
+            PERMISSION_STATUS_GRANTED,
+            PERMISSION_STATUS_RESTRICTED,
+            PERMISSION_STATUS_LIMITED,
+            PERMISSION_STATUS_NEVER_ASK_AGAIN
+    })
+    @interface PermissionStatus {
+    }
+
+    //SERVICE_STATUS
+    static final int SERVICE_STATUS_DISABLED = 0;
+    static final int SERVICE_STATUS_ENABLED = 1;
+    static final int SERVICE_STATUS_NOT_APPLICABLE = 2;
+
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef({
+            SERVICE_STATUS_DISABLED,
+            SERVICE_STATUS_ENABLED,
+            SERVICE_STATUS_NOT_APPLICABLE
+    })
+    @interface ServiceStatus {
+    }
+}
\ No newline at end of file

android/src/main/java/com/baseflow/permissionhandler/PermissionHandlerPlugin.java

+package com.baseflow.permissionhandler;
+
+import android.app.Activity;
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import io.flutter.embedding.engine.plugins.FlutterPlugin;
+import io.flutter.embedding.engine.plugins.activity.ActivityAware;
+import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding;
+import io.flutter.plugin.common.BinaryMessenger;
+import io.flutter.plugin.common.MethodChannel;
+
+/**
+ * Platform implementation of the permission_handler Flutter plugin.
+ *
+ * <p>Instantiate this in an add to app scenario to gracefully handle activity and context changes.
+ * See {@code com.example.permissionhandlerexample.MainActivity} for an example.
+ *
+ * <p>Call {@link #registerWith(io.flutter.plugin.common.PluginRegistry.Registrar)} to register an
+ * implementation of this that uses the stable {@code io.flutter.plugin.common} package.
+ */
+public final class PermissionHandlerPlugin implements FlutterPlugin, ActivityAware {
+
+    private final PermissionManager permissionManager;
+    private MethodChannel methodChannel;
+
+    @SuppressWarnings("deprecation")
+    @Nullable private io.flutter.plugin.common.PluginRegistry.Registrar pluginRegistrar;
+
+    @Nullable private ActivityPluginBinding pluginBinding;
+
+    @Nullable
+    private MethodCallHandlerImpl methodCallHandler;
+
+    public PermissionHandlerPlugin() {
+        this.permissionManager = new PermissionManager();
+    }
+
+    /**
+     * Registers a plugin implementation that uses the stable {@code io.flutter.plugin.common}
+     * package.
+     *
+     * <p>Calling this automatically initializes the plugin. However plugins initialized this way
+     * won't react to changes in activity or context, unlike {@link PermissionHandlerPlugin}.
+     */
+    @SuppressWarnings("deprecation")
+    public static void registerWith(io.flutter.plugin.common.PluginRegistry.Registrar registrar) {
+        final PermissionHandlerPlugin plugin = new PermissionHandlerPlugin();
+
+        plugin.pluginRegistrar = registrar;
+        plugin.registerListeners();
+
+        plugin.startListening(registrar.context(), registrar.messenger());
+
+        if (registrar.activeContext() instanceof Activity) {
+            plugin.startListeningToActivity(
+                registrar.activity()
+            );
+        }
+    }
+
+    @Override
+    public void onAttachedToEngine(@NonNull FlutterPluginBinding binding) {
+        startListening(
+            binding.getApplicationContext(),
+            binding.getBinaryMessenger()
+        );
+    }
+
+    @Override
+    public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) {
+        stopListening();
+    }
+
+    @Override
+    public void onAttachedToActivity(@NonNull ActivityPluginBinding binding) {
+        startListeningToActivity(
+            binding.getActivity()
+        );
+
+        this.pluginBinding = binding;
+        registerListeners();
+    }
+
+    @Override
+    public void onReattachedToActivityForConfigChanges(@NonNull ActivityPluginBinding binding) {
+        onAttachedToActivity(binding);
+    }
+
+    @Override
+    public void onDetachedFromActivity() {
+        stopListeningToActivity();
+
+        deregisterListeners();
+    }
+
+    @Override
+    public void onDetachedFromActivityForConfigChanges() {
+        onDetachedFromActivity();
+    }
+
+
+    private void startListening(Context applicationContext, BinaryMessenger messenger) {
+        methodChannel = new MethodChannel(
+            messenger,
+            "flutter.baseflow.com/permissions/methods");
+
+        methodCallHandler = new MethodCallHandlerImpl(
+            applicationContext,
+            new AppSettingsManager(),
+            this.permissionManager,
+            new ServiceManager()
+        );
+
+        methodChannel.setMethodCallHandler(methodCallHandler);
+    }
+
+    private void stopListening() {
+        methodChannel.setMethodCallHandler(null);
+        methodChannel = null;
+        methodCallHandler = null;
+    }
+
+    private void startListeningToActivity(
+        Activity activity
+    ) {
+        if (methodCallHandler != null) {
+            methodCallHandler.setActivity(activity);
+        }
+    }
+
+    private void stopListeningToActivity() {
+        if (methodCallHandler != null) {
+            methodCallHandler.setActivity(null);
+        }
+    }
+
+    private void registerListeners() {
+        if (this.pluginRegistrar != null) {
+            this.pluginRegistrar.addActivityResultListener(this.permissionManager);
+            this.pluginRegistrar.addRequestPermissionsResultListener(this.permissionManager);
+        } else if (pluginBinding != null) {
+            this.pluginBinding.addActivityResultListener(this.permissionManager);
+            this.pluginBinding.addRequestPermissionsResultListener(this.permissionManager);
+        }
+    }
+
+    private void deregisterListeners() {
+        if (this.pluginBinding != null) {
+            this.pluginBinding.removeActivityResultListener(this.permissionManager);
+            this.pluginBinding.removeRequestPermissionsResultListener(this.permissionManager);
+        }
+    }
+}

android/src/main/java/com/baseflow/permissionhandler/PermissionManager.java

+package com.baseflow.permissionhandler;
+
+import android.app.Activity;
+import android.app.Application;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.os.PowerManager;
+import android.provider.Settings;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.core.app.ActivityCompat;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.content.ContextCompat;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import io.flutter.plugin.common.PluginRegistry;
+
+final class PermissionManager implements PluginRegistry.ActivityResultListener, PluginRegistry.RequestPermissionsResultListener {
+
+    @Nullable
+    private RequestPermissionsSuccessCallback successCallback;
+
+    @Nullable
+    private Activity activity;
+
+    private Map<Integer, Integer> requestResults;
+
+    @Override
+    public boolean onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode != PermissionConstants.PERMISSION_CODE_IGNORE_BATTERY_OPTIMIZATIONS &&
+                requestCode != PermissionConstants.PERMISSION_CODE_MANAGE_EXTERNAL_STORAGE &&
+                requestCode != PermissionConstants.PERMISSION_CODE_SYSTEM_ALERT_WINDOW &&
+                requestCode != PermissionConstants.PERMISSION_CODE_REQUEST_INSTALL_PACKAGES &&
+                requestCode != PermissionConstants.PERMISSION_CODE_ACCESS_NOTIFICATION_POLICY) {
+            return false;
+        }
+
+        int status = resultCode == Activity.RESULT_OK
+                ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                : PermissionConstants.PERMISSION_STATUS_DENIED;
+
+        int permission;
+
+        if (requestCode == PermissionConstants.PERMISSION_CODE_IGNORE_BATTERY_OPTIMIZATIONS) {
+            permission = PermissionConstants.PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS;
+        } else if (requestCode == PermissionConstants.PERMISSION_CODE_MANAGE_EXTERNAL_STORAGE) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                status = Environment.isExternalStorageManager()
+                        ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                        : PermissionConstants.PERMISSION_STATUS_DENIED;
+            } else {
+                return false;
+            }
+            permission = PermissionConstants.PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE;
+        } else if (requestCode == PermissionConstants.PERMISSION_CODE_SYSTEM_ALERT_WINDOW) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                status = Settings.canDrawOverlays(activity)
+                        ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                        : PermissionConstants.PERMISSION_STATUS_DENIED;
+                permission = PermissionConstants.PERMISSION_GROUP_SYSTEM_ALERT_WINDOW;
+            } else {
+                return false;
+            }
+        } else if (requestCode == PermissionConstants.PERMISSION_CODE_REQUEST_INSTALL_PACKAGES) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                status = activity.getPackageManager().canRequestPackageInstalls()
+                        ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                        : PermissionConstants.PERMISSION_STATUS_DENIED;
+                permission = PermissionConstants.PERMISSION_GROUP_REQUEST_INSTALL_PACKAGES;
+            } else {
+                return false;
+            }
+        } else if (requestCode == PermissionConstants.PERMISSION_CODE_ACCESS_NOTIFICATION_POLICY) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                NotificationManager notificationManager = (NotificationManager) activity.getSystemService(Application.NOTIFICATION_SERVICE);
+                status = notificationManager.isNotificationPolicyAccessGranted()
+                        ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                        : PermissionConstants.PERMISSION_STATUS_DENIED;
+                permission = PermissionConstants.PERMISSION_GROUP_ACCESS_NOTIFICATION_POLICY;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+
+        HashMap<Integer, Integer> results = new HashMap<>();
+        results.put(permission, status);
+        successCallback.onSuccess(results);
+        return true;
+    }
+
+    @Override
+    public boolean onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        if (requestCode != PermissionConstants.PERMISSION_CODE) {
+            ongoing = false;
+            return false;
+        }
+
+        if (requestResults == null) {
+           return false;
+        }
+
+        for (int i = 0; i < permissions.length; i++) {
+            final String permissionName = permissions[i];
+
+            @PermissionConstants.PermissionGroup final int permission =
+                    PermissionUtils.parseManifestName(permissionName);
+
+            if (permission == PermissionConstants.PERMISSION_GROUP_UNKNOWN)
+                continue;
+
+            final int result = grantResults[i];
+
+            if (permission == PermissionConstants.PERMISSION_GROUP_MICROPHONE) {
+                if (!requestResults.containsKey(PermissionConstants.PERMISSION_GROUP_MICROPHONE)) {
+                    requestResults.put(
+                            PermissionConstants.PERMISSION_GROUP_MICROPHONE,
+                            PermissionUtils.toPermissionStatus(this.activity, permissionName, result));
+                }
+                if (!requestResults.containsKey(PermissionConstants.PERMISSION_GROUP_SPEECH)) {
+                    requestResults.put(
+                            PermissionConstants.PERMISSION_GROUP_SPEECH,
+                            PermissionUtils.toPermissionStatus(this.activity, permissionName, result));
+                }
+            } else if (permission == PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS) {
+                @PermissionConstants.PermissionStatus int permissionStatus =
+                        PermissionUtils.toPermissionStatus(this.activity, permissionName, result);
+
+                if (!requestResults.containsKey(PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS)) {
+                    requestResults.put(PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS, permissionStatus);
+                }
+            } else if (permission == PermissionConstants.PERMISSION_GROUP_LOCATION) {
+                @PermissionConstants.PermissionStatus int permissionStatus =
+                        PermissionUtils.toPermissionStatus(this.activity, permissionName, result);
+
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+                    if (!requestResults.containsKey(PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS)) {
+                        requestResults.put(
+                                PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS,
+                                permissionStatus);
+                    }
+                }
+
+                if (!requestResults.containsKey(PermissionConstants.PERMISSION_GROUP_LOCATION_WHEN_IN_USE)) {
+                    requestResults.put(
+                            PermissionConstants.PERMISSION_GROUP_LOCATION_WHEN_IN_USE,
+                            permissionStatus);
+                }
+
+                requestResults.put(permission, permissionStatus);
+            } else if (!requestResults.containsKey(permission)) {
+                requestResults.put(
+                        permission,
+                        PermissionUtils.toPermissionStatus(this.activity, permissionName, result));
+            }
+
+            PermissionUtils.updatePermissionShouldShowStatus(this.activity, permission);
+        }
+
+        this.successCallback.onSuccess(requestResults);
+        ongoing = false;
+        return true;
+    }
+
+    @FunctionalInterface
+    interface RequestPermissionsSuccessCallback {
+        void onSuccess(Map<Integer, Integer> results);
+    }
+
+    @FunctionalInterface
+    interface CheckPermissionsSuccessCallback {
+        void onSuccess(@PermissionConstants.PermissionStatus int permissionStatus);
+    }
+
+    @FunctionalInterface
+    interface ShouldShowRequestPermissionRationaleSuccessCallback {
+        void onSuccess(boolean shouldShowRequestPermissionRationale);
+    }
+
+    private boolean ongoing = false;
+
+    void checkPermissionStatus(
+            @PermissionConstants.PermissionGroup int permission,
+            Context context,
+            CheckPermissionsSuccessCallback successCallback) {
+
+        successCallback.onSuccess(determinePermissionStatus(
+                permission,
+                context));
+    }
+
+    void requestPermissions(
+            List<Integer> permissions,
+            Activity activity,
+            RequestPermissionsSuccessCallback successCallback,
+            ErrorCallback errorCallback) {
+        if (ongoing) {
+            errorCallback.onError(
+                    "PermissionHandler.PermissionManager",
+                    "A request for permissions is already running, please wait for it to finish before doing another request (note that you can request multiple permissions at the same time).");
+            return;
+        }
+
+        if (activity == null) {
+            Log.d(PermissionConstants.LOG_TAG, "Unable to detect current Activity.");
+
+            errorCallback.onError(
+                    "PermissionHandler.PermissionManager",
+                    "Unable to detect current Android Activity.");
+            return;
+        }
+
+        this.successCallback = successCallback;
+        this.activity = activity;
+        this.requestResults = new HashMap<>();
+
+        ArrayList<String> permissionsToRequest = new ArrayList<>();
+        for (Integer permission : permissions) {
+            @PermissionConstants.PermissionStatus final int permissionStatus = determinePermissionStatus(permission, activity);
+            if (permissionStatus == PermissionConstants.PERMISSION_STATUS_GRANTED) {
+                if (!requestResults.containsKey(permission)) {
+                    requestResults.put(permission, PermissionConstants.PERMISSION_STATUS_GRANTED);
+                }
+                continue;
+            }
+
+            final List<String> names = PermissionUtils.getManifestNames(activity, permission);
+
+            // check to see if we can find manifest names
+            // if we can't add as unknown and continue
+            if (names == null || names.isEmpty()) {
+                if (!requestResults.containsKey(permission)) {
+                    // On Android below M, the android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS flag in AndroidManifest.xml
+                    // may be ignored and not visible to the App as it's a new permission setting as a whole.
+                    if (permission == PermissionConstants.PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS && Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                        requestResults.put(permission, PermissionConstants.PERMISSION_STATUS_RESTRICTED);
+                    } else {
+                        requestResults.put(permission, PermissionConstants.PERMISSION_STATUS_DENIED);
+                    }
+                    // On Android below R, the android.permission.MANAGE_EXTERNAL_STORAGE flag in AndroidManifest.xml
+                    // may be ignored and not visible to the App as it's a new permission setting as a whole.
+                    if (permission == PermissionConstants.PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE && Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+                        requestResults.put(permission, PermissionConstants.PERMISSION_STATUS_RESTRICTED);
+                    } else {
+                        requestResults.put(permission, PermissionConstants.PERMISSION_STATUS_DENIED);
+                    }
+                }
+
+                continue;
+            }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && permission == PermissionConstants.PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS) {
+                executeIntent(
+                        Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS,
+                        PermissionConstants.PERMISSION_CODE_IGNORE_BATTERY_OPTIMIZATIONS);
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && permission == PermissionConstants.PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE) {
+                executeIntent(
+                        Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION,
+                        PermissionConstants.PERMISSION_CODE_MANAGE_EXTERNAL_STORAGE);
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && permission == PermissionConstants.PERMISSION_GROUP_SYSTEM_ALERT_WINDOW) {
+                executeIntent(
+                        Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+                        PermissionConstants.PERMISSION_CODE_SYSTEM_ALERT_WINDOW);
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && permission == PermissionConstants.PERMISSION_GROUP_REQUEST_INSTALL_PACKAGES) {
+                executeIntent(
+                        Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES,
+                        PermissionConstants.PERMISSION_CODE_REQUEST_INSTALL_PACKAGES);
+            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && permission == PermissionConstants.PERMISSION_GROUP_ACCESS_NOTIFICATION_POLICY) {
+                executeSimpleIntent(
+                        Settings.ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS,
+                        PermissionConstants.PERMISSION_CODE_ACCESS_NOTIFICATION_POLICY);
+            } else {
+                permissionsToRequest.addAll(names);
+            }
+        }
+
+        final String[] requestPermissions = permissionsToRequest.toArray(new String[0]);
+        if (permissionsToRequest.size() > 0) {
+            ongoing = true;
+
+            ActivityCompat.requestPermissions(
+                    activity,
+                    requestPermissions,
+                    PermissionConstants.PERMISSION_CODE);
+        } else {
+            ongoing = false;
+            if (requestResults.size() > 0) {
+                successCallback.onSuccess(requestResults);
+            }
+        }
+    }
+
+    @PermissionConstants.PermissionStatus
+    private int determinePermissionStatus(
+            @PermissionConstants.PermissionGroup int permission,
+            Context context) {
+
+        if (permission == PermissionConstants.PERMISSION_GROUP_NOTIFICATION) {
+            return checkNotificationPermissionStatus(context);
+        }
+
+        if (permission == PermissionConstants.PERMISSION_GROUP_BLUETOOTH) {
+            return checkBluetoothPermissionStatus(context);
+        }
+        final List<String> names = PermissionUtils.getManifestNames(context, permission);
+
+        if (names == null) {
+            Log.d(PermissionConstants.LOG_TAG, "No android specific permissions needed for: " + permission);
+
+            return PermissionConstants.PERMISSION_STATUS_GRANTED;
+        }
+
+        //if no permissions were found then there is an issue and permission is not set in Android manifest
+        if (names.size() == 0) {
+            Log.d(PermissionConstants.LOG_TAG, "No permissions found in manifest for: " + names + permission);
+
+            // On Android below M, the android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS flag in AndroidManifest.xml
+            // may be ignored and not visible to the App as it's a new permission setting as a whole.
+            if (permission == PermissionConstants.PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS) {
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                    return PermissionConstants.PERMISSION_STATUS_RESTRICTED;
+                }
+            }
+
+            // On Android below R, the android.permission.MANAGE_EXTERNAL_STORAGE flag in AndroidManifest.xml
+            // may be ignored and not visible to the App as it's a new permission setting as a whole.
+            if (permission == PermissionConstants.PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE) {
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+                    return PermissionConstants.PERMISSION_STATUS_RESTRICTED;
+                }
+            }
+
+            return Build.VERSION.SDK_INT < Build.VERSION_CODES.M
+                ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                : PermissionConstants.PERMISSION_STATUS_DENIED;
+        }
+
+        final boolean targetsMOrHigher = context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.M;
+
+        for (String name : names) {
+            // Only handle them if the client app actually targets a API level greater than M.
+            if (targetsMOrHigher) {
+                if (permission == PermissionConstants.PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS) {
+                    String packageName = context.getPackageName();
+                    PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+                    // PowerManager.isIgnoringBatteryOptimizations has been included in Android M first.
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                        if (pm != null && pm.isIgnoringBatteryOptimizations(packageName)) {
+                            return PermissionConstants.PERMISSION_STATUS_GRANTED;
+                        } else {
+                            return PermissionConstants.PERMISSION_STATUS_DENIED;
+                        }
+                    } else {
+                        return PermissionConstants.PERMISSION_STATUS_RESTRICTED;
+                    }
+                }
+
+                if (permission == PermissionConstants.PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE) {
+                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+                        return PermissionConstants.PERMISSION_STATUS_RESTRICTED;
+                    }
+
+                    return Environment.isExternalStorageManager()
+                            ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                            : PermissionConstants.PERMISSION_STATUS_DENIED;
+                }
+
+                if (permission == PermissionConstants.PERMISSION_GROUP_SYSTEM_ALERT_WINDOW) {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                        return Settings.canDrawOverlays(context)
+                                ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                                : PermissionConstants.PERMISSION_STATUS_DENIED;
+                    }
+                }
+
+                if (permission == PermissionConstants.PERMISSION_GROUP_REQUEST_INSTALL_PACKAGES) {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                        return context.getPackageManager().canRequestPackageInstalls()
+                                ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                                : PermissionConstants.PERMISSION_STATUS_DENIED;
+                    }
+                }
+
+                if (permission == PermissionConstants.PERMISSION_GROUP_ACCESS_NOTIFICATION_POLICY) {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Application.NOTIFICATION_SERVICE);
+                        return notificationManager.isNotificationPolicyAccessGranted()
+                                ? PermissionConstants.PERMISSION_STATUS_GRANTED
+                                : PermissionConstants.PERMISSION_STATUS_DENIED;
+                    }
+                }
+
+                final int permissionStatus = ContextCompat.checkSelfPermission(context, name);
+                if (permissionStatus != PackageManager.PERMISSION_GRANTED) {
+                    return PermissionConstants.PERMISSION_STATUS_DENIED;
+                }
+            }
+        }
+        return PermissionConstants.PERMISSION_STATUS_GRANTED;
+    }
+
+    private void executeIntent(String action, int requestCode) {
+        String packageName = activity.getPackageName();
+        Intent intent = new Intent();
+        intent.setAction(action);
+        intent.setData(Uri.parse("package:" + packageName));
+        activity.startActivityForResult(intent, requestCode);
+    }
+
+    private void executeSimpleIntent(String action, int requestCode) {
+        activity.startActivityForResult(new Intent(action), requestCode);
+    }
+
+    void shouldShowRequestPermissionRationale(
+            int permission,
+            Activity activity,
+            ShouldShowRequestPermissionRationaleSuccessCallback successCallback,
+            ErrorCallback errorCallback) {
+        if (activity == null) {
+            Log.d(PermissionConstants.LOG_TAG, "Unable to detect current Activity.");
+
+            errorCallback.onError(
+                    "PermissionHandler.PermissionManager",
+                    "Unable to detect current Android Activity.");
+            return;
+        }
+
+        List<String> names = PermissionUtils.getManifestNames(activity, permission);
+
+        // if isn't an android specific group then go ahead and return false;
+        if (names == null) {
+            Log.d(PermissionConstants.LOG_TAG, "No android specific permissions needed for: " + permission);
+            successCallback.onSuccess(false);
+            return;
+        }
+
+        if (names.isEmpty()) {
+            Log.d(PermissionConstants.LOG_TAG, "No permissions found in manifest for: " + permission + " no need to show request rationale");
+            successCallback.onSuccess(false);
+            return;
+        }
+
+        successCallback.onSuccess(ActivityCompat.shouldShowRequestPermissionRationale(activity, names.get(0)));
+    }
+
+    private int checkNotificationPermissionStatus(Context context) {
+        NotificationManagerCompat manager = NotificationManagerCompat.from(context);
+        boolean isGranted = manager.areNotificationsEnabled();
+        if (isGranted) {
+            return PermissionConstants.PERMISSION_STATUS_GRANTED;
+        }
+        return PermissionConstants.PERMISSION_STATUS_DENIED;
+    }
+
+    private int checkBluetoothPermissionStatus(Context context) {
+        List<String> names = PermissionUtils.getManifestNames(context, PermissionConstants.PERMISSION_GROUP_BLUETOOTH);
+        boolean missingInManifest = names == null || names.isEmpty();
+        if (missingInManifest) {
+            Log.d(PermissionConstants.LOG_TAG, "Bluetooth permission missing in manifest");
+            return PermissionConstants.PERMISSION_STATUS_DENIED;
+        }
+        return PermissionConstants.PERMISSION_STATUS_GRANTED;
+    }
+}

android/src/main/java/com/baseflow/permissionhandler/PermissionUtils.java

+package com.baseflow.permissionhandler;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Environment;
+import android.util.Log;
+
+import androidx.annotation.RequiresApi;
+import androidx.core.app.ActivityCompat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class PermissionUtils {
+
+    @PermissionConstants.PermissionGroup
+    static int parseManifestName(String permission) {
+        switch (permission) {
+            case Manifest.permission.READ_CALENDAR:
+            case Manifest.permission.WRITE_CALENDAR:
+                return PermissionConstants.PERMISSION_GROUP_CALENDAR;
+            case Manifest.permission.CAMERA:
+                return PermissionConstants.PERMISSION_GROUP_CAMERA;
+            case Manifest.permission.READ_CONTACTS:
+            case Manifest.permission.WRITE_CONTACTS:
+            case Manifest.permission.GET_ACCOUNTS:
+                return PermissionConstants.PERMISSION_GROUP_CONTACTS;
+            case Manifest.permission.ACCESS_BACKGROUND_LOCATION:
+                return PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS;
+            case Manifest.permission.ACCESS_COARSE_LOCATION:
+            case Manifest.permission.ACCESS_FINE_LOCATION:
+                return PermissionConstants.PERMISSION_GROUP_LOCATION;
+            case Manifest.permission.RECORD_AUDIO:
+                return PermissionConstants.PERMISSION_GROUP_MICROPHONE;
+            case Manifest.permission.READ_PHONE_STATE:
+            case Manifest.permission.READ_PHONE_NUMBERS:
+            case Manifest.permission.CALL_PHONE:
+            case Manifest.permission.READ_CALL_LOG:
+            case Manifest.permission.WRITE_CALL_LOG:
+            case Manifest.permission.ADD_VOICEMAIL:
+            case Manifest.permission.USE_SIP:
+            case Manifest.permission.BIND_CALL_REDIRECTION_SERVICE:
+                return PermissionConstants.PERMISSION_GROUP_PHONE;
+            case Manifest.permission.BODY_SENSORS:
+                return PermissionConstants.PERMISSION_GROUP_SENSORS;
+            case Manifest.permission.SEND_SMS:
+            case Manifest.permission.RECEIVE_SMS:
+            case Manifest.permission.READ_SMS:
+            case Manifest.permission.RECEIVE_WAP_PUSH:
+            case Manifest.permission.RECEIVE_MMS:
+                return PermissionConstants.PERMISSION_GROUP_SMS;
+            case Manifest.permission.READ_EXTERNAL_STORAGE:
+            case Manifest.permission.WRITE_EXTERNAL_STORAGE:
+                return PermissionConstants.PERMISSION_GROUP_STORAGE;
+            case Manifest.permission.ACCESS_MEDIA_LOCATION:
+                return PermissionConstants.PERMISSION_GROUP_ACCESS_MEDIA_LOCATION;
+            case Manifest.permission.ACTIVITY_RECOGNITION:
+                return PermissionConstants.PERMISSION_GROUP_ACTIVITY_RECOGNITION;
+            case Manifest.permission.MANAGE_EXTERNAL_STORAGE:
+                return PermissionConstants.PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE;
+            case Manifest.permission.SYSTEM_ALERT_WINDOW:
+                return PermissionConstants.PERMISSION_GROUP_SYSTEM_ALERT_WINDOW;
+            case Manifest.permission.REQUEST_INSTALL_PACKAGES:
+                return PermissionConstants.PERMISSION_GROUP_REQUEST_INSTALL_PACKAGES;
+            case Manifest.permission.ACCESS_NOTIFICATION_POLICY:
+                return PermissionConstants.PERMISSION_GROUP_ACCESS_NOTIFICATION_POLICY;
+            default:
+                return PermissionConstants.PERMISSION_GROUP_UNKNOWN;
+        }
+    }
+
+    static List<String> getManifestNames(Context context, @PermissionConstants.PermissionGroup int permission) {
+        final ArrayList<String> permissionNames = new ArrayList<>();
+
+        switch (permission) {
+            case PermissionConstants.PERMISSION_GROUP_CALENDAR:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.READ_CALENDAR))
+                    permissionNames.add(Manifest.permission.READ_CALENDAR);
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.WRITE_CALENDAR))
+                    permissionNames.add(Manifest.permission.WRITE_CALENDAR);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_CAMERA:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.CAMERA))
+                    permissionNames.add(Manifest.permission.CAMERA);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_CONTACTS:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.READ_CONTACTS))
+                    permissionNames.add(Manifest.permission.READ_CONTACTS);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.WRITE_CONTACTS))
+                    permissionNames.add(Manifest.permission.WRITE_CONTACTS);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.GET_ACCOUNTS))
+                    permissionNames.add(Manifest.permission.GET_ACCOUNTS);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS:
+                // Note that the LOCATION_ALWAYS will deliberately fallthrough to the LOCATION
+                // case on pre Android Q devices. The ACCESS_BACKGROUND_LOCATION permission was only
+                // introduced in Android Q, before it should be treated as the ACCESS_COARSE_LOCATION or
+                // ACCESS_FINE_LOCATION.
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    if (hasPermissionInManifest(context, permissionNames, Manifest.permission.ACCESS_BACKGROUND_LOCATION))
+                        permissionNames.add(Manifest.permission.ACCESS_BACKGROUND_LOCATION);
+                }
+            case PermissionConstants.PERMISSION_GROUP_LOCATION_WHEN_IN_USE:
+            case PermissionConstants.PERMISSION_GROUP_LOCATION:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.ACCESS_COARSE_LOCATION))
+                    permissionNames.add(Manifest.permission.ACCESS_COARSE_LOCATION);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.ACCESS_FINE_LOCATION))
+                    permissionNames.add(Manifest.permission.ACCESS_FINE_LOCATION);
+                break;
+
+
+            case PermissionConstants.PERMISSION_GROUP_SPEECH:
+            case PermissionConstants.PERMISSION_GROUP_MICROPHONE:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.RECORD_AUDIO))
+                    permissionNames.add(Manifest.permission.RECORD_AUDIO);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_PHONE:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.READ_PHONE_STATE))
+                    permissionNames.add(Manifest.permission.READ_PHONE_STATE);
+
+                if (android.os.Build.VERSION.SDK_INT > Build.VERSION_CODES.Q && hasPermissionInManifest(context, permissionNames, Manifest.permission.READ_PHONE_NUMBERS)) {
+                    permissionNames.add(Manifest.permission.READ_PHONE_NUMBERS);
+                }
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.CALL_PHONE))
+                    permissionNames.add(Manifest.permission.CALL_PHONE);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.READ_CALL_LOG))
+                    permissionNames.add(Manifest.permission.READ_CALL_LOG);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.WRITE_CALL_LOG))
+                    permissionNames.add(Manifest.permission.WRITE_CALL_LOG);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.ADD_VOICEMAIL))
+                    permissionNames.add(Manifest.permission.ADD_VOICEMAIL);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.USE_SIP))
+                    permissionNames.add(Manifest.permission.USE_SIP);
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && hasPermissionInManifest(context, permissionNames, Manifest.permission.BIND_CALL_REDIRECTION_SERVICE))
+                    permissionNames.add(Manifest.permission.BIND_CALL_REDIRECTION_SERVICE);
+
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && hasPermissionInManifest(context, permissionNames, Manifest.permission.ANSWER_PHONE_CALLS))
+                    permissionNames.add(Manifest.permission.ANSWER_PHONE_CALLS);
+
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_SENSORS:
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
+                    if (hasPermissionInManifest(context, permissionNames, Manifest.permission.BODY_SENSORS)) {
+                        permissionNames.add(Manifest.permission.BODY_SENSORS);
+                    }
+                }
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_SMS:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.SEND_SMS))
+                    permissionNames.add(Manifest.permission.SEND_SMS);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.RECEIVE_SMS))
+                    permissionNames.add(Manifest.permission.RECEIVE_SMS);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.READ_SMS))
+                    permissionNames.add(Manifest.permission.READ_SMS);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.RECEIVE_WAP_PUSH))
+                    permissionNames.add(Manifest.permission.RECEIVE_WAP_PUSH);
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.RECEIVE_MMS))
+                    permissionNames.add(Manifest.permission.RECEIVE_MMS);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_STORAGE:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.READ_EXTERNAL_STORAGE))
+                    permissionNames.add(Manifest.permission.READ_EXTERNAL_STORAGE);
+
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q || (Build.VERSION.SDK_INT == Build.VERSION_CODES.Q && Environment.isExternalStorageLegacy())) {
+                    if (hasPermissionInManifest(context, permissionNames, Manifest.permission.WRITE_EXTERNAL_STORAGE))
+                        permissionNames.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
+                    break;
+                }
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS:
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && hasPermissionInManifest(context, permissionNames, Manifest.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS))
+                    permissionNames.add(Manifest.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_ACCESS_MEDIA_LOCATION:
+                // The ACCESS_MEDIA_LOCATION permission is introduced in Android Q, meaning we should
+                // not handle permissions on pre Android Q devices.
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q)
+                    return null;
+
+                if(hasPermissionInManifest(context, permissionNames, Manifest.permission.ACCESS_MEDIA_LOCATION))
+                    permissionNames.add(Manifest.permission.ACCESS_MEDIA_LOCATION);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_ACTIVITY_RECOGNITION:
+                // The ACTIVITY_RECOGNITION permission is introduced in Android Q, meaning we should
+                // not handle permissions on pre Android Q devices.
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q)
+                    return null;
+
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.ACTIVITY_RECOGNITION))
+                    permissionNames.add(Manifest.permission.ACTIVITY_RECOGNITION);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_BLUETOOTH:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.BLUETOOTH))
+                    permissionNames.add(Manifest.permission.BLUETOOTH);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_MANAGE_EXTERNAL_STORAGE:
+                // The MANAGE_EXTERNAL_STORAGE permission is introduced in Android R, meaning we should
+                // not handle permissions on pre Android R devices.
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && hasPermissionInManifest(context, permissionNames, Manifest.permission.MANAGE_EXTERNAL_STORAGE ))
+                    permissionNames.add(Manifest.permission.MANAGE_EXTERNAL_STORAGE);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_SYSTEM_ALERT_WINDOW:
+                if (hasPermissionInManifest(context, permissionNames, Manifest.permission.SYSTEM_ALERT_WINDOW ))
+                    permissionNames.add(Manifest.permission.SYSTEM_ALERT_WINDOW);
+                break;
+
+            case PermissionConstants.PERMISSION_GROUP_REQUEST_INSTALL_PACKAGES:
+                // The REQUEST_INSTALL_PACKAGES permission is introduced in Android M, meaning we should
+                // not handle permissions on pre Android M devices.
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && hasPermissionInManifest(context, permissionNames, Manifest.permission.REQUEST_INSTALL_PACKAGES ))
+                    permissionNames.add(Manifest.permission.REQUEST_INSTALL_PACKAGES);
+                break;
+            case PermissionConstants.PERMISSION_GROUP_ACCESS_NOTIFICATION_POLICY:
+                // The REQUEST_NOTIFICATION_POLICY permission is introduced in Android M, meaning we should
+                // not handle permissions on pre Android M devices.
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && hasPermissionInManifest(context, permissionNames, Manifest.permission.ACCESS_NOTIFICATION_POLICY ))
+                    permissionNames.add(Manifest.permission.ACCESS_NOTIFICATION_POLICY);
+                break;
+            case PermissionConstants.PERMISSION_GROUP_NOTIFICATION:
+            case PermissionConstants.PERMISSION_GROUP_MEDIA_LIBRARY:
+            case PermissionConstants.PERMISSION_GROUP_PHOTOS:
+            case PermissionConstants.PERMISSION_GROUP_REMINDERS:
+            case PermissionConstants.PERMISSION_GROUP_UNKNOWN:
+                return null;
+        }
+
+        return permissionNames;
+    }
+
+    private static boolean hasPermissionInManifest(Context context, ArrayList<String> confirmedPermissions, String permission) {
+        try {
+            if (confirmedPermissions != null) {
+                for (String r : confirmedPermissions) {
+                    if (r.equals(permission)) {
+                        return true;
+                    }
+                }
+            }
+
+            if (context == null) {
+                Log.d(PermissionConstants.LOG_TAG, "Unable to detect current Activity or App Context.");
+                return false;
+            }
+
+            PackageInfo info = context
+                    .getPackageManager()
+                    .getPackageInfo(context.getPackageName(), PackageManager.GET_PERMISSIONS);
+
+            if (info == null) {
+                Log.d(PermissionConstants.LOG_TAG, "Unable to get Package info, will not be able to determine permissions to request.");
+                return false;
+            }
+
+            confirmedPermissions = new ArrayList<>(Arrays.asList(info.requestedPermissions));
+            for (String r : confirmedPermissions) {
+                if (r.equals(permission)) {
+                    return true;
+                }
+            }
+        } catch (Exception ex) {
+            Log.d(PermissionConstants.LOG_TAG, "Unable to check manifest for permission: ", ex);
+        }
+        return false;
+    }
+
+    @PermissionConstants.PermissionStatus
+    static int toPermissionStatus(final Activity activity, final String permissionName, int grantResult) {
+        if (grantResult == PackageManager.PERMISSION_DENIED) {
+            return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && PermissionUtils.isNeverAskAgainSelected(activity, permissionName)
+                    ? PermissionConstants.PERMISSION_STATUS_NEVER_ASK_AGAIN
+                    : PermissionConstants.PERMISSION_STATUS_DENIED;
+        }
+
+        return PermissionConstants.PERMISSION_STATUS_GRANTED;
+    }
+
+    static void updatePermissionShouldShowStatus(final Activity activity, @PermissionConstants.PermissionGroup int permission) {
+        if (activity == null) {
+            return;
+        }
+
+        List<String> names = getManifestNames(activity, permission);
+
+        if (names == null || names.isEmpty()) {
+            return;
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.M)
+    static boolean isNeverAskAgainSelected(final Activity activity, final String name) {
+        if (activity == null) {
+            return false;
+        }
+
+        final boolean shouldShowRequestPermissionRationale = ActivityCompat.shouldShowRequestPermissionRationale(activity, name);
+        return !shouldShowRequestPermissionRationale;
+    }
+
+    private static String determineBluetoothPermission(Context context, String permission) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            if(hasPermissionInManifest(context, null, Manifest.permission.ACCESS_FINE_LOCATION)){
+                return Manifest.permission.ACCESS_FINE_LOCATION;
+            } else if (hasPermissionInManifest(context, null, Manifest.permission.ACCESS_COARSE_LOCATION)){
+                return Manifest.permission.ACCESS_COARSE_LOCATION;
+            }
+
+            return  null;
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && hasPermissionInManifest(context, null, Manifest.permission.ACCESS_FINE_LOCATION)) {
+            return Manifest.permission.ACCESS_FINE_LOCATION;
+        }
+
+        return null;
+    }
+}

android/src/main/java/com/baseflow/permissionhandler/ServiceManager.java

+package com.baseflow.permissionhandler;
+
+import static android.content.Context.BLUETOOTH_SERVICE;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothManager;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.location.LocationManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.provider.Settings;
+import android.telephony.TelephonyManager;
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.util.List;
+
+final class ServiceManager {
+    @FunctionalInterface
+    interface SuccessCallback {
+        void onSuccess(@PermissionConstants.ServiceStatus int serviceStatus);
+    }
+
+    void checkServiceStatus(
+            int permission,
+            Context context,
+            SuccessCallback successCallback,
+            ErrorCallback errorCallback) {
+        if(context == null) {
+            Log.d(PermissionConstants.LOG_TAG, "Context cannot be null.");
+            errorCallback.onError("PermissionHandler.ServiceManager", "Android context cannot be null.");
+            return;
+        }
+
+        if (permission == PermissionConstants.PERMISSION_GROUP_LOCATION ||
+            permission == PermissionConstants.PERMISSION_GROUP_LOCATION_ALWAYS ||
+            permission == PermissionConstants.PERMISSION_GROUP_LOCATION_WHEN_IN_USE) {
+            final int serviceStatus = isLocationServiceEnabled(context)
+                    ? PermissionConstants.SERVICE_STATUS_ENABLED
+                    : PermissionConstants.SERVICE_STATUS_DISABLED;
+
+            successCallback.onSuccess(serviceStatus);
+            return;
+        }
+        if(permission == PermissionConstants.PERMISSION_GROUP_BLUETOOTH){
+            final int serviceStatus = isBluetoothServiceEnabled(context)
+                    ? PermissionConstants.SERVICE_STATUS_ENABLED
+                    : PermissionConstants.SERVICE_STATUS_DISABLED;
+
+            successCallback.onSuccess(serviceStatus);
+        }
+
+        if (permission == PermissionConstants.PERMISSION_GROUP_PHONE) {
+            PackageManager pm = context.getPackageManager();
+            if (!pm.hasSystemFeature(PackageManager.FEATURE_TELEPHONY)) {
+                successCallback.onSuccess(PermissionConstants.SERVICE_STATUS_NOT_APPLICABLE);
+                return;
+            }
+
+            TelephonyManager telephonyManager = (TelephonyManager) context
+                    .getSystemService(Context.TELEPHONY_SERVICE);
+
+            if (telephonyManager == null || telephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) {
+                successCallback.onSuccess(PermissionConstants.SERVICE_STATUS_NOT_APPLICABLE);
+                return;
+            }
+
+            Intent callIntent = new Intent(Intent.ACTION_CALL);
+            callIntent.setData(Uri.parse("tel:123123"));
+            List<ResolveInfo> callAppsList = pm.queryIntentActivities(callIntent, 0);
+
+            if (callAppsList.isEmpty()) {
+                successCallback.onSuccess(PermissionConstants.SERVICE_STATUS_NOT_APPLICABLE);
+                return;
+            }
+
+            if (telephonyManager.getSimState() != TelephonyManager.SIM_STATE_READY) {
+                successCallback.onSuccess(PermissionConstants.SERVICE_STATUS_DISABLED);
+                return;
+            }
+
+            successCallback.onSuccess(PermissionConstants.SERVICE_STATUS_ENABLED);
+            return;
+        }
+
+        if (permission == PermissionConstants.PERMISSION_GROUP_IGNORE_BATTERY_OPTIMIZATIONS) {
+            final int serviceStatus = Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
+                    ? PermissionConstants.SERVICE_STATUS_ENABLED
+                    : PermissionConstants.SERVICE_STATUS_NOT_APPLICABLE;
+            successCallback.onSuccess(serviceStatus);
+            return;
+        }
+
+        successCallback.onSuccess(PermissionConstants.SERVICE_STATUS_NOT_APPLICABLE);
+    }
+
+    private boolean isLocationServiceEnabled(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            final LocationManager locationManager = context.getSystemService(LocationManager.class);
+            if (locationManager == null) {
+                return false;
+            }
+
+            return locationManager.isLocationEnabled();
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+            return isLocationServiceEnabledKitKat(context);
+        } else {
+            return isLocationServiceEnablePreKitKat(context);
+        }
+    }
+
+    // Suppress deprecation warnings since its purpose is to support to be backwards compatible with
+    // pre Pie versions of Android.
+    @SuppressWarnings("deprecation")
+    private static boolean isLocationServiceEnabledKitKat(Context context)
+    {
+        if (Build.VERSION.SDK_INT < VERSION_CODES.KITKAT) {
+            return false;
+        }
+
+        final int locationMode;
+
+        try {
+            locationMode = Settings.Secure.getInt(
+                    context.getContentResolver(),
+                    Settings.Secure.LOCATION_MODE);
+        } catch (Settings.SettingNotFoundException e) {
+            e.printStackTrace();
+            return false;
+        }
+
+        return locationMode != Settings.Secure.LOCATION_MODE_OFF;
+    }
+
+    // Suppress deprecation warnings since its purpose is to support to be backwards compatible with
+    // pre KitKat versions of Android.
+    @SuppressWarnings("deprecation")
+    private static boolean isLocationServiceEnablePreKitKat(Context context)
+    {
+        if (VERSION.SDK_INT >= VERSION_CODES.KITKAT)
+            return false;
+
+        final String locationProviders = Settings.Secure.getString(
+                context.getContentResolver(),
+                Settings.Secure.LOCATION_PROVIDERS_ALLOWED);
+        return !TextUtils.isEmpty(locationProviders);
+    }
+    // Suppress deprecation warnings since its purpose is to support to be backwards compatible with
+    // pre S versions of Android
+    @SuppressWarnings("deprecation")
+    private boolean isBluetoothServiceEnabled(Context context) {
+        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            return BluetoothAdapter.getDefaultAdapter().isEnabled();
+        } 
+        
+        BluetoothManager manager = (BluetoothManager) context.getSystemService(BLUETOOTH_SERVICE);
+        final BluetoothAdapter adapter = manager.getAdapter();
+        return adapter.isEnabled();
+    }
+}

example/README.md

+# permission_handler_example
+
+Demonstrates how to use the permission_handler plugin.
+
+## Getting Started
+
+This project is a starting point for a Flutter application.
+
+A few resources to get you started if this is your first Flutter project:
+
+- [Lab: Write your first Flutter app](https://flutter.io/docs/get-started/codelab)
+- [Cookbook: Useful Flutter samples](https://flutter.io/docs/cookbook)
+
+For help getting started with Flutter, view our 
+[online documentation](https://flutter.io/docs), which offers tutorials, 
+samples, guidance on mobile development, and a full API reference.

example/android/app/build.gradle

+def localProperties = new Properties()
+def localPropertiesFile = rootProject.file('local.properties')
+if (localPropertiesFile.exists()) {
+    localPropertiesFile.withReader('UTF-8') { reader ->
+        localProperties.load(reader)
+    }
+}
+
+def flutterRoot = localProperties.getProperty('flutter.sdk')
+if (flutterRoot == null) {
+    throw new GradleException("Flutter SDK not found. Define location with flutter.sdk in the local.properties file.")
+}
+
+def flutterVersionCode = localProperties.getProperty('flutter.versionCode')
+if (flutterVersionCode == null) {
+    flutterVersionCode = '1'
+}
+
+def flutterVersionName = localProperties.getProperty('flutter.versionName')
+if (flutterVersionName == null) {
+    flutterVersionName = '1.0'
+}
+
+apply plugin: 'com.android.application'
+apply from: "$flutterRoot/packages/flutter_tools/gradle/flutter.gradle"
+
+android {
+    compileSdkVersion 31
+
+    lintOptions {
+        disable 'InvalidPackage'
+    }
+
+    defaultConfig {
+        applicationId "com.baseflow.permissionhandler.example"
+        minSdkVersion 16
+        targetSdkVersion 31
+        versionCode flutterVersionCode.toInteger()
+        versionName flutterVersionName
+    }
+
+    buildTypes {
+        release {
+            // TODO: Add your own signing config for the release build.
+            // Signing with the debug keys for now, so `flutter run --release` works.
+            signingConfig signingConfigs.debug
+        }
+    }
+}
+
+flutter {
+    source '../..'
+}
\ No newline at end of file

example/android/app/src/debug/AndroidManifest.xml

+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.baseflow.permissionhandler.example">
+    <!-- Flutter needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>

example/android/app/src/main/AndroidManifest.xml

+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    package="com.baseflow.permissionhandler.example">
+
+    <!--
+    Internet permissions do not affect the `permission_handler` plugin, but are required if your app needs access to
+    the internet.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+
+    <!-- Permissions options for the `contacts` group -->
+    <uses-permission android:name="android.permission.READ_CONTACTS"/>
+    <uses-permission android:name="android.permission.WRITE_CONTACTS"/>
+    <uses-permission android:name="android.permission.GET_ACCOUNTS"/>
+
+    <!-- Permissions options for the `storage` group -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+
+    <!-- Permissions options for the `camera` group -->
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <!-- Permissions options for the `sms` group -->
+    <uses-permission android:name="android.permission.SEND_SMS"/>
+    <uses-permission android:name="android.permission.RECEIVE_SMS"/>
+    <uses-permission android:name="android.permission.READ_SMS"/>
+    <uses-permission android:name="android.permission.RECEIVE_WAP_PUSH"/>
+    <uses-permission android:name="android.permission.RECEIVE_MMS"/>
+
+    <!-- Permissions options for the `phone` group -->
+    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
+    <uses-permission android:name="android.permission.CALL_PHONE"/>
+    <uses-permission android:name="android.permission.ADD_VOICEMAIL"/>
+    <uses-permission android:name="android.permission.USE_SIP"/>
+    <uses-permission android:name="android.permission.READ_CALL_LOG"/>
+    <uses-permission android:name="android.permission.WRITE_CALL_LOG"/>
+    <uses-permission android:name="android.permission.BIND_CALL_REDIRECTION_SERVICE"/>
+
+    <!-- Permissions options for the `calendar` group -->
+    <uses-permission android:name="android.permission.READ_CALENDAR" />
+    <uses-permission android:name="android.permission.WRITE_CALENDAR" />
+
+    <!-- Permissions options for the `location` group -->
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
+
+    <!-- Permissions options for the `microphone` or `speech` group -->
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <!-- Permissions options for the `sensors` group -->
+    <uses-permission android:name="android.permission.BODY_SENSORS" />
+
+    <!-- Permissions options for the `accessMediaLocation` group -->
+    <uses-permission android:name="android.permission.ACCESS_MEDIA_LOCATION" />
+
+    <!-- Permissions options for the `activityRecognition` group -->
+    <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
+
+    <!-- Permissions options for the `ignoreBatteryOptimizations` group -->
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+
+    <!-- Permissions options for the `bluetooth` group -->
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+
+    <!-- Permissions options for the `manage external storage` group -->
+    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
+
+    <!-- Permissions options for the `system alert windows` group -->
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+
+    <!-- Permissions options for the `request install packages` group -->
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
+
+    <!-- Permissions options for the `access notification policy` group -->
+    <uses-permission android:name="android.permission.ACCESS_NOTIFICATION_POLICY"/>
+
+    <application
+        android:name="io.flutter.app.FlutterApplication"
+        android:icon="@mipmap/ic_launcher"
+        android:label="permission_handler_example"
+        tools:ignore="AllowBackup,GoogleAppIndexingWarning">
+
+        <activity android:name="io.flutter.embedding.android.FlutterActivity"
+            android:launchMode="singleTop"
+            android:theme="@android:style/Theme.Black.NoTitleBar"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection"
+            android:hardwareAccelerated="true"
+            android:windowSoftInputMode="adjustResize"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+
+        <meta-data
+            android:name="flutterEmbedding"
+            android:value="2" />
+    </application>
+</manifest>

example/android/app/src/main/kotlin/com/example/example/MainActivity.kt

+package com.example.example
+
+import io.flutter.embedding.android.FlutterActivity
+
+class MainActivity: FlutterActivity() {
+}

example/android/app/src/main/res/drawable-v21/launch_background.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="?android:colorBackground" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>

example/android/app/src/main/res/drawable/launch_background.xml

+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@android:color/white" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>

example/android/app/src/main/res/values-night/styles.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is on -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             Flutter draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+         
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

example/android/app/src/main/res/values/styles.xml

+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             Flutter draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+</resources>

example/android/app/src/profile/AndroidManifest.xml

+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.permissionhandlerexample">
+    <!-- Flutter needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+
+    <!-- Permissions options for the `contacts` group -->
+    <uses-permission android:name="android.permission.READ_CONTACTS"/>
+    <uses-permission android:name="android.permission.WRITE_CONTACTS"/>
+    <uses-permission android:name="android.permission.GET_ACCOUNTS"/>
+
+    <!-- Permissions options for the `storage` group -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+
+    <!-- Permissions options for the `camera` group -->
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+    <!-- Permissions options for the `sms` group -->
+    <uses-permission android:name="android.permission.SEND_SMS"/>
+    <uses-permission android:name="android.permission.RECEIVE_SMS"/>
+    <uses-permission android:name="android.permission.READ_SMS"/>
+    <uses-permission android:name="android.permission.RECEIVE_WAP_PUSH"/>
+    <uses-permission android:name="android.permission.RECEIVE_MMS"/>
+
+    <!-- Permissions options for the `phone` group -->
+    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
+    <uses-permission android:name="android.permission.CALL_PHONE"/>
+    <uses-permission android:name="android.permission.ADD_VOICEMAIL"/>
+    <uses-permission android:name="android.permission.USE_SIP"/>
+    <uses-permission android:name="android.permission.READ_CALL_LOG"/>
+    <uses-permission android:name="android.permission.WRITE_CALL_LOG"/>
+    <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS"/>
+
+    <!-- Permissions options for the `calendar` group -->
+    <uses-permission android:name="android.permission.READ_CALENDAR" />
+    <uses-permission android:name="android.permission.WRITE_CALENDAR" />
+
+    <!-- Permissions options for the `location` group -->
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+
+    <!-- Permissions options for the `microphone` or `speech` group -->
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <!-- Permissions options for the `sensors` group -->
+    <uses-permission android:name="android.permission.BODY_SENSORS" />
+
+    <!-- Permissions options for the `access notification policy` group -->
+    <uses-permission android:name="android.permission.ACCESS_NOTIFICATION_POLICY"/>
+</manifest>

example/android/build.gradle

+buildscript {
+    repositories {
+        google()
+        jcenter()
+    }
+
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.0.2'
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        jcenter()
+    }
+}
+
+rootProject.buildDir = '../build'
+subprojects {
+    project.buildDir = "${rootProject.buildDir}/${project.name}"
+}
+subprojects {
+    project.evaluationDependsOn(':app')
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

example/android/gradle.properties

+org.gradle.jvmargs=-Xmx1536M
+android.enableJetifier=true
+android.useAndroidX=true

example/android/gradle/wrapper/gradle-wrapper.properties

+#Thu May 16 14:57:52 BST 2019
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-all.zip

example/android/settings.gradle

+include ':app'
+
+def flutterProjectRoot = rootProject.projectDir.parentFile.toPath()
+
+def plugins = new Properties()
+def pluginsFile = new File(flutterProjectRoot.toFile(), '.flutter-plugins')
+if (pluginsFile.exists()) {
+    pluginsFile.withReader('UTF-8') { reader -> plugins.load(reader) }
+}
+
+plugins.each { name, path ->
+    def pluginDirectory = flutterProjectRoot.resolve(path).resolve('android').toFile()
+    include ":$name"
+    project(":$name").projectDir = pluginDirectory
+}

example/ios/Flutter/AppFrameworkInfo.plist

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>$(DEVELOPMENT_LANGUAGE)</string>
+  <key>CFBundleExecutable</key>
+  <string>App</string>
+  <key>CFBundleIdentifier</key>
+  <string>io.flutter.flutter.app</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>App</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>1.0</string>
+  <key>MinimumOSVersion</key>
+  <string>8.0</string>
+</dict>
+</plist>

example/ios/Flutter/Debug.xcconfig

+#include "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"
+#include "Generated.xcconfig"

example/ios/Flutter/Release.xcconfig

+#include "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"
+#include "Generated.xcconfig"

example/ios/Podfile

+# Uncomment this line to define a global platform for your project
+# platform :ios, '9.0'
+
+# CocoaPods analytics sends network stats synchronously affecting flutter build latency.
+ENV['COCOAPODS_DISABLE_STATS'] = 'true'
+
+project 'Runner', {
+  'Debug' => :debug,
+  'Profile' => :release,
+  'Release' => :release,
+}
+
+def flutter_root
+  generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'Generated.xcconfig'), __FILE__)
+  unless File.exist?(generated_xcode_build_settings_path)
+    raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure flutter pub get is executed first"
+  end
+
+  File.foreach(generated_xcode_build_settings_path) do |line|
+    matches = line.match(/FLUTTER_ROOT\=(.*)/)
+    return matches[1].strip if matches
+  end
+  raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Generated.xcconfig, then run flutter pub get"
+end
+
+require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root)
+
+flutter_ios_podfile_setup
+
+target 'Runner' do
+  use_frameworks!
+  use_modular_headers!
+
+  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
+end
+
+post_install do |installer|
+  installer.pods_project.targets.each do |target|
+    flutter_additional_ios_build_settings(target)
+
+    target.build_configurations.each do |config|
+      # You can remove unused permissions here
+      # for more infomation: https://github.com/BaseflowIT/flutter-permission-handler/blob/master/permission_handler/ios/Classes/PermissionHandlerEnums.h
+      # e.g. when you don't need camera permission, just add 'PERMISSION_CAMERA=0'
+      config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] ||= [
+        '$(inherited)',
+
+        ## dart: PermissionGroup.calendar
+        'PERMISSION_EVENTS=1',
+
+        ## dart: PermissionGroup.reminders
+        'PERMISSION_REMINDERS=1',
+
+        ## dart: PermissionGroup.contacts
+        'PERMISSION_CONTACTS=1',
+
+        ## dart: PermissionGroup.camera
+        'PERMISSION_CAMERA=1',
+
+        ## dart: PermissionGroup.microphone
+        'PERMISSION_MICROPHONE=1',
+
+        ## dart: PermissionGroup.speech
+        'PERMISSION_SPEECH_RECOGNIZER=1',
+
+        ## dart: PermissionGroup.photos
+        'PERMISSION_PHOTOS=1',
+
+        ## dart: [PermissionGroup.location, PermissionGroup.locationAlways, PermissionGroup.locationWhenInUse]
+        'PERMISSION_LOCATION=1',
+       
+        ## dart: PermissionGroup.notification
+        'PERMISSION_NOTIFICATIONS=1',
+
+        ## dart: PermissionGroup.mediaLibrary
+        'PERMISSION_MEDIA_LIBRARY=1',
+
+        ## dart: PermissionGroup.sensors
+        'PERMISSION_SENSORS=1',
+
+        ## dart: PermissionGroup.bluetooth
+        'PERMISSION_BLUETOOTH=1',
+
+        ## dart: PermissionGroup.appTrackingTransparency
+        'PERMISSION_APP_TRACKING_TRANSPARENCY=1',
+
+        ## dart: PermissionGroup.criticalAlerts
+        'PERMISSION_CRITICAL_ALERTS=1',
+      ]
+
+    end
+  end
+end

example/ios/Podfile.lock

+PODS:
+  - Flutter (1.0.0)
+  - "permission_handler (5.1.0+2)":
+    - Flutter
+  - url_launcher (0.0.1):
+    - Flutter
+
+DEPENDENCIES:
+  - Flutter (from `Flutter`)
+  - permission_handler (from `.symlinks/plugins/permission_handler/ios`)
+  - url_launcher (from `.symlinks/plugins/url_launcher/ios`)
+
+EXTERNAL SOURCES:
+  Flutter:
+    :path: Flutter
+  permission_handler:
+    :path: ".symlinks/plugins/permission_handler/ios"
+  url_launcher:
+    :path: ".symlinks/plugins/url_launcher/ios"
+
+SPEC CHECKSUMS:
+  Flutter: 434fef37c0980e73bb6479ef766c45957d4b510c
+  permission_handler: ccb20a9fad0ee9b1314a52b70b76b473c5f8dab0
+  url_launcher: 6fef411d543ceb26efce54b05a0a40bfd74cbbef
+
+PODFILE CHECKSUM: 4b73f6bd84be061adf82c3a307fdf146c15a9138
+
+COCOAPODS: 1.10.1

example/ios/Runner.xcodeproj/project.pbxproj

+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 51;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; };
+		3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; };
+		74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; };
+		97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };
+		97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };
+		97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };
+		B501E7F22BA22C455255CE2E /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = C446183715B92022DDB68882 /* Pods_Runner.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		9705A1C41CF9048500538489 /* Embed Frameworks */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 10;
+			files = (
+			);
+			name = "Embed Frameworks";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = "<group>"; };
+		1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = "<group>"; };
+		3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = "<group>"; };
+		74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = "<group>"; };
+		74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = "<group>"; };
+		862A53EA392D32566500E869 /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = "<group>"; };
+		9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = "<group>"; };
+		9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = "<group>"; };
+		97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		C446183715B92022DDB68882 /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+		CEA40B36DE135D81D16B7399 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = "<group>"; };
+		DA7CB50DE8057A7A8D126AC9 /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		97C146EB1CF9000F007C117D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				B501E7F22BA22C455255CE2E /* Pods_Runner.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		2982F40ECD3DD26A4434B596 /* Pods */ = {
+			isa = PBXGroup;
+			children = (
+				CEA40B36DE135D81D16B7399 /* Pods-Runner.debug.xcconfig */,
+				862A53EA392D32566500E869 /* Pods-Runner.release.xcconfig */,
+				DA7CB50DE8057A7A8D126AC9 /* Pods-Runner.profile.xcconfig */,
+			);
+			path = Pods;
+			sourceTree = "<group>";
+		};
+		7EF8E4A69F95E4BF7F747BE9 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				C446183715B92022DDB68882 /* Pods_Runner.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		9740EEB11CF90186004384FC /* Flutter */ = {
+			isa = PBXGroup;
+			children = (
+				3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */,
+				9740EEB21CF90195004384FC /* Debug.xcconfig */,
+				7AFA3C8E1D35360C0083082E /* Release.xcconfig */,
+				9740EEB31CF90195004384FC /* Generated.xcconfig */,
+			);
+			name = Flutter;
+			sourceTree = "<group>";
+		};
+		97C146E51CF9000F007C117D = {
+			isa = PBXGroup;
+			children = (
+				9740EEB11CF90186004384FC /* Flutter */,
+				97C146F01CF9000F007C117D /* Runner */,
+				97C146EF1CF9000F007C117D /* Products */,
+				2982F40ECD3DD26A4434B596 /* Pods */,
+				7EF8E4A69F95E4BF7F747BE9 /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		97C146EF1CF9000F007C117D /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				97C146EE1CF9000F007C117D /* Runner.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		97C146F01CF9000F007C117D /* Runner */ = {
+			isa = PBXGroup;
+			children = (
+				97C146FA1CF9000F007C117D /* Main.storyboard */,
+				97C146FD1CF9000F007C117D /* Assets.xcassets */,
+				97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */,
+				97C147021CF9000F007C117D /* Info.plist */,
+				1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */,
+				1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */,
+				74858FAE1ED2DC5600515810 /* AppDelegate.swift */,
+				74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */,
+			);
+			path = Runner;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		97C146ED1CF9000F007C117D /* Runner */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */;
+			buildPhases = (
+				5CF31A8C72B66ABB365E813D /* [CP] Check Pods Manifest.lock */,
+				9740EEB61CF901F6004384FC /* Run Script */,
+				97C146EA1CF9000F007C117D /* Sources */,
+				97C146EB1CF9000F007C117D /* Frameworks */,
+				97C146EC1CF9000F007C117D /* Resources */,
+				9705A1C41CF9048500538489 /* Embed Frameworks */,
+				3B06AD1E1E4923F5004D2608 /* Thin Binary */,
+				D38B08CB85942E5D11545EE3 /* [CP] Embed Pods Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = Runner;
+			productName = Runner;
+			productReference = 97C146EE1CF9000F007C117D /* Runner.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		97C146E61CF9000F007C117D /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 1020;
+				ORGANIZATIONNAME = "";
+				TargetAttributes = {
+					97C146ED1CF9000F007C117D = {
+						CreatedOnToolsVersion = 7.3.1;
+						LastSwiftMigration = 1100;
+					};
+				};
+			};
+			buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 97C146E51CF9000F007C117D;
+			productRefGroup = 97C146EF1CF9000F007C117D /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				97C146ED1CF9000F007C117D /* Runner */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		97C146EC1CF9000F007C117D /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */,
+				3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */,
+				97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */,
+				97C146FC1CF9000F007C117D /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		3B06AD1E1E4923F5004D2608 /* Thin Binary */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Thin Binary";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin";
+		};
+		5CF31A8C72B66ABB365E813D /* [CP] Check Pods Manifest.lock */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+				"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
+				"${PODS_ROOT}/Manifest.lock",
+			);
+			name = "[CP] Check Pods Manifest.lock";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+				"$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n    # print error to STDERR\n    echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n    exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
+			showEnvVarsInLog = 0;
+		};
+		9740EEB61CF901F6004384FC /* Run Script */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Run Script";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build";
+		};
+		D38B08CB85942E5D11545EE3 /* [CP] Embed Pods Frameworks */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist",
+			);
+			name = "[CP] Embed Pods Frameworks";
+			outputFileListPaths = (
+				"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n";
+			showEnvVarsInLog = 0;
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		97C146EA1CF9000F007C117D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */,
+				1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		97C146FA1CF9000F007C117D /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C146FB1CF9000F007C117D /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C147001CF9000F007C117D /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		249021D3217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Profile;
+		};
+		249021D4217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				DEVELOPMENT_TEAM = 7624MWN53C;
+				ENABLE_BITCODE = NO;
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/Flutter",
+				);
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LIBRARY_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/Flutter",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.example;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Profile;
+		};
+		97C147031CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		97C147041CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 9.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		97C147061CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				DEVELOPMENT_TEAM = 7624MWN53C;
+				ENABLE_BITCODE = NO;
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/Flutter",
+				);
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LIBRARY_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/Flutter",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.example;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Debug;
+		};
+		97C147071CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				DEVELOPMENT_TEAM = 7624MWN53C;
+				ENABLE_BITCODE = NO;
+				FRAMEWORK_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/Flutter",
+				);
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LIBRARY_SEARCH_PATHS = (
+					"$(inherited)",
+					"$(PROJECT_DIR)/Flutter",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.example;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147031CF9000F007C117D /* Debug */,
+				97C147041CF9000F007C117D /* Release */,
+				249021D3217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147061CF9000F007C117D /* Debug */,
+				97C147071CF9000F007C117D /* Release */,
+				249021D4217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 97C146E61CF9000F007C117D /* Project object */;
+}

example/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata

+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>

example/ios/Runner.xcworkspace/contents.xcworkspacedata

+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:Runner.xcodeproj">
+   </FileRef>
+   <FileRef
+      location = "group:Pods/Pods.xcodeproj">
+   </FileRef>
+</Workspace>

example/ios/Runner/AppDelegate.swift

+import UIKit
+import Flutter
+
+@UIApplicationMain
+@objc class AppDelegate: FlutterAppDelegate {
+  override func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+  ) -> Bool {
+    GeneratedPluginRegistrant.register(with: self)
+    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
+  }
+}

example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json

+{
+  "images" : [
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-20x20@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-20x20@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-29x29@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-29x29@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-29x29@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-40x40@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-40x40@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-60x60@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "Icon-App-60x60@3x.png",
+      "scale" : "3x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-20x20@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-20x20@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-29x29@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-29x29@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-40x40@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-40x40@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-76x76@1x.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-76x76@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "83.5x83.5",
+      "idiom" : "ipad",
+      "filename" : "Icon-App-83.5x83.5@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "size" : "1024x1024",
+      "idiom" : "ios-marketing",
+      "filename" : "Icon-App-1024x1024@1x.png",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

example/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json

+{
+  "images" : [
+    {
+      "idiom" : "universal",
+      "filename" : "LaunchImage.png",
+      "scale" : "1x"
+    },
+    {
+      "idiom" : "universal",
+      "filename" : "LaunchImage@2x.png",
+      "scale" : "2x"
+    },
+    {
+      "idiom" : "universal",
+      "filename" : "LaunchImage@3x.png",
+      "scale" : "3x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}

example/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md

+# Launch Screen Assets
+
+You can customize the launch screen with your own desired assets by replacing the image files in this directory.
+
+You can also do it by opening your Flutter project's Xcode project with `open ios/Runner.xcworkspace`, selecting `Runner/Assets.xcassets` in the Project Navigator and dropping in the desired images.
\ No newline at end of file

example/ios/Runner/Base.lproj/LaunchScreen.storyboard

+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="12121" systemVersion="16G29" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="12089"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <layoutGuides>
+                        <viewControllerLayoutGuide type="top" id="Ydg-fD-yQy"/>
+                        <viewControllerLayoutGuide type="bottom" id="xbc-2k-c8Z"/>
+                    </layoutGuides>
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <imageView opaque="NO" clipsSubviews="YES" multipleTouchEnabled="YES" contentMode="center" image="LaunchImage" translatesAutoresizingMaskIntoConstraints="NO" id="YRO-k0-Ey4">
+                            </imageView>
+                        </subviews>
+                        <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                        <constraints>
+                            <constraint firstItem="YRO-k0-Ey4" firstAttribute="centerX" secondItem="Ze5-6b-2t3" secondAttribute="centerX" id="1a2-6s-vTC"/>
+                            <constraint firstItem="YRO-k0-Ey4" firstAttribute="centerY" secondItem="Ze5-6b-2t3" secondAttribute="centerY" id="4X2-HB-R7a"/>
+                        </constraints>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+    <resources>
+        <image name="LaunchImage" width="168" height="185"/>
+    </resources>
+</document>

example/ios/Runner/Base.lproj/Main.storyboard

+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="10117" systemVersion="15F34" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" initialViewController="BYZ-38-t0r">
+    <dependencies>
+        <deployment identifier="iOS"/>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="10085"/>
+    </dependencies>
+    <scenes>
+        <!--Flutter View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="FlutterViewController" sceneMemberID="viewController">
+                    <layoutGuides>
+                        <viewControllerLayoutGuide type="top" id="y3c-jy-aDJ"/>
+                        <viewControllerLayoutGuide type="bottom" id="wfy-db-euE"/>
+                    </layoutGuides>
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="600" height="600"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+        </scene>
+    </scenes>
+</document>

example/ios/Runner/Info.plist

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>example</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(FLUTTER_BUILD_NAME)</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string>$(FLUTTER_BUILD_NUMBER)</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIMainStoryboardFile</key>
+	<string>Main</string>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UIViewControllerBasedStatusBarAppearance</key>
+	<false/>
+
+	<!-- Permission options for the `location` group -->
+    <key>NSLocationWhenInUseUsageDescription</key>
+    <string>Need location when in use</string>
+    <key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
+    <string>Always and when in use!</string>
+    <key>NSLocationUsageDescription</key>
+    <string>Older devices need location.</string>
+    <key>NSLocationAlwaysUsageDescription</key>
+    <string>Can I have location always?</string>
+
+    <!-- Permission options for the `mediaLibrary` group -->
+    <key>NSAppleMusicUsageDescription</key>
+    <string>Music!</string>
+    <key>kTCCServiceMediaLibrary</key>
+    <string>media</string>
+
+    <!-- Permission options for the `calendar` group -->
+    <key>NSCalendarsUsageDescription</key>
+    <string>Calendars</string>
+
+    <!-- Permission options for the `camera` group -->
+    <key>NSCameraUsageDescription</key>
+    <string>camera</string>
+
+    <!-- Permission options for the `contacts` group -->
+    <key>NSContactsUsageDescription</key>
+    <string>contacts</string>
+
+    <!-- Permission options for the `microphone` group -->
+    <key>NSMicrophoneUsageDescription</key>
+    <string>microphone</string>
+
+    <!-- Permission options for the `speech` group -->
+    <key>NSSpeechRecognitionUsageDescription</key>
+    <string>speech</string>
+
+    <!-- Permission options for the `sensors` group -->
+    <key>NSMotionUsageDescription</key>
+    <string>motion</string>
+
+    <!-- Permission options for the `photos` group -->
+    <key>NSPhotoLibraryUsageDescription</key>
+    <string>photos</string>
+
+    <!-- Permission options for the `reminder` group -->
+    <key>NSRemindersUsageDescription</key>
+    <string>reminders</string>
+
+    <!-- Permission options for the `bluetooth` -->
+    <key>NSBluetoothAlwaysUsageDescription</key>
+    <string>bluetooth</string>
+    <key>NSBluetoothPeripheralUsageDescription</key>
+    <string>bluetooth</string>
+
+    <!-- Permission options for the `appTrackingTransparency` -->
+    <key>NSUserTrackingUsageDescription</key>
+    <string>appTrackingTransparency</string>
+</dict>
+</plist>

example/ios/Runner/Runner-Bridging-Header.h

+#import "GeneratedPluginRegistrant.h"

example/lib/main.dart

+import 'dart:io';
+
+import 'package:baseflow_plugin_template/baseflow_plugin_template.dart';
+import 'package:flutter/material.dart';
+import 'package:permission_handler/permission_handler.dart';
+
+void main() {
+  runApp(BaseflowPluginExample(
+      pluginName: 'Permission Handler',
+      githubURL: 'https://github.com/Baseflow/flutter-permission-handler',
+      pubDevURL: 'https://pub.dev/packages/permission_handler',
+      pages: [PermissionHandlerWidget.createPage()]));
+}
+
+///Defines the main theme color
+final MaterialColor themeMaterialColor =
+    BaseflowPluginExample.createMaterialColor(
+        const Color.fromRGBO(48, 49, 60, 1));
+
+/// A Flutter application demonstrating the functionality of this plugin
+class PermissionHandlerWidget extends StatefulWidget {
+  /// Create a page containing the functionality of this plugin
+  static ExamplePage createPage() {
+    return ExamplePage(
+        Icons.location_on, (context) => PermissionHandlerWidget());
+  }
+
+  @override
+  _PermissionHandlerWidgetState createState() =>
+      _PermissionHandlerWidgetState();
+}
+
+class _PermissionHandlerWidgetState extends State<PermissionHandlerWidget> {
+  @override
+  Widget build(BuildContext context) {
+    return Center(
+      child: ListView(
+          children: Permission.values
+              .where((permission) {
+                if (Platform.isIOS) {
+                  return permission != Permission.unknown &&
+                      permission != Permission.sms &&
+                      permission != Permission.storage &&
+                      permission != Permission.ignoreBatteryOptimizations &&
+                      permission != Permission.accessMediaLocation &&
+                      permission != Permission.activityRecognition &&
+                      permission != Permission.manageExternalStorage &&
+                      permission != Permission.systemAlertWindow &&
+                      permission != Permission.requestInstallPackages &&
+                      permission != Permission.accessNotificationPolicy &&
+                      permission != Permission.bluetoothScan &&
+                      permission != Permission.bluetoothAdvertise &&
+                      permission != Permission.bluetoothConnect;
+                } else {
+                  return permission != Permission.unknown &&
+                      permission != Permission.mediaLibrary &&
+                      permission != Permission.photos &&
+                      permission != Permission.photosAddOnly &&
+                      permission != Permission.reminders &&
+                      permission != Permission.appTrackingTransparency &&
+                      permission != Permission.criticalAlerts;
+                }
+              })
+              .map((permission) => PermissionWidget(permission))
+              .toList()),
+    );
+  }
+}
+
+/// Permission widget containing information about the passed [Permission]
+class PermissionWidget extends StatefulWidget {
+  /// Constructs a [PermissionWidget] for the supplied [Permission]
+  const PermissionWidget(this._permission);
+
+  final Permission _permission;
+
+  @override
+  _PermissionState createState() => _PermissionState(_permission);
+}
+
+class _PermissionState extends State<PermissionWidget> {
+  _PermissionState(this._permission);
+
+  final Permission _permission;
+  PermissionStatus _permissionStatus = PermissionStatus.denied;
+
+  @override
+  void initState() {
+    super.initState();
+
+    _listenForPermissionStatus();
+  }
+
+  void _listenForPermissionStatus() async {
+    final status = await _permission.status;
+    setState(() => _permissionStatus = status);
+  }
+
+  Color getPermissionColor() {
+    switch (_permissionStatus) {
+      case PermissionStatus.denied:
+        return Colors.red;
+      case PermissionStatus.granted:
+        return Colors.green;
+      case PermissionStatus.limited:
+        return Colors.orange;
+      default:
+        return Colors.grey;
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return ListTile(
+      title: Text(
+        _permission.toString(),
+        style: Theme.of(context).textTheme.bodyText1,
+      ),
+      subtitle: Text(
+        _permissionStatus.toString(),
+        style: TextStyle(color: getPermissionColor()),
+      ),
+      trailing: (_permission is PermissionWithService)
+          ? IconButton(
+              icon: const Icon(
+                Icons.info,
+                color: Colors.white,
+              ),
+              onPressed: () {
+                checkServiceStatus(
+                    context, _permission as PermissionWithService);
+              })
+          : null,
+      onTap: () {
+        requestPermission(_permission);
+      },
+    );
+  }
+
+  void checkServiceStatus(
+      BuildContext context, PermissionWithService permission) async {
+    ScaffoldMessenger.of(context).showSnackBar(SnackBar(
+      content: Text((await permission.serviceStatus).toString()),
+    ));
+  }
+
+  Future<void> requestPermission(Permission permission) async {
+    final status = await permission.request();
+
+    setState(() {
+      print(status);
+      _permissionStatus = status;
+      print(_permissionStatus);
+    });
+  }
+}

example/pubspec.yaml

+name: permission_handler_example
+description: Demonstrates how to use the permission_handler plugin.
+
+environment:
+  sdk: ">=2.12.0-259.9.beta <3.0.0"
+
+dependencies:
+  baseflow_plugin_template:
+    git:
+      url: git://github.com/Baseflow/baseflow_plugin_template.git
+      ref: v2.0.0-nullsafety
+  flutter:
+    sdk: flutter
+
+dev_dependencies:
+  flutter_test:
+    sdk: flutter
+
+  permission_handler:
+    path: ../
+
+  url_launcher: ^6.0.12
+
+flutter:
+  uses-material-design: true
+
+  assets:
+    - res/images/baseflow_logo_def_light-02.png
+    - res/images/poweredByBaseflowLogoLight@3x.png
+    - packages/baseflow_plugin_template/logo.png
+    - packages/baseflow_plugin_template/poweredByBaseflow.png
+

ios/Classes/PermissionHandlerEnums.h

+//
+//  PermissionHandlerEnums.h
+//  permission_handler
+//
+//  Created by Razvan Lung on 15/02/2019.
+//
+
+// ios: PermissionGroupCalendar
+// Info.plist: NSCalendarsUsageDescription
+// dart: PermissionGroup.calendar
+#ifndef PERMISSION_EVENTS
+    #define PERMISSION_EVENTS 0
+#endif
+
+// ios: PermissionGroupReminders
+// Info.plist: NSRemindersUsageDescription
+// dart: PermissionGroup.reminders
+#ifndef PERMISSION_REMINDERS
+    #define PERMISSION_REMINDERS 0
+#endif
+
+// ios: PermissionGroupContacts
+// Info.plist: NSContactsUsageDescription
+// dart: PermissionGroup.contacts
+#ifndef PERMISSION_CONTACTS
+    #define PERMISSION_CONTACTS 0
+#endif
+
+// ios: PermissionGroupCamera
+// Info.plist: NSCameraUsageDescription
+// dart: PermissionGroup.camera
+#ifndef PERMISSION_CAMERA
+    #define PERMISSION_CAMERA 0
+#endif
+
+// ios: PermissionGroupMicrophone
+// Info.plist: NSMicrophoneUsageDescription
+// dart: PermissionGroup.microphone
+#ifndef PERMISSION_MICROPHONE
+    #define PERMISSION_MICROPHONE 0
+#endif
+
+// ios: PermissionGroupSpeech
+// Info.plist: NSSpeechRecognitionUsageDescription
+// dart: PermissionGroup.speech
+#ifndef PERMISSION_SPEECH_RECOGNIZER
+    #define PERMISSION_SPEECH_RECOGNIZER 0
+#endif
+
+// ios: PermissionGroupPhotos
+// Info.plist: NSPhotoLibraryUsageDescription
+// dart: PermissionGroup.photos
+#ifndef PERMISSION_PHOTOS
+    #define PERMISSION_PHOTOS 0
+#endif
+
+// ios: PermissionGroupPhotosAddOnly
+// Info.plist: NSPhotoLibraryUsageDescription
+// dart: PermissionGroup.photosAddOnly
+#ifndef PERMISSION_PHOTOS_ADD_ONLY
+    #define PERMISSION_PHOTOS_ADD_ONLY 0
+#endif
+
+// ios: [PermissionGroupLocation, PermissionGroupLocationAlways, PermissionGroupLocationWhenInUse]
+// Info.plist: [NSLocationUsageDescription, NSLocationAlwaysAndWhenInUseUsageDescription, NSLocationWhenInUseUsageDescription]
+// dart: [PermissionGroup.location, PermissionGroup.locationAlways, PermissionGroup.locationWhenInUse]
+#ifndef PERMISSION_LOCATION
+    #define PERMISSION_LOCATION 0
+#endif
+
+// ios: PermissionGroupNotification
+// dart: PermissionGroup.notification
+#ifndef PERMISSION_NOTIFICATIONS
+    #define PERMISSION_NOTIFICATIONS 0
+#endif
+
+// ios: PermissionGroupMediaLibrary
+// Info.plist: [NSAppleMusicUsageDescription, kTCCServiceMediaLibrary]
+// dart: PermissionGroup.mediaLibrary
+#ifndef PERMISSION_MEDIA_LIBRARY
+    #define PERMISSION_MEDIA_LIBRARY 0
+#endif
+
+// ios: PermissionGroupSensors
+// Info.plist: NSMotionUsageDescription
+// dart: PermissionGroup.sensors
+#ifndef PERMISSION_SENSORS
+    #define PERMISSION_SENSORS 0
+#endif
+
+// ios: PermissionGroupBluetooth
+// Info.plist: [NSBluetoothAlwaysUsageDescription, NSBluetoothPeripheralUsageDescription]
+// dart: PermissionGroup.bluetooth
+#ifndef PERMISSION_BLUETOOTH
+    #define PERMISSION_BLUETOOTH 0
+#endif
+
+// ios: PermissionGroupAppTrackingTransparency
+// Info.plist: [NSUserTrackingUsageDescription]
+// dart: PermissionGroup.appTrackingTransparency
+#ifndef PERMISSION_APP_TRACKING_TRANSPARENCY
+    #define PERMISSION_APP_TRACKING_TRANSPARENCY 0
+#endif
+
+
+// ios: PermissionGroupCriticalAlerts
+// Info.plist: UNAuthorizationOptionCriticalAlert
+// dart: PermissionGroup.criticalAlerts
+#ifndef PERMISSION_CRITICAL_ALERTS
+    #define PERMISSION_CRITICAL_ALERTS 0
+#endif
+
+typedef NS_ENUM(int, PermissionGroup) {
+    PermissionGroupCalendar = 0,
+    PermissionGroupCamera,
+    PermissionGroupContacts,
+    PermissionGroupLocation,
+    PermissionGroupLocationAlways,
+    PermissionGroupLocationWhenInUse,
+    PermissionGroupMediaLibrary,
+    PermissionGroupMicrophone,
+    PermissionGroupPhone,
+    PermissionGroupPhotos,
+    PermissionGroupPhotosAddOnly,
+    PermissionGroupReminders,
+    PermissionGroupSensors,
+    PermissionGroupSms,
+    PermissionGroupSpeech,
+    PermissionGroupStorage,
+    PermissionGroupIgnoreBatteryOptimizations,
+    PermissionGroupNotification,
+    PermissionGroupAccessMediaLocation,
+    PermissionGroupActivityRecognition,
+    PermissionGroupUnknown,
+    PermissionGroupBluetooth,
+    PermissionGroupManageExternalStorage,
+    PermissionGroupSystemAlertWindow,
+    PermissionGroupRequestInstallPackages,
+    PermissionGroupAppTrackingTransparency,
+    PermissionGroupCriticalAlerts,
+    PermissionGroupAccessNotificationPolicy,
+    PermissionGroupBluetoothScan,
+    PermissionGroupBluetoothAdvertise,
+    PermissionGroupBluetoothConnect,
+};
+
+typedef NS_ENUM(int, PermissionStatus) {
+    PermissionStatusDenied = 0,
+    PermissionStatusGranted = 1,
+    PermissionStatusRestricted = 2,
+    PermissionStatusLimited = 3,
+    PermissionStatusPermanentlyDenied = 4
+};
+
+typedef NS_ENUM(int, ServiceStatus) {
+    ServiceStatusDisabled = 0,
+    ServiceStatusEnabled,
+    ServiceStatusNotApplicable,
+};

ios/Classes/PermissionHandlerPlugin.h

+#import <Flutter/Flutter.h>
+#import "PermissionManager.h"
+
+@interface PermissionHandlerPlugin : NSObject<FlutterPlugin>
+- (instancetype)initWithPermissionManager:(PermissionManager *)permissionManager;
+@end

ios/Classes/PermissionHandlerPlugin.m

+#import "PermissionHandlerPlugin.h"
+
+
+@implementation PermissionHandlerPlugin {
+    PermissionManager *_Nonnull _permissionManager;
+    _Nullable FlutterResult _methodResult;
+}
+
+- (instancetype)initWithPermissionManager:(PermissionManager *)permissionManager {
+    self = [super init];
+    if (self) {
+        _permissionManager = permissionManager;
+    }
+    
+    return self;
+}
+
++ (void)registerWithRegistrar:(NSObject <FlutterPluginRegistrar> *)registrar {
+    FlutterMethodChannel *channel = [FlutterMethodChannel
+                                     methodChannelWithName:@"flutter.baseflow.com/permissions/methods"
+                                     binaryMessenger:[registrar messenger]];
+    PermissionManager *permissionManager = [[PermissionManager alloc] initWithStrategyInstances];
+    PermissionHandlerPlugin *instance = [[PermissionHandlerPlugin alloc] initWithPermissionManager:permissionManager];
+    [registrar addMethodCallDelegate:instance channel:channel];
+}
+
+- (void)handleMethodCall:(FlutterMethodCall *)call result:(FlutterResult)result {
+    if ([@"checkPermissionStatus" isEqualToString:call.method]) {
+        PermissionGroup permission = [Codec decodePermissionGroupFrom:call.arguments];
+        [PermissionManager checkPermissionStatus:permission result:result];
+    } else if ([@"checkServiceStatus" isEqualToString:call.method]) {
+        PermissionGroup permission = [Codec decodePermissionGroupFrom:call.arguments];
+        [PermissionManager checkServiceStatus:permission result:result];
+    } else if ([@"requestPermissions" isEqualToString:call.method]) {
+        if (_methodResult != nil) {
+            result([FlutterError errorWithCode:@"ERROR_ALREADY_REQUESTING_PERMISSIONS" message:@"A request for permissions is already running, please wait for it to finish before doing another request (note that you can request multiple permissions at the same time)." details:nil]);
+        }
+        
+        _methodResult = result;
+        NSArray *permissions = [Codec decodePermissionGroupsFrom:call.arguments];
+        
+        [_permissionManager
+         requestPermissions:permissions completion:^(NSDictionary *permissionRequestResults) {
+             if (self->_methodResult != nil) {
+                 self->_methodResult(permissionRequestResults);
+             }
+             
+             self->_methodResult = nil;
+         }];
+        
+    } else if ([@"shouldShowRequestPermissionRationale" isEqualToString:call.method]) {
+        result(@false);
+    } else if ([@"openAppSettings" isEqualToString:call.method]) {
+        [PermissionManager openAppSettings:result];
+    } else {
+        result(FlutterMethodNotImplemented);
+    }
+}
+
+@end

ios/Classes/PermissionManager.h

+//
+//  PermissionManager.h
+//  permission_handler
+//
+//  Created by Razvan Lung on 15/02/2019.
+//
+
+#import <Flutter/Flutter.h>
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+
+#import "AudioVideoPermissionStrategy.h"
+#import "AppTrackingTransparencyPermissionStrategy.h"
+#import "BluetoothPermissionStrategy.h"
+#import "ContactPermissionStrategy.h"
+#import "EventPermissionStrategy.h"
+#import "LocationPermissionStrategy.h"
+#import "MediaLibraryPermissionStrategy.h"
+#import "PermissionStrategy.h"
+#import "PhonePermissionStrategy.h"
+#import "PhotoPermissionStrategy.h"
+#import "SensorPermissionStrategy.h"
+#import "SpeechPermissionStrategy.h"
+#import "StoragePermissionStrategy.h"
+#import "UnknownPermissionStrategy.h"
+#import "NotificationPermissionStrategy.h"
+#import "CriticalAlertsPermissionStrategy.h"
+#import "PermissionHandlerEnums.h"
+#import "Codec.h"
+
+typedef void (^PermissionRequestCompletion)(NSDictionary *permissionRequestResults);
+
+@interface PermissionManager : NSObject
+
+- (instancetype)initWithStrategyInstances;
+- (void)requestPermissions:(NSArray *)permissions completion:(PermissionRequestCompletion)completion;
+
++ (void)checkPermissionStatus:(enum PermissionGroup)permission result:(FlutterResult)result;
++ (void)checkServiceStatus:(enum PermissionGroup)permission result:(FlutterResult)result;
++ (void)openAppSettings:(FlutterResult)result;
+
+@end

ios/Classes/PermissionManager.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "PermissionManager.h"
+
+@implementation PermissionManager {
+    NSMutableArray <id <PermissionStrategy>> *_strategyInstances;
+}
+
+- (instancetype)initWithStrategyInstances {
+    self = [super init];
+    if (self) {
+        _strategyInstances = _strategyInstances = [[NSMutableArray alloc] init];
+    }
+    
+    return self;
+}
+
++ (void)checkPermissionStatus:(enum PermissionGroup)permission result:(FlutterResult)result {
+    id <PermissionStrategy> permissionStrategy = [PermissionManager createPermissionStrategy:permission];
+    PermissionStatus status = [permissionStrategy checkPermissionStatus:permission];
+    
+    result([Codec encodePermissionStatus:status]);
+}
+
++ (void)checkServiceStatus:(enum PermissionGroup)permission result:(FlutterResult)result {
+    id <PermissionStrategy> permissionStrategy = [PermissionManager createPermissionStrategy:permission];
+    ServiceStatus status = [permissionStrategy checkServiceStatus:permission];
+    result([Codec encodeServiceStatus:status]);
+}
+
+- (void)requestPermissions:(NSArray *)permissions completion:(PermissionRequestCompletion)completion {
+    NSMutableDictionary *permissionStatusResult = [[NSMutableDictionary alloc] init];
+
+    if (permissions.count == 0) {
+        completion(permissionStatusResult);
+        return;
+    }
+    
+    NSMutableSet *requestQueue = [[NSMutableSet alloc] initWithArray:permissions];
+        
+    for (int i = 0; i < permissions.count; ++i) {
+        NSNumber *rawNumberValue = permissions[i];
+        int rawValue = rawNumberValue.intValue;
+        PermissionGroup permission = (PermissionGroup) rawValue;
+        
+        __block id <PermissionStrategy> permissionStrategy = [PermissionManager createPermissionStrategy:permission];
+        [_strategyInstances addObject:permissionStrategy];
+        
+        
+        [permissionStrategy requestPermission:permission completionHandler:^(PermissionStatus permissionStatus) {
+            permissionStatusResult[@(permission)] = @(permissionStatus);
+            [requestQueue removeObject:@(permission)];
+            
+            [self->_strategyInstances removeObject:permissionStrategy];
+            
+            if (requestQueue.count == 0) {
+                completion(permissionStatusResult);
+            }
+          
+            // Make sure `completion` is called before cleaning up the reference
+            // otherwise the `completion` block is also dereferenced on iOS 12 and
+            // below (this is most likely a bug in Objective-C which is solved in
+            // later versions of the runtime).
+            permissionStrategy = nil;
+        }];
+    }
+}
+
++ (void)openAppSettings:(FlutterResult)result {
+    if (@available(iOS 10, *)) {
+        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]
+                                           options:[[NSDictionary alloc] init]
+                                 completionHandler:^(BOOL success) {
+                                     result([[NSNumber alloc] initWithBool:success]);
+                                 }];
+    } else if (@available(iOS 8.0, *)) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        BOOL success = [[UIApplication sharedApplication] openURL:[NSURL URLWithString:UIApplicationOpenSettingsURLString]];
+        result([[NSNumber alloc] initWithBool:success]);
+#pragma clang diagnostic pop
+    } else {
+        result(@false);    
+    }
+}
+
++ (id)createPermissionStrategy:(PermissionGroup)permission {
+    switch (permission) {
+        case PermissionGroupCalendar:
+            return [EventPermissionStrategy new];
+        case PermissionGroupCamera:
+            return [AudioVideoPermissionStrategy new];
+        case PermissionGroupContacts:
+            return [ContactPermissionStrategy new];
+        case PermissionGroupLocation:
+        case PermissionGroupLocationAlways:
+        case PermissionGroupLocationWhenInUse:
+            #if PERMISSION_LOCATION
+            return [[LocationPermissionStrategy alloc] initWithLocationManager];
+            #else
+            return [LocationPermissionStrategy new];
+            #endif
+        case PermissionGroupMediaLibrary:
+            return [MediaLibraryPermissionStrategy new];
+        case PermissionGroupMicrophone:
+            return [AudioVideoPermissionStrategy new];
+        case PermissionGroupPhone:
+            return [PhonePermissionStrategy new];
+        case PermissionGroupPhotos:
+            #if PERMISSION_PHOTOS
+            return [[PhotoPermissionStrategy alloc] initWithAccessAddOnly:false];
+            #else
+            return [PhotoPermissionStrategy new];
+            #endif
+        case PermissionGroupPhotosAddOnly:
+            #if PERMISSION_PHOTOS
+            return [[PhotoPermissionStrategy alloc] initWithAccessAddOnly:true];
+            #else
+            return [PhotoPermissionStrategy new];
+            #endif
+        case PermissionGroupReminders:
+            return [EventPermissionStrategy new];
+        case PermissionGroupSensors:
+            return [SensorPermissionStrategy new];
+        case PermissionGroupSpeech:
+            return [SpeechPermissionStrategy new];
+        case PermissionGroupNotification:
+            return [NotificationPermissionStrategy new];
+        case PermissionGroupStorage:
+            return [StoragePermissionStrategy new];
+        case PermissionGroupBluetooth:
+            #if PERMISSION_BLUETOOTH
+            return [[BluetoothPermissionStrategy alloc] initWithBluetoothManager];
+            #else
+            return [BluetoothPermissionStrategy new];
+            #endif
+        case PermissionGroupAppTrackingTransparency:
+            return [AppTrackingTransparencyPermissionStrategy new];
+        case PermissionGroupCriticalAlerts:
+            return [CriticalAlertsPermissionStrategy new];
+        default:
+            return [UnknownPermissionStrategy new];
+    }
+}
+
+@end

ios/Classes/strategies/AppTrackingTransparencyPermissionStrategy.h

+//
+//  AppTrackingTransparency.h
+//  permission_handler
+//
+//  Created by Jan-Derk on 21/05/2021.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_APP_TRACKING_TRANSPARENCY
+
+#import <AppTrackingTransparency/AppTrackingTransparency.h>
+
+@interface AppTrackingTransparencyPermissionStrategy : NSObject <PermissionStrategy>
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+
+@interface AppTrackingTransparencyPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/AppTrackingTransparencyPermissionStrategy.m

+//
+//  AppTrackingTransparency.m
+//  permission_handler
+//
+//  Created by Jan-Derk on 21/05/2021.
+//
+
+#import "AppTrackingTransparencyPermissionStrategy.h"
+
+#if PERMISSION_APP_TRACKING_TRANSPARENCY
+
+@implementation AppTrackingTransparencyPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    if (@available(iOS 14, *)) {
+        ATTrackingManagerAuthorizationStatus attPermission = [ATTrackingManager trackingAuthorizationStatus];
+        return [AppTrackingTransparencyPermissionStrategy parsePermission:attPermission];
+    }
+    
+    return PermissionStatusGranted;
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+    
+    if (@available(iOS 14, *)){
+        [ATTrackingManager requestTrackingAuthorizationWithCompletionHandler:^(ATTrackingManagerAuthorizationStatus status) {
+            PermissionStatus permissionStatus = [AppTrackingTransparencyPermissionStrategy parsePermission:status];
+            completionHandler(permissionStatus);
+        }];
+    } else {
+        completionHandler(PermissionStatusGranted);
+    }
+}
+
++ (PermissionStatus)parsePermission:(ATTrackingManagerAuthorizationStatus)attPermission API_AVAILABLE(ios(14)){
+    switch(attPermission){
+        case ATTrackingManagerAuthorizationStatusAuthorized:
+            return PermissionStatusGranted;
+        case ATTrackingManagerAuthorizationStatusRestricted:
+            return PermissionStatusRestricted;
+        case ATTrackingManagerAuthorizationStatusDenied:
+            return PermissionStatusPermanentlyDenied;
+        case ATTrackingManagerAuthorizationStatusNotDetermined:
+            return PermissionStatusDenied;
+    }
+}
+@end
+
+#else
+
+@implementation AppTrackingTransparencyPermissionStrategy
+@end
+
+#endif
+

ios/Classes/strategies/AudioVideoPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_CAMERA | PERMISSION_MICROPHONE
+#import <AVFoundation/AVFoundation.h>
+
+@interface AudioVideoPermissionStrategy : NSObject <PermissionStrategy>
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface AudioVideoPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/AudioVideoPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "AudioVideoPermissionStrategy.h"
+
+#if PERMISSION_CAMERA | PERMISSION_MICROPHONE
+
+@implementation AudioVideoPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    if (permission == PermissionGroupCamera) {
+        #if PERMISSION_CAMERA
+        return [AudioVideoPermissionStrategy permissionStatus:AVMediaTypeVideo];
+        #endif
+    } else if (permission == PermissionGroupMicrophone) {
+        #if PERMISSION_MICROPHONE
+        return [AudioVideoPermissionStrategy permissionStatus:AVMediaTypeAudio];
+        #endif
+    }
+    return PermissionStatusDenied;
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+
+    AVMediaType mediaType;
+
+    if (permission == PermissionGroupCamera) {
+        #if PERMISSION_CAMERA
+        mediaType = AVMediaTypeVideo;
+        #else
+        completionHandler(PermissionStatusDenied);
+        return;
+        #endif
+    } else if (permission == PermissionGroupMicrophone) {
+        #if PERMISSION_MICROPHONE
+        mediaType = AVMediaTypeAudio;
+        #else
+        completionHandler(PermissionStatusDenied);
+        return;
+        #endif
+    } else {
+        completionHandler(PermissionStatusDenied);
+        return;
+    }
+
+    [AVCaptureDevice requestAccessForMediaType:mediaType completionHandler:^(BOOL granted) {
+        if (granted) {
+            completionHandler(PermissionStatusGranted);
+        } else {
+            completionHandler(PermissionStatusPermanentlyDenied);
+        }
+    }];
+}
+
++ (PermissionStatus)permissionStatus:(AVMediaType const)mediaType {
+    AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:mediaType];
+
+    switch (status) {
+        case AVAuthorizationStatusNotDetermined:
+            return PermissionStatusDenied;
+        case AVAuthorizationStatusRestricted:
+            return PermissionStatusRestricted;
+        case AVAuthorizationStatusDenied:
+            return PermissionStatusPermanentlyDenied;
+        case AVAuthorizationStatusAuthorized:
+            return PermissionStatusGranted;
+    }
+
+    return PermissionStatusDenied;
+}
+
+@end
+
+#else
+
+@implementation AudioVideoPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/BluetoothPermissionStrategy.h

+//
+//  BluetoothPermissionStrategy.h
+//  permission_handler
+//
+//  Created by Rene Floor on 12/03/2021.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_BLUETOOTH
+
+#import <CoreBluetooth/CoreBluetooth.h>
+
+@interface BluetoothPermissionStrategy : NSObject <PermissionStrategy, CBCentralManagerDelegate>
+-(instancetype)initWithBluetoothManager;
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+
+@interface BluetoothPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/BluetoothPermissionStrategy.m

+//
+//  BluetoothPermissionStrategy.m
+//  permission_handler
+//
+//  Created by Rene Floor on 12/03/2021.
+//
+
+#import "BluetoothPermissionStrategy.h"
+
+#if PERMISSION_BLUETOOTH
+
+@implementation BluetoothPermissionStrategy {
+    CBCentralManager *_centralManager;
+    PermissionStatusHandler _permissionStatusHandler;
+    PermissionGroup _requestedPermission;
+}
+
+- (instancetype)initWithBluetoothManager {
+    self = [super init];
+    if (self) {
+        _centralManager = [[CBCentralManager alloc] initWithDelegate:self queue:nil];
+    }
+    
+    return self;
+}
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    if (@available(iOS 13.1, *)) {
+        CBManagerAuthorization blePermission = [_centralManager authorization];
+        return [BluetoothPermissionStrategy parsePermission:blePermission];
+    } else if (@available(iOS 13.0, *)){
+        CBManagerAuthorization blePermission =  [_centralManager authorization];
+        return [BluetoothPermissionStrategy parsePermission:blePermission];
+    }
+    return PermissionStatusGranted;
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    if (@available(iOS 10, *)) {
+        return [_centralManager state] == CBManagerStatePoweredOn ? ServiceStatusEnabled : ServiceStatusDisabled;
+    }
+    return [_centralManager state] == CBCentralManagerStatePoweredOn ? ServiceStatusEnabled : ServiceStatusDisabled;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+    
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+    
+    _permissionStatusHandler = completionHandler;
+    _requestedPermission = permission;
+}
+
++ (PermissionStatus)parsePermission:(CBManagerAuthorization)bluetoothPermission API_AVAILABLE(ios(13)){
+    switch(bluetoothPermission){
+        case CBManagerAuthorizationNotDetermined:
+            return PermissionStatusDenied;
+        case CBManagerAuthorizationRestricted:
+            return PermissionStatusRestricted;
+        case CBManagerAuthorizationDenied:
+            return PermissionStatusPermanentlyDenied;
+        case CBManagerAuthorizationAllowedAlways:
+            return PermissionStatusGranted;
+    }
+}
+
+- (void)centralManagerDidUpdateState:(nonnull CBCentralManager *)centralManager {
+    PermissionStatus permissionStatus = [self checkPermissionStatus:_requestedPermission];
+    _permissionStatusHandler(permissionStatus);
+}
+
+@end
+
+#else
+
+@implementation BluetoothPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/ContactPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_CONTACTS
+
+#import <AddressBook/ABAddressBook.h>
+#import <Contacts/Contacts.h>
+
+@interface ContactPermissionStrategy : NSObject <PermissionStrategy>
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface ContactPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/ContactPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "ContactPermissionStrategy.h"
+
+#if PERMISSION_CONTACTS
+
+@implementation ContactPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return [ContactPermissionStrategy permissionStatus];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+
+    if (@available(iOS 9.0, *)) {
+        [ContactPermissionStrategy requestPermissionsFromContactStore:completionHandler];
+    } else {
+        [ContactPermissionStrategy requestPermissionsFromAddressBook:completionHandler];
+    }
+}
+
++ (PermissionStatus)permissionStatus {
+    if (@available(iOS 9.0, *)) {
+        CNAuthorizationStatus status = [CNContactStore authorizationStatusForEntityType:CNEntityTypeContacts];
+
+        switch (status) {
+            case CNAuthorizationStatusNotDetermined:
+                return PermissionStatusDenied;
+            case CNAuthorizationStatusRestricted:
+                return PermissionStatusRestricted;
+            case CNAuthorizationStatusDenied:
+                return PermissionStatusPermanentlyDenied;
+            case CNAuthorizationStatusAuthorized:
+                return PermissionStatusGranted;
+        }
+
+    } else {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        ABAuthorizationStatus status = ABAddressBookGetAuthorizationStatus();
+
+        switch (status) {
+            case kABAuthorizationStatusNotDetermined:
+                return PermissionStatusDenied;
+            case kABAuthorizationStatusRestricted:
+                return PermissionStatusRestricted;
+            case kABAuthorizationStatusDenied:
+                return PermissionStatusPermanentlyDenied;
+            case kABAuthorizationStatusAuthorized:
+                return PermissionStatusGranted;
+#pragma clang diagnostic pop
+        }
+    }
+
+    return PermissionStatusDenied;
+}
+
++ (void)requestPermissionsFromContactStore:(PermissionStatusHandler)completionHandler API_AVAILABLE(ios(9)) {
+    CNContactStore *contactStore = [CNContactStore new];
+
+    [contactStore requestAccessForEntityType:CNEntityTypeContacts completionHandler:^(BOOL granted, NSError *__nullable error) {
+        if (granted) {
+            completionHandler(PermissionStatusGranted);
+        } else {
+            completionHandler(PermissionStatusPermanentlyDenied);
+        }
+    }];
+}
+
++ (void)requestPermissionsFromAddressBook:(PermissionStatusHandler)completionHandler {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    ABAddressBookRequestAccessWithCompletion(ABAddressBookCreate(), ^(bool granted, CFErrorRef error) {
+        if (granted) {
+            completionHandler(PermissionStatusGranted);
+        } else {
+            completionHandler(PermissionStatusPermanentlyDenied);
+        }
+    });
+#pragma clang diagnostic pop
+}
+@end
+
+#else
+
+@implementation ContactPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/CriticalAlertsPermissionStrategy.h

+//
+//  CriticalAlertsPermissionStrategy.h
+//  permission_handler
+//
+//  Created by Neal Soni on 2021/6/8.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_CRITICAL_ALERTS
+
+#import <UserNotifications/UserNotifications.h>
+
+@interface CriticalAlertsPermissionStrategy : NSObject <PermissionStrategy>
+
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface CriticalAlertsPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/CriticalAlertsPermissionStrategy.m

+//
+//  CriticalAlertsPermissionStrategy.m
+//  permission_handler
+//
+//  Created by Neal Soni on 2021/6/8.
+//
+
+#import "CriticalAlertsPermissionStrategy.h"
+
+#if PERMISSION_CRITICAL_ALERTS
+
+@implementation CriticalAlertsPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+  return [CriticalAlertsPermissionStrategy permissionStatus];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+  return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+  PermissionStatus status = [self checkPermissionStatus:permission];
+  if (status != PermissionStatusDenied) {
+    completionHandler(status);
+    return;
+  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if(@available(iOS 12.0, *)) {
+      UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+      UNAuthorizationOptions authorizationOptions = 0;
+      authorizationOptions += UNAuthorizationOptionCriticalAlert;
+      [center requestAuthorizationWithOptions:(authorizationOptions) completionHandler:^(BOOL granted, NSError * _Nullable error) {
+        if (error != nil || !granted) {
+          completionHandler(PermissionStatusPermanentlyDenied);
+          return;
+        }
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [[UIApplication sharedApplication] registerForRemoteNotifications];
+            completionHandler(PermissionStatusGranted);
+        });
+      }];
+    } else {
+      completionHandler(PermissionStatusPermanentlyDenied);
+    }
+  });
+}
+
++ (PermissionStatus)permissionStatus {
+  __block PermissionStatus permissionStatus = PermissionStatusGranted;
+  if (@available(iOS 12 , *)) {
+    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+    [[UNUserNotificationCenter currentNotificationCenter] getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
+      if (settings.criticalAlertSetting == UNAuthorizationStatusDenied) {
+        permissionStatus = PermissionStatusPermanentlyDenied;
+      } else if (settings.criticalAlertSetting == UNAuthorizationStatusNotDetermined) {
+        permissionStatus = PermissionStatusDenied;
+      }
+      dispatch_semaphore_signal(sem);
+    }];
+    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+  } else {
+    permissionStatus = PermissionStatusPermanentlyDenied;
+  }
+
+  return permissionStatus;
+}
+
+@end
+
+#else
+
+@implementation CriticalAlertsPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/EventPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_EVENTS | PERMISSION_REMINDERS
+
+#import <EventKit/EventKit.h>
+
+@interface EventPermissionStrategy : NSObject <PermissionStrategy>
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface EventPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/EventPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "EventPermissionStrategy.h"
+
+#if PERMISSION_EVENTS | PERMISSION_REMINDERS
+
+@implementation EventPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    if (permission == PermissionGroupCalendar) {
+        #if PERMISSION_EVENTS
+        return [EventPermissionStrategy permissionStatus:EKEntityTypeEvent];
+        #endif
+    } else if (permission == PermissionGroupReminders) {
+        #if PERMISSION_REMINDERS
+        return [EventPermissionStrategy permissionStatus:EKEntityTypeReminder];
+        #endif
+    }
+    
+    return PermissionStatusDenied;
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus permissionStatus = [self checkPermissionStatus:permission];
+    
+    if (permissionStatus != PermissionStatusDenied) {
+        completionHandler(permissionStatus);
+        return;
+    }
+    
+    EKEntityType entityType;
+    
+    if (permission == PermissionGroupCalendar) {
+        #if PERMISSION_EVENTS
+        entityType = EKEntityTypeEvent;
+        #else
+        completionHandler(PermissionStatusDenied);
+        return;
+        #endif
+    } else if (permission == PermissionGroupReminders) {
+        #if PERMISSION_REMINDERS
+        entityType = EKEntityTypeReminder;
+        #else
+        completionHandler(PermissionStatusDenied);
+        return;
+        #endif
+    } else {
+        completionHandler(PermissionStatusPermanentlyDenied);
+        return;
+    }
+    
+    EKEventStore *eventStore = [[EKEventStore alloc] init];
+    [eventStore requestAccessToEntityType:entityType completion:^(BOOL granted, NSError *error) {
+        if (granted) {
+            completionHandler(PermissionStatusGranted);
+        } else {
+            completionHandler(PermissionStatusPermanentlyDenied);
+        }
+    }];
+}
+
++ (PermissionStatus)permissionStatus:(EKEntityType)entityType {
+    EKAuthorizationStatus status = [EKEventStore authorizationStatusForEntityType:entityType];
+    
+    switch (status) {
+        case EKAuthorizationStatusNotDetermined:
+            return PermissionStatusDenied;
+        case EKAuthorizationStatusRestricted:
+            return PermissionStatusRestricted;
+        case EKAuthorizationStatusDenied:
+            return PermissionStatusPermanentlyDenied;
+        case EKAuthorizationStatusAuthorized:
+            return PermissionStatusGranted;
+    }
+    
+    return PermissionStatusDenied;
+}
+
+@end
+
+#else
+
+@implementation EventPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/LocationPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_LOCATION
+
+#import <CoreLocation/CoreLocation.h>
+
+@interface LocationPermissionStrategy : NSObject <PermissionStrategy, CLLocationManagerDelegate>
+- (instancetype)initWithLocationManager;
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface LocationPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/LocationPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "LocationPermissionStrategy.h"
+
+#if PERMISSION_LOCATION
+
+@implementation LocationPermissionStrategy {
+    CLLocationManager *_locationManager;
+    PermissionStatusHandler _permissionStatusHandler;
+    PermissionGroup _requestedPermission;
+}
+
+- (instancetype)initWithLocationManager {
+    self = [super init];
+    if (self) {
+        _locationManager = [CLLocationManager new];
+        _locationManager.delegate = self;
+    }
+    
+    return self;
+}
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return [LocationPermissionStrategy permissionStatus:permission];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return [CLLocationManager locationServicesEnabled] ? ServiceStatusEnabled : ServiceStatusDisabled;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+    if ([CLLocationManager authorizationStatus] == kCLAuthorizationStatusAuthorizedWhenInUse && permission == PermissionGroupLocationAlways) {
+        // don't do anything and continue requesting permissions
+    } else if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+    
+    _permissionStatusHandler = completionHandler;
+    _requestedPermission = permission;
+    
+    if (permission == PermissionGroupLocation) {
+        if ([[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationAlwaysUsageDescription"] != nil) {
+            [_locationManager requestAlwaysAuthorization];
+        } else if ([[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationWhenInUseUsageDescription"] != nil) {
+            [_locationManager requestWhenInUseAuthorization];
+        } else {
+            [[NSException exceptionWithName:NSInternalInconsistencyException reason:@"To use location in iOS8 you need to define either NSLocationWhenInUseUsageDescription or NSLocationAlwaysUsageDescription in the app bundle's Info.plist file" userInfo:nil] raise];
+        }
+    } else if (permission == PermissionGroupLocationAlways) {
+        if ([[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationAlwaysUsageDescription"] != nil) {
+            [_locationManager requestAlwaysAuthorization];
+        } else {
+            [[NSException exceptionWithName:NSInternalInconsistencyException reason:@"To use location in iOS8 you need to define NSLocationAlwaysUsageDescription in the app bundle's Info.plist file" userInfo:nil] raise];
+        }
+    } else if (permission == PermissionGroupLocationWhenInUse) {
+        if ([[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationWhenInUseUsageDescription"] != nil) {
+            [_locationManager requestWhenInUseAuthorization];
+        } else {
+            [[NSException exceptionWithName:NSInternalInconsistencyException reason:@"To use location in iOS8 you need to define NSLocationWhenInUseUsageDescription in the app bundle's Info.plist file" userInfo:nil] raise];
+        }
+    }
+}
+
+// {WARNING}
+// This is called when the location manager is first initialized and raises the following situations:
+// 1. When we first request [PermissionGroupLocationWhenInUse] and then [PermissionGroupLocationAlways]
+//    this will be called when the [CLLocationManager] is first initialized with
+//    [kCLAuthorizationStatusAuthorizedWhenInUse]. As a consequence we send back the result to early.
+// 2. When we first request [PermissionGroupLocationWhenInUse] and then [PermissionGroupLocationAlways]
+//    and the user doesn't allow for [kCLAuthorizationStatusAuthorizedAlways] this method is not called
+//    at all.
+- (void)locationManager:(CLLocationManager *)manager didChangeAuthorizationStatus:(CLAuthorizationStatus)status {
+    if (status == kCLAuthorizationStatusNotDetermined) {
+        return;
+    }
+    
+    if (_permissionStatusHandler == nil || @(_requestedPermission) == nil) {
+        return;
+    }
+
+    if ((_requestedPermission == PermissionGroupLocationAlways && status == kCLAuthorizationStatusAuthorizedWhenInUse)) {
+            return;
+    }
+
+    PermissionStatus permissionStatus = [LocationPermissionStrategy
+                                         determinePermissionStatus:_requestedPermission authorizationStatus:status];
+    
+    _permissionStatusHandler(permissionStatus);
+}
+
+
++ (PermissionStatus)permissionStatus:(PermissionGroup)permission {
+    CLAuthorizationStatus authorizationStatus = [CLLocationManager authorizationStatus];
+    
+    
+    PermissionStatus status = [LocationPermissionStrategy
+                               determinePermissionStatus:permission authorizationStatus:authorizationStatus];
+    
+    return status;
+}
+
+
++ (PermissionStatus)determinePermissionStatus:(PermissionGroup)permission authorizationStatus:(CLAuthorizationStatus)authorizationStatus {
+    if (@available(iOS 8.0, *)) {
+        if (permission == PermissionGroupLocationAlways) {
+            switch (authorizationStatus) {
+                case kCLAuthorizationStatusNotDetermined:
+                    return PermissionStatusDenied;
+                case kCLAuthorizationStatusRestricted:
+                    return PermissionStatusRestricted;
+                case kCLAuthorizationStatusAuthorizedWhenInUse:
+                case kCLAuthorizationStatusDenied:
+                    return PermissionStatusPermanentlyDenied;
+                case kCLAuthorizationStatusAuthorizedAlways:
+                    return PermissionStatusGranted;
+            }
+        }
+        
+        switch (authorizationStatus) {
+            case kCLAuthorizationStatusNotDetermined:
+                return PermissionStatusDenied;
+            case kCLAuthorizationStatusRestricted:
+                return PermissionStatusRestricted;
+            case kCLAuthorizationStatusDenied:
+                return PermissionStatusPermanentlyDenied;
+            case kCLAuthorizationStatusAuthorizedWhenInUse:
+            case kCLAuthorizationStatusAuthorizedAlways:
+                return PermissionStatusGranted;
+        }
+    }
+    
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+
+    switch (authorizationStatus) {
+        case kCLAuthorizationStatusNotDetermined:
+            return PermissionStatusDenied;
+        case kCLAuthorizationStatusRestricted:
+            return PermissionStatusRestricted;
+        case kCLAuthorizationStatusDenied:
+            return PermissionStatusPermanentlyDenied;
+        case kCLAuthorizationStatusAuthorized:
+            return PermissionStatusGranted;
+        default:
+            return PermissionStatusDenied;
+    }
+
+#pragma clang diagnostic pop
+
+}
+
+@end
+
+#else
+
+@implementation LocationPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/MediaLibraryPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#include "PermissionStrategy.h"
+
+#if PERMISSION_MEDIA_LIBRARY
+
+#import <MediaPlayer/MediaPlayer.h>
+
+@interface MediaLibraryPermissionStrategy : NSObject <PermissionStrategy>
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface MediaLibraryPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/MediaLibraryPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "MediaLibraryPermissionStrategy.h"
+
+#if PERMISSION_MEDIA_LIBRARY
+
+@implementation MediaLibraryPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return [MediaLibraryPermissionStrategy permissionStatus];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+
+    if (@available(iOS 9.3, *)) {
+        [MPMediaLibrary requestAuthorization:^(MPMediaLibraryAuthorizationStatus status) {
+            completionHandler([MediaLibraryPermissionStrategy determinePermissionStatus:status]);
+        }];
+    } else {
+        completionHandler(PermissionStatusPermanentlyDenied);
+        return;
+    }
+}
+
++ (PermissionStatus)permissionStatus {
+    if (@available(iOS 9.3, *)) {
+        MPMediaLibraryAuthorizationStatus status = [MPMediaLibrary authorizationStatus];
+
+        return [MediaLibraryPermissionStrategy determinePermissionStatus:status];
+    }
+
+    return PermissionStatusDenied;
+}
+
++ (PermissionStatus)determinePermissionStatus:(MPMediaLibraryAuthorizationStatus)authorizationStatus  API_AVAILABLE(ios(9.3)){
+    switch (authorizationStatus) {
+        case MPMediaLibraryAuthorizationStatusNotDetermined:
+            return PermissionStatusDenied;
+        case MPMediaLibraryAuthorizationStatusDenied:
+            return PermissionStatusPermanentlyDenied;
+        case MPMediaLibraryAuthorizationStatusRestricted:
+            return PermissionStatusRestricted;
+        case MPMediaLibraryAuthorizationStatusAuthorized:
+            return PermissionStatusGranted;
+    }
+
+    return PermissionStatusDenied;
+}
+
+@end
+
+#else
+
+@implementation MediaLibraryPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/NotificationPermissionStrategy.h

+//
+//  NotificationPermissionStrategy.h
+//  permission_handler
+//
+//  Created by Tong on 2019/10/21.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_NOTIFICATIONS
+
+#import <UserNotifications/UserNotifications.h>
+
+@interface NotificationPermissionStrategy : NSObject <PermissionStrategy>
+
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface NotificationPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/NotificationPermissionStrategy.m

+//
+//  NotificationPermissionStrategy.m
+//  permission_handler
+//
+//  Created by Tong on 2019/10/21.
+//
+
+#import "NotificationPermissionStrategy.h"
+
+#if PERMISSION_NOTIFICATIONS
+
+@implementation NotificationPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+  return [NotificationPermissionStrategy permissionStatus];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+  return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+  PermissionStatus status = [self checkPermissionStatus:permission];
+  if (status != PermissionStatusDenied) {
+    completionHandler(status);
+    return;
+  }
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if(@available(iOS 10.0, *)) {
+      UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+      UNAuthorizationOptions authorizationOptions = 0;
+      authorizationOptions += UNAuthorizationOptionSound;
+      authorizationOptions += UNAuthorizationOptionAlert;
+      authorizationOptions += UNAuthorizationOptionBadge;
+      [center requestAuthorizationWithOptions:(authorizationOptions) completionHandler:^(BOOL granted, NSError * _Nullable error) {
+        if (error != nil || !granted) {
+          completionHandler(PermissionStatusPermanentlyDenied);
+          return;
+        }
+
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [[UIApplication sharedApplication] registerForRemoteNotifications];
+            completionHandler(PermissionStatusGranted);
+        });
+      }];
+
+    } else {
+      UIUserNotificationType notificationTypes = 0;
+      notificationTypes |= UIUserNotificationTypeSound;
+      notificationTypes |= UIUserNotificationTypeAlert;
+      notificationTypes |= UIUserNotificationTypeBadge;
+      UIUserNotificationSettings *settings = [UIUserNotificationSettings settingsForTypes:notificationTypes categories:nil];
+      [[UIApplication sharedApplication] registerUserNotificationSettings:settings];
+
+      [[UIApplication sharedApplication] registerForRemoteNotifications];
+      completionHandler(PermissionStatusGranted);
+    }
+  });
+}
+
++ (PermissionStatus)permissionStatus {
+  __block PermissionStatus permissionStatus = PermissionStatusGranted;
+  if (@available(iOS 10 , *)) {
+    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
+    [[UNUserNotificationCenter currentNotificationCenter] getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
+      if (settings.authorizationStatus == UNAuthorizationStatusDenied) {
+        permissionStatus = PermissionStatusPermanentlyDenied;
+      } else if (settings.authorizationStatus == UNAuthorizationStatusNotDetermined) {
+        permissionStatus = PermissionStatusDenied;
+      }
+      dispatch_semaphore_signal(sem);
+    }];
+    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
+  } else if (@available(iOS 8 , *)) {
+    UIUserNotificationSettings * setting = [[UIApplication sharedApplication] currentUserNotificationSettings];
+    if (setting.types == UIUserNotificationTypeNone) permissionStatus = PermissionStatusDenied;
+  } else {
+      permissionStatus = PermissionStatusPermanentlyDenied;
+  }
+  return permissionStatus;
+}
+
+@end
+
+#else
+
+@implementation NotificationPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/PermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionHandlerEnums.h"
+
+typedef void (^PermissionStatusHandler)(PermissionStatus permissionStatus);
+
+@protocol PermissionStrategy <NSObject>
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission;
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission;
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler;
+@end

ios/Classes/strategies/PhonePermissionStrategy.h

+//
+//  PhonePermissionStrategy.h
+//  permission_handler
+//
+//  Created by Sebastian Roth on 5/20/19.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface PhonePermissionStrategy : NSObject<PermissionStrategy>
+
+@end
+
+NS_ASSUME_NONNULL_END

ios/Classes/strategies/PhonePermissionStrategy.m

+//
+//  PhonePermissionStrategy.m
+//  permission_handler
+//
+//  Created by Sebastian Roth on 5/20/19.
+//
+
+#import <CoreTelephony/CTTelephonyNetworkInfo.h>
+#import <CoreTelephony/CTCarrier.h>
+
+#import "PhonePermissionStrategy.h"
+
+@implementation PhonePermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+  return PermissionStatusDenied;
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+  // https://stackoverflow.com/a/5095058
+  if (![[UIApplication sharedApplication] canOpenURL:[NSURL URLWithString:@"tel://"]]) {
+    return ServiceStatusNotApplicable;
+  }
+  
+  return [self canDevicePlaceAPhoneCall] ? ServiceStatusEnabled : ServiceStatusDisabled;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+  completionHandler(PermissionStatusPermanentlyDenied);
+}
+
+
+/**
+ * Returns YES if the device can place a phone call.
+ */
+-(bool) canDevicePlaceAPhoneCall {
+  CTTelephonyNetworkInfo *netInfo = [[CTTelephonyNetworkInfo alloc] init];
+  
+  if(@available(iOS 12.0, *)) {
+    NSDictionary<NSString *, CTCarrier *> *providers = [netInfo serviceSubscriberCellularProviders];
+    for (NSString *key in providers) {
+      CTCarrier *carrier = [providers objectForKey:key];
+      if ([self canPlacePhoneCallWithCarrier:carrier]) {
+        return YES;
+      }
+    }
+    
+    return NO;
+  } else {
+    CTCarrier *carrier = [netInfo subscriberCellularProvider];
+    return [self canPlacePhoneCallWithCarrier:carrier];
+  }
+}
+
+-(bool)canPlacePhoneCallWithCarrier:(CTCarrier *)carrier {
+  // https://stackoverflow.com/a/11595365
+  NSString *mnc = [carrier mobileNetworkCode];
+  if (([mnc length] == 0) || ([mnc isEqualToString:@"65535"])) {
+    // Device cannot place a call at this time.  SIM might be removed.
+    return NO;
+  } else {
+    // Device can place a phone call
+    return YES;
+  }
+}
+
+@end

ios/Classes/strategies/PhotoPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_PHOTOS
+
+#import <Photos/Photos.h>
+
+@interface PhotoPermissionStrategy : NSObject <PermissionStrategy>
+-(instancetype)initWithAccessAddOnly:(BOOL) addOnly;
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface PhotoPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/PhotoPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "PhotoPermissionStrategy.h"
+
+#if PERMISSION_PHOTOS
+
+@implementation PhotoPermissionStrategy{
+    bool addOnlyAccessLevel;
+}
+
+- (instancetype)initWithAccessAddOnly:(BOOL)addOnly {
+    self = [super init];
+    if(self) {
+        addOnlyAccessLevel = addOnly;
+    }
+    
+    return self;
+}
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return [PhotoPermissionStrategy permissionStatus:addOnlyAccessLevel];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+
+    if(@available(iOS 14, *)) {
+        [PHPhotoLibrary requestAuthorizationForAccessLevel:(addOnlyAccessLevel)?PHAccessLevelAddOnly:PHAccessLevelReadWrite handler:^(PHAuthorizationStatus authorizationStatus) {
+            completionHandler([PhotoPermissionStrategy determinePermissionStatus:authorizationStatus]);
+        }];
+    }else {
+    [PHPhotoLibrary requestAuthorization:^(PHAuthorizationStatus authorizationStatus) {
+        completionHandler([PhotoPermissionStrategy determinePermissionStatus:authorizationStatus]);
+    }];
+    }
+}
+
++ (PermissionStatus)permissionStatus:(BOOL) addOnlyAccessLevel {
+    PHAuthorizationStatus status;
+    if(@available(iOS 14, *)){
+        status = [PHPhotoLibrary authorizationStatusForAccessLevel:(addOnlyAccessLevel)?PHAccessLevelAddOnly:PHAccessLevelReadWrite];
+    }else {
+        status = [PHPhotoLibrary authorizationStatus];
+    }
+
+    return [PhotoPermissionStrategy determinePermissionStatus:status];
+}
+
++ (PermissionStatus)determinePermissionStatus:(PHAuthorizationStatus)authorizationStatus {
+    switch (authorizationStatus) {
+        case PHAuthorizationStatusNotDetermined:
+            return PermissionStatusDenied;
+        case PHAuthorizationStatusRestricted:
+            return PermissionStatusRestricted;
+        case PHAuthorizationStatusDenied:
+            return PermissionStatusPermanentlyDenied;
+        case PHAuthorizationStatusAuthorized:
+            return PermissionStatusGranted;
+        case PHAuthorizationStatusLimited:
+            return PermissionStatusLimited;
+    }
+
+    return PermissionStatusDenied;
+}
+
+@end
+
+#else
+
+@implementation PhotoPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/SensorPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_SENSORS
+
+#import <CoreMotion/CoreMotion.h>
+
+@interface SensorPermissionStrategy : NSObject <PermissionStrategy>
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface SensorPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/SensorPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "SensorPermissionStrategy.h"
+
+#if PERMISSION_SENSORS
+
+@implementation SensorPermissionStrategy
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return [SensorPermissionStrategy permissionStatus];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    if (@available(iOS 11.0, *)) {
+        return [CMMotionActivityManager isActivityAvailable]
+        ? ServiceStatusEnabled
+        : ServiceStatusDisabled;
+    }
+    
+    return ServiceStatusDisabled;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+    
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+    
+    if (@available(iOS 11.0, *)) {
+        CMMotionActivityManager *motionManager = [[CMMotionActivityManager alloc] init];
+        
+        NSDate *today = [NSDate new];
+        [motionManager queryActivityStartingFromDate:today toDate:today toQueue:[NSOperationQueue mainQueue] withHandler:^(NSArray<CMMotionActivity *> *__nullable activities, NSError *__nullable error) {
+            PermissionStatus status = [SensorPermissionStrategy permissionStatus];
+            completionHandler(status);
+        }];
+    } else {
+        completionHandler(PermissionStatusDenied);
+    }
+    
+}
+
++ (PermissionStatus)permissionStatus {
+    if (@available(iOS 11.0, *)) {
+        CMAuthorizationStatus status = [CMMotionActivityManager authorizationStatus];
+        PermissionStatus permissionStatus;
+        
+        switch (status) {
+            case CMAuthorizationStatusNotDetermined:
+                permissionStatus = PermissionStatusDenied;
+                break;
+            case CMAuthorizationStatusRestricted:
+                permissionStatus = PermissionStatusRestricted;
+                break;
+            case CMAuthorizationStatusDenied:
+                permissionStatus = PermissionStatusPermanentlyDenied;
+                break;
+            case CMAuthorizationStatusAuthorized:
+                permissionStatus = PermissionStatusGranted;
+                break;
+            default:
+                permissionStatus = PermissionStatusGranted;
+        }
+        
+        return permissionStatus;
+    }
+    
+    return PermissionStatusDenied;
+}
+
+@end
+
+#else
+
+@implementation SensorPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/SpeechPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+#if PERMISSION_SPEECH_RECOGNIZER
+
+#import <Speech/Speech.h>
+
+@interface SpeechPermissionStrategy : NSObject <PermissionStrategy>
+@end
+
+#else
+
+#import "UnknownPermissionStrategy.h"
+@interface SpeechPermissionStrategy : UnknownPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/SpeechPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "SpeechPermissionStrategy.h"
+
+#if PERMISSION_SPEECH_RECOGNIZER
+
+@implementation SpeechPermissionStrategy
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return [SpeechPermissionStrategy permissionStatus];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    PermissionStatus status = [self checkPermissionStatus:permission];
+    
+    if (status != PermissionStatusDenied) {
+        completionHandler(status);
+        return;
+    }
+    
+    if (@available(iOS 10.0, *)) {
+        [SFSpeechRecognizer requestAuthorization:^(SFSpeechRecognizerAuthorizationStatus authorizationStatus) {
+            completionHandler([SpeechPermissionStrategy determinePermissionStatus:authorizationStatus]);
+        }];
+    } else {
+        completionHandler(PermissionStatusDenied);
+    }
+}
+
++ (PermissionStatus)permissionStatus {
+    if (@available(iOS 10.0, *)) {
+        SFSpeechRecognizerAuthorizationStatus status = [SFSpeechRecognizer authorizationStatus];
+        
+        return [SpeechPermissionStrategy determinePermissionStatus:status];
+    }
+    
+    return PermissionStatusDenied;
+}
+
++ (PermissionStatus)determinePermissionStatus:(SFSpeechRecognizerAuthorizationStatus)authorizationStatus  API_AVAILABLE(ios(10.0)){
+    switch (authorizationStatus) {
+        case SFSpeechRecognizerAuthorizationStatusNotDetermined:
+            return PermissionStatusDenied;
+        case SFSpeechRecognizerAuthorizationStatusDenied:
+            return PermissionStatusPermanentlyDenied;
+        case SFSpeechRecognizerAuthorizationStatusRestricted:
+            return PermissionStatusRestricted;
+        case SFSpeechRecognizerAuthorizationStatusAuthorized:
+            return PermissionStatusGranted;
+    }
+    
+    return PermissionStatusDenied;
+}
+
+@end
+
+#else
+
+@implementation SpeechPermissionStrategy
+@end
+
+#endif

ios/Classes/strategies/StoragePermissionStrategy.h

+//
+//  StoragePermissionStrategy.h
+//  permission_handler
+//
+//  Created by Frank Gregor on 06.11.19.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface StoragePermissionStrategy : NSObject <PermissionStrategy>
+
+@end
+
+NS_ASSUME_NONNULL_END

ios/Classes/strategies/StoragePermissionStrategy.m

+//
+//  StoragePermissionStrategy.m
+//  permission_handler
+//
+//  Created by Frank Gregor on 06.11.19.
+//
+
+#import "StoragePermissionStrategy.h"
+
+@implementation StoragePermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return [StoragePermissionStrategy permissionStatus];
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusNotApplicable;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    completionHandler([StoragePermissionStrategy permissionStatus]);
+}
+
++ (PermissionStatus)permissionStatus {
+    return PermissionStatusGranted;
+}
+
+@end

ios/Classes/strategies/UnknownPermissionStrategy.h

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionStrategy.h"
+
+
+@interface UnknownPermissionStrategy : NSObject <PermissionStrategy>
+@end
\ No newline at end of file

ios/Classes/strategies/UnknownPermissionStrategy.m

+//
+// Created by Razvan Lung(long1eu) on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "UnknownPermissionStrategy.h"
+
+
+@implementation UnknownPermissionStrategy
+
+- (PermissionStatus)checkPermissionStatus:(PermissionGroup)permission {
+    return PermissionStatusDenied;
+}
+
+- (ServiceStatus)checkServiceStatus:(PermissionGroup)permission {
+    return ServiceStatusDisabled;
+}
+
+- (void)requestPermission:(PermissionGroup)permission completionHandler:(PermissionStatusHandler)completionHandler {
+    completionHandler(PermissionStatusPermanentlyDenied);
+}
+@end

ios/Classes/util/Codec.h

+//
+// Created by Razvan Lung on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "PermissionHandlerEnums.h"
+
+@interface Codec : NSObject
++ (PermissionGroup)decodePermissionGroupFrom:(NSNumber *_Nonnull)event;
+
++ (NSArray*_Nullable)decodePermissionGroupsFrom:(NSArray<NSNumber *> *_Nullable)event;
+
++ (NSNumber *_Nullable)encodePermissionStatus:(enum PermissionStatus)permissionStatus;
+
++ (NSNumber *_Nullable)encodeServiceStatus:(enum ServiceStatus)serviceStatus;
+@end

ios/Classes/util/Codec.m

+//
+// Created by Razvan Lung on 2019-02-15.
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+//
+
+#import "Codec.h"
+
+@implementation Codec
++ (PermissionGroup)decodePermissionGroupFrom:(NSNumber *)event {
+    return (PermissionGroup) event.intValue;
+}
+
++ (NSArray *_Nullable)decodePermissionGroupsFrom:(NSArray<NSNumber *> *)event {
+    NSMutableArray *result = [[NSMutableArray alloc] init];
+    for (NSNumber *number in event) {
+        [result addObject:@([self decodePermissionGroupFrom:number])];
+    }
+    return [[NSArray alloc] initWithArray:result];
+}
+
++ (NSNumber *_Nullable)encodePermissionStatus:(enum PermissionStatus)permissionStatus {
+    return [[NSNumber alloc] initWithInt:permissionStatus];
+}
+
++ (NSNumber *_Nullable)encodeServiceStatus:(enum ServiceStatus)serviceStatus {
+    return [[NSNumber alloc] initWithInt:serviceStatus];
+}
+
+@end

ios/permission_handler.podspec

+#
+# To learn more about a Podspec see http://guides.cocoapods.org/syntax/podspec.html
+#
+Pod::Spec.new do |s|
+  s.name             = 'permission_handler'
+  s.version          = '5.1.0+2'
+  s.summary          = 'Permission plugin for Flutter.'
+  s.description      = <<-DESC
+Permission plugin for Flutter. This plugin provides a cross-platform (iOS, Android) API to request and check permissions.
+                       DESC
+  s.homepage         = 'https://github.com/baseflowit/flutter-permission-handler'
+  s.license          = { :file => '../LICENSE' }
+  s.author           = { 'Baseflow' => 'hello@baseflow.com' }
+  s.source           = { :path => '.' }
+  s.source_files = 'Classes/**/*'
+  s.public_header_files = 'Classes/**/*.h'
+  s.dependency 'Flutter'
+
+  s.ios.deployment_target = '8.0'
+  s.static_framework = true
+end
+

lib/permission_handler.dart

+import 'package:flutter/foundation.dart';
+import 'package:permission_handler_platform_interface/permission_handler_platform_interface.dart';
+
+export 'package:permission_handler_platform_interface/permission_handler_platform_interface.dart'
+    show
+        Permission,
+        PermissionStatus,
+        PermissionStatusGetters,
+        PermissionWithService,
+        FuturePermissionStatusGetters,
+        ServiceStatus,
+        ServiceStatusGetters,
+        FutureServiceStatusGetters;
+
+PermissionHandlerPlatform get _handler => PermissionHandlerPlatform.instance;
+
+/// Opens the app settings page.
+///
+/// Returns [true] if the app settings page could be opened, otherwise [false].
+Future<bool> openAppSettings() => _handler.openAppSettings();
+
+/// Actions that can be executed on a permission.
+extension PermissionActions on Permission {
+  /// The current status of this permission.
+  Future<PermissionStatus> get status => _handler.checkPermissionStatus(this);
+
+  /// If you should show a rationale for requesting permission.
+  ///
+  /// This is only implemented on Android, calling this on iOS always returns
+  /// [false].
+  Future<bool> get shouldShowRequestRationale async {
+    if (defaultTargetPlatform != TargetPlatform.android) {
+      return false;
+    }
+
+    return _handler.shouldShowRequestPermissionRationale(this);
+  }
+
+  /// Request the user for access to this [Permission], if access hasn't already
+  /// been grant access before.
+  ///
+  /// Returns the new [PermissionStatus].
+  Future<PermissionStatus> request() async {
+    final permissionStatus = (await [this].request())[this];
+    return permissionStatus ?? PermissionStatus.denied;
+  }
+}
+
+/// Shortcuts for checking the [status] of a [Permission].
+extension PermissionCheckShortcuts on Permission {
+  /// If the user granted this permission.
+  Future<bool> get isGranted => status.isGranted;
+
+  /// If the user denied this permission.
+  Future<bool> get isDenied => status.isDenied;
+
+  /// If the OS denied this permission. The user cannot change the status,
+  /// possibly due to active restrictions such as parental controls being in
+  /// place.
+  /// *Only supported on iOS.*
+  Future<bool> get isRestricted => status.isRestricted;
+
+  /// User has authorized this application for limited photo library access.
+  /// *Only supported on iOS.(iOS14+)*
+  Future<bool> get isLimited => status.isLimited;
+
+  /// Returns `true` when permissions are denied permanently.
+  ///
+  /// When permissions are denied permanently, no new permission dialog will
+  /// be showed to the user. Consuming Apps should redirect the user to the
+  /// App settings to change permissions.
+  Future<bool> get isPermanentlyDenied => status.isPermanentlyDenied;
+}
+
+/// Actions that apply only to permissions that have an associated service.
+extension ServicePermissionActions on PermissionWithService {
+  /// Checks the current status of the service associated with this permission.
+  ///
+  /// Notes about specific permissions:
+  /// - **[Permission.phone]**
+  ///   - Android:
+  ///     - The method will return [ServiceStatus.notApplicable] when:
+  ///       - the device lacks the TELEPHONY feature
+  ///       - TelephonyManager.getPhoneType() returns PHONE_TYPE_NONE
+  ///       - when no Intents can be resolved to handle the `tel:` scheme
+  ///     - The method will return [ServiceStatus.disabled] when:
+  ///       - the SIM card is missing
+  ///   - iOS:
+  ///     - The method will return [ServiceStatus.notApplicable] when:
+  ///       - the native code can not find a handler for the `tel:` scheme
+  ///     - The method will return [ServiceStatus.disabled] when:
+  ///       - the mobile network code (MNC) is either 0 or 65535. See
+  ///          https://stackoverflow.com/a/11595365 for details
+  ///   - **PLEASE NOTE that this is still not a perfect indication** of the
+  ///     device's capability to place & connect phone calls as it also depends
+  ///     on the network condition.
+  Future<ServiceStatus> get serviceStatus => _handler.checkServiceStatus(this);
+}
+
+/// Actions that can be taken on a [List] of [Permission]s.
+extension PermissionListActions on List<Permission> {
+  /// Requests the user for access to these permissions, if they haven't already
+  /// been granted before.
+  ///
+  /// Returns a [Map] containing the status per requested [Permission].
+  Future<Map<Permission, PermissionStatus>> request() =>
+      _handler.requestPermissions(this);
+}

pubspec.yaml

+name: permission_handler
+description: Permission plugin for Flutter. This plugin provides a cross-platform (iOS, Android) API to request and check permissions.
+version: 8.2.5
+homepage: https://github.com/baseflowit/flutter-permission-handler
+
+flutter:
+  plugin:
+    platforms:
+      android:
+        package: com.baseflow.permissionhandler
+        pluginClass: PermissionHandlerPlugin
+      ios:
+        pluginClass: PermissionHandlerPlugin
+
+dependencies:
+  flutter:
+    sdk: flutter
+  meta: ^1.3.0
+  permission_handler_platform_interface: ^3.7.0
+
+dev_dependencies:
+  flutter_test:
+    sdk: flutter
+  mockito: ^5.0.1
+  effective_dart: ^1.3.0
+  plugin_platform_interface: ^2.0.0
+
+environment:
+  sdk: ">=2.12.0 <3.0.0"
+  flutter: ">=1.12.8"

scripts/before_build_apks.sh

+#!/bin/bash
+wget https://dl.google.com/android/repository/sdk-tools-linux-3859397.zip
+mkdir android-sdk
+unzip -qq sdk-tools-linux-3859397.zip -d $HOME/android-sdk
+export ANDROID_HOME=$HOME/android-sdk
+export PATH=$HOME/android-sdk/tools/bin:$PATH
+mkdir -p /home/travis/.android # silence sdkmanager warning
+echo 'count=0' > /home/travis/.android/repositories.cfg # silence sdkmanager warning
+        # suppressing output of sdkmanager to keep log under 4MB (travis limit)
+echo y | sdkmanager "tools" >/dev/null
+echo y | sdkmanager "platform-tools" >/dev/null
+echo y | sdkmanager "build-tools;26.0.3" >/dev/null
+echo y | sdkmanager "platforms;android-26" >/dev/null
+echo y | sdkmanager "extras;android;m2repository" >/dev/null
+echo y | sdkmanager "extras;google;m2repository" >/dev/null
+echo y | sdkmanager "patcher;v4" >/dev/null
+sdkmanager --list
+wget http://services.gradle.org/distributions/gradle-4.1-bin.zip
+unzip -qq gradle-4.1-bin.zip -d $HOME/gradle-4.1
+export GRADLE_HOME=$HOME/gradle-4.1
+export PATH=$GRADLE_HOME/bin:$PATH
+gradle -v
+git clone --single-branch --branch stable https://github.com/flutter/flutter.git $HOME/flutter
+export PATH=$HOME/flutter/bin:$HOME/flutter/bin/cache/dart-sdk/bin:$PATH
+flutter doctor
+

scripts/before_build_ipas.sh

+#!/bin/bash
+brew update
+brew install libimobiledevice
+brew install ideviceinstaller
+brew install ios-deploy
+pod repo update
+gem update cocoapods
+git clone --single-branch --branch stable https://github.com/flutter/flutter.git $HOME/flutter
+export PATH=$HOME/flutter/bin:$HOME/flutter/bin/cache/dart-sdk/bin:$PATH
+flutter doctor

test/permission_handler_test.dart

+import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/mockito.dart';
+import 'package:permission_handler/permission_handler.dart';
+import 'package:permission_handler_platform_interface/permission_handler_platform_interface.dart';
+import 'package:plugin_platform_interface/plugin_platform_interface.dart';
+
+void main() {
+  group('PermissionHandler', () {
+    setUp(() {
+      PermissionHandlerPlatform.instance = MockPermissionHandlerPlatform();
+    });
+
+    test('openAppSettings', () async {
+      final hasOpened = await openAppSettings();
+
+      expect(hasOpened, true);
+    });
+
+    test('PermissionActions on Permission: get status', () async {
+      final permissionStatus = await Permission.calendar.status;
+
+      expect(permissionStatus, PermissionStatus.granted);
+    });
+
+    test(
+        // ignore: lines_longer_than_80_chars
+        'PermissionActions on Permission: get shouldShowRequestRationale should return true when on android',
+        () async {
+      final mockPermissionHandlerPlatform = PermissionHandlerPlatform.instance;
+
+      when(mockPermissionHandlerPlatform
+              .shouldShowRequestPermissionRationale(Permission.calendar))
+          .thenAnswer((_) => Future.value(true));
+
+      await Permission.calendar.shouldShowRequestRationale;
+
+      verify(mockPermissionHandlerPlatform
+              .shouldShowRequestPermissionRationale(Permission.calendar))
+          .called(1);
+    });
+
+    test('PermissionActions on Permission: request()', () async {
+      final permissionRequest = Permission.calendar.request();
+
+      expect(permissionRequest, isA<Future<PermissionStatus>>());
+    });
+
+    test('PermissionCheckShortcuts on Permission: get isGranted', () async {
+      final isGranted = await Permission.calendar.isGranted;
+      expect(isGranted, true);
+    });
+
+    test('PermissionCheckShortcuts on Permission: get isDenied', () async {
+      final isDenied = await Permission.calendar.isDenied;
+      expect(isDenied, false);
+    });
+
+    test('PermissionCheckShortcuts on Permission: get isRestricted', () async {
+      final isRestricted = await Permission.calendar.isRestricted;
+      expect(isRestricted, false);
+    });
+
+    test('PermissionCheckShortcuts on Permission: get isLimited', () async {
+      final isLimited = await Permission.calendar.isLimited;
+      expect(isLimited, false);
+    });
+
+    test('PermissionCheckShortcuts on Permission: get isPermanentlyDenied',
+        () async {
+      final isPermanentlyDenied = await Permission.calendar.isPermanentlyDenied;
+      expect(isPermanentlyDenied, false);
+    });
+
+    test(
+        // ignore: lines_longer_than_80_chars
+        'ServicePermissionActions on PermissionWithService: get ServiceStatus returns the right service status',
+        () async {
+      var serviceStatus = await Permission.phone.serviceStatus;
+
+      expect(serviceStatus, ServiceStatus.enabled);
+    });
+
+    test(
+        // ignore: lines_longer_than_80_chars
+        'PermissionListActions on List<Permission>: request() on  a list returns a Map<Permission, PermissionStatus>',
+        () async {
+      var permissionList = <Permission>[];
+      final permissionMap = await permissionList.request();
+
+      expect(permissionMap, isA<Map<Permission, PermissionStatus>>());
+    });
+  });
+}
+
+class MockPermissionHandlerPlatform extends Mock
+    with
+        // ignore: prefer_mixin
+        MockPlatformInterfaceMixin
+    implements
+        PermissionHandlerPlatform {
+  @override
+  Future<PermissionStatus> checkPermissionStatus(Permission permission) =>
+      Future.value(PermissionStatus.granted);
+
+  @override
+  Future<ServiceStatus> checkServiceStatus(Permission permission) =>
+      Future.value(ServiceStatus.enabled);
+
+  @override
+  Future<bool> openAppSettings() => Future.value(true);
+
+  @override
+  Future<Map<Permission, PermissionStatus>> requestPermissions(
+      List<Permission> permissions) {
+    var permissionsMap = <Permission, PermissionStatus>{};
+    return Future.value(permissionsMap);
+  }
+
+  @override
+  Future<bool> shouldShowRequestPermissionRationale(Permission? permission) {
+    return super.noSuchMethod(
+      Invocation.method(
+        #shouldShowPermissionRationale,
+        [permission],
+      ),
+      returnValue: Future.value(true),
+    );
+  }
+}