react-native-permissions
    TypeScript icon, indicating that this package has built-in type declarations

    3.0.5 • Public • Published

    ☝🏼 react-native-permissions

    This library helped you? Consider sponsoring!

    A unified permissions API for React Native on iOS, Android and Windows.
    (For Windows only builds 18362 and later are supported)

    npm version npm MIT
    Platform - Android Platform - iOS Platform - Windows

    Support

    version react-native version Xcode version
    3.0.0+ 0.63.0+ 12+

    Setup

    $ npm install --save react-native-permissions
    # --- or ---
    $ yarn add react-native-permissions

    iOS

    By default no permission handler is installed. Update your Podfile by choosing the ones you want to check or request, then run pod install.

    target 'YourAwesomeProject' do
    
      # …
    
      permissions_path = '../node_modules/react-native-permissions/ios'
    
      pod 'Permission-AppTrackingTransparency', :path => "#{permissions_path}/AppTrackingTransparency"
      pod 'Permission-BluetoothPeripheral', :path => "#{permissions_path}/BluetoothPeripheral"
      pod 'Permission-Calendars', :path => "#{permissions_path}/Calendars"
      pod 'Permission-Camera', :path => "#{permissions_path}/Camera"
      pod 'Permission-Contacts', :path => "#{permissions_path}/Contacts"
      pod 'Permission-FaceID', :path => "#{permissions_path}/FaceID"
      pod 'Permission-LocationAccuracy', :path => "#{permissions_path}/LocationAccuracy"
      pod 'Permission-LocationAlways', :path => "#{permissions_path}/LocationAlways"
      pod 'Permission-LocationWhenInUse', :path => "#{permissions_path}/LocationWhenInUse"
      pod 'Permission-MediaLibrary', :path => "#{permissions_path}/MediaLibrary"
      pod 'Permission-Microphone', :path => "#{permissions_path}/Microphone"
      pod 'Permission-Motion', :path => "#{permissions_path}/Motion"
      pod 'Permission-Notifications', :path => "#{permissions_path}/Notifications"
      pod 'Permission-PhotoLibrary', :path => "#{permissions_path}/PhotoLibrary"
      pod 'Permission-PhotoLibraryAddOnly', :path => "#{permissions_path}/PhotoLibraryAddOnly"
      pod 'Permission-Reminders', :path => "#{permissions_path}/Reminders"
      pod 'Permission-Siri', :path => "#{permissions_path}/Siri"
      pod 'Permission-SpeechRecognition', :path => "#{permissions_path}/SpeechRecognition"
      pod 'Permission-StoreKit', :path => "#{permissions_path}/StoreKit"
    
    end

    ⚠️ If you see a No permission handler detected error: Make sure that you have at least one permission handler set up. In some cases the Xcode cache needs to be cleared (Xcode -> Product -> Clean Build Folder)

    Then update your Info.plist with wanted permissions usage descriptions:

    <?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>
    
      <!-- 🚨 Keep only the permissions used in your app 🚨 -->
    
      <key>NSAppleMusicUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSBluetoothAlwaysUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSBluetoothPeripheralUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSCalendarsUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSCameraUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSContactsUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSFaceIDUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSLocationAlwaysUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSLocationTemporaryUsageDescriptionDictionary</key>
      <dict>
        <key>YOUR-PURPOSE-KEY</key>
        <string>YOUR TEXT</string>
      </dict>
      <key>NSLocationWhenInUseUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSMicrophoneUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSMotionUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSPhotoLibraryUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSPhotoLibraryAddUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSRemindersUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSSpeechRecognitionUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSSiriUsageDescription</key>
      <string>YOUR TEXT</string>
      <key>NSUserTrackingUsageDescription</key>
      <string>YOUR TEXT</string>
    
      <!---->
    
    </dict>
    </plist>

    Workaround for use_frameworks! issues

    If you use use_frameworks!, add this at the top of your Podfile, and uncomment the line corresponding to your CocoaPods version:

    use_frameworks!
    
    # Convert all permission pods into static libraries
    pre_install do |installer|
      Pod::Installer::Xcode::TargetValidator.send(:define_method, :verify_no_static_framework_transitive_dependencies) {}
    
      installer.pod_targets.each do |pod|
        if pod.name.eql?('RNPermissions') || pod.name.start_with?('Permission-')
          def pod.build_type;
            # Uncomment the line corresponding to your CocoaPods version
            # Pod::BuildType.static_library # >= 1.9
            # Pod::Target::BuildType.static_library # < 1.9
          end
        end
      end
    end

    Android

    Add all wanted permissions to your app android/app/src/main/AndroidManifest.xml file:

    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.myawesomeapp">
    
      <!-- 🚨 Keep only the permissions used in your app 🚨 -->
    
      <uses-permission android:name="android.permission.ACCEPT_HANDOVER" />
      <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
      <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
      <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
      <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
      <uses-permission android:name="android.permission.ANSWER_PHONE_CALLS" />
      <uses-permission android:name="android.permission.BODY_SENSORS" />
      <uses-permission android:name="android.permission.CALL_PHONE" />
      <uses-permission android:name="android.permission.CAMERA" />
      <uses-permission android:name="android.permission.GET_ACCOUNTS" />
      <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />
      <uses-permission android:name="android.permission.READ_CALENDAR" />
      <uses-permission android:name="android.permission.READ_CALL_LOG" />
      <uses-permission android:name="android.permission.READ_CONTACTS" />
      <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
      <uses-permission android:name="android.permission.READ_PHONE_NUMBERS" />
      <uses-permission android:name="android.permission.READ_PHONE_STATE" />
      <uses-permission android:name="android.permission.READ_SMS" />
      <uses-permission android:name="android.permission.RECEIVE_MMS" />
      <uses-permission android:name="android.permission.RECEIVE_SMS" />
      <uses-permission android:name="android.permission.RECEIVE_WAP_PUSH" />
      <uses-permission android:name="android.permission.RECORD_AUDIO" />
      <uses-permission android:name="android.permission.SEND_SMS" />
      <uses-permission android:name="android.permission.USE_SIP" />
      <uses-permission android:name="android.permission.WRITE_CALENDAR" />
      <uses-permission android:name="android.permission.WRITE_CALL_LOG" />
      <uses-permission android:name="android.permission.WRITE_CONTACTS" />
      <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
      <uses-permission android:name="com.android.voicemail.permission.ADD_VOICEMAIL" />
    
      <!---->
    
    </manifest>

    Windows

    Open the project solution file from the windows folder. In the app project open Package.appxmanifest file. From there you can select which capabilites you want your app to support.

    🆘 Manual linking

    Because this package targets React Native 0.63.0+, you probably won't need to link it manually. Otherwise if it's not the case, follow these additional instructions. You also need to manual link the module on Windows when using React Native Windows prior to 0.63:

    👀 See manual linking instructions

    iOS

    Add this line to your ios/Podfile file, then run pod install.

    target 'YourAwesomeProject' do
      #
      pod 'RNPermissions', :path => '../node_modules/react-native-permissions'
    end

    Android

    1. Add the following lines to android/settings.gradle:
    include ':react-native-permissions'
    project(':react-native-permissions').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-permissions/android')
    1. Add the implementation line to the dependencies in android/app/build.gradle:
    dependencies {
      // ...
      implementation project(':react-native-permissions')
    }
    1. Add the import and link the package in MainApplication.java:
    import com.zoontek.rnpermissions.RNPermissionsPackage; // <- add the RNPermissionsPackage import
    
    public class MainApplication extends Application implements ReactApplication {
    
      //
    
      @Override
      protected List<ReactPackage> getPackages() {
        @SuppressWarnings("UnnecessaryLocalVariable")
        List<ReactPackage> packages = new PackageList(this).getPackages();
        //
        packages.add(new RNPermissionsPackage());
        return packages;
      }
    
      //
    }

    Windows

    1. In windows/myapp.sln add the RNCConfig project to your solution:
    • Open the solution in Visual Studio 2019
    • Right-click Solution icon in Solution Explorer > Add > Existing Project
    • Select node_modules\react-native-permissions\windows\RNPermissions\RNPermissions.vcxproj
    1. In windows/myapp/myapp.vcxproj ad a reference to RNPermissions to your main application project. From Visual Studio 2019:
    • Right-click main application project > Add > Reference...
    • Check RNPermissions from Solution Projects.
    1. In pch.h add #include "winrt/RNPermissions.h".

    2. In app.cpp add PackageProviders().Append(winrt::RNPermissions::ReactPackageProvider()); before InitializeComponent();.

    Understanding permission flow

    As permissions are not handled in the same way on iOS and Android, this library provides an abstraction over the two platforms' behaviors. To understand it a little better, take a look to these two flowcharts:

    iOS flow

       ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
       ┃ check(PERMISSIONS.IOS.CAMERA) ┃
       ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                       │
           Is the feature available
               on this device ?
                       │           ╔════╗
                       ├───────────║ NO ║──────────────┐
                       │           ╚════╝              │
                    ╔═════╗                            ▼
                    ║ YES ║                 ┌─────────────────────┐
                    ╚═════╝                 │ RESULTS.UNAVAILABLE │
                       │                    └─────────────────────┘
               Is the permission
                 requestable ?
                       │           ╔════╗
                       ├───────────║ NO ║──────────────┐
                       │           ╚════╝              │
                    ╔═════╗                            ▼
                    ║ YES ║                  ┌───────────────────┐
                    ╚═════╝                  │ RESULTS.BLOCKED / │
                       │                     │ RESULTS.LIMITED / │
                       │                     │  RESULTS.GRANTED  │
                       ▼                     └───────────────────┘
              ┌────────────────┐
              │ RESULTS.DENIED │
              └────────────────┘
                       │
                       ▼
      ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
      ┃ request(PERMISSIONS.IOS.CAMERA) ┃
      ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                       │
             Does the user accept
                the request ?
                       │           ╔════╗
                       ├───────────║ NO ║──────────────┐
                       │           ╚════╝              │
                    ╔═════╗                            ▼
                    ║ YES ║                   ┌─────────────────┐
                    ╚═════╝                   │ RESULTS.BLOCKED │
                       │                      └─────────────────┘
                       ▼
              ┌─────────────────┐
              │ RESULTS.GRANTED │
              └─────────────────┘
    

    Android flow

     ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
     ┃ check(PERMISSIONS.ANDROID.CAMERA) ┃
     ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                       │
           Is the feature available
               on this device ?
                       │           ╔════╗
                       ├───────────║ NO ║──────────────┐
                       │           ╚════╝              │
                    ╔═════╗                            ▼
                    ║ YES ║                 ┌─────────────────────┐
                    ╚═════╝                 │ RESULTS.UNAVAILABLE │
                       │                    └─────────────────────┘
               Is the permission
                 requestable ?
                       │           ╔════╗
                       ├───────────║ NO ║──────────────┐
                       │           ╚════╝              │
                    ╔═════╗                            ▼
                    ║ YES ║                  ┌───────────────────┐
                    ╚═════╝                  │ RESULTS.BLOCKED / │
                       │                     │  RESULTS.GRANTED  │
                       ▼                     └───────────────────┘
              ┌────────────────┐
              │ RESULTS.DENIED │◀──────────────────────┐
              └────────────────┘                       │
                       │                               │
                       ▼                               │
    ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓         ╔════╗
    ┃ request(PERMISSIONS.ANDROID.CAMERA) ┃         ║ NO ║
    ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛         ╚════╝
                       │                               │
             Does the user accept                      │
                the request ?                          │
                       │           ╔════╗     Does the user check
                       ├───────────║ NO ║─────"Never ask again" ?
                       │           ╚════╝              │
                    ╔═════╗                         ╔═════╗
                    ║ YES ║                         ║ YES ║
                    ╚═════╝                         ╚═════╝
                       │                               │
                       ▼                               ▼
              ┌─────────────────┐             ┌─────────────────┐
              │ RESULTS.GRANTED │             │ RESULTS.BLOCKED │
              └─────────────────┘             └─────────────────┘
    

    Windows flow

       ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
       ┃ check(PERMISSIONS.WINDOWS.WEBCAM) ┃
       ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                         │
             Is the feature available
                  on this device ?
                         │           ╔════╗
                         ├───────────║ NO ║──────────────┐
                         │           ╚════╝              │
                      ╔═════╗                            ▼
                      ║ YES ║                 ┌─────────────────────┐
                      ╚═════╝                 │ RESULTS.UNAVAILABLE │
                         │                    └─────────────────────┘
                 Is the permission
                   requestable ?
                         │           ╔════╗
                         ├───────────║ NO ║──────────────┐
                         │           ╚════╝              │
                      ╔═════╗                            ▼
                      ║ YES ║                  ┌───────────────────┐
                      ╚═════╝                  │ RESULTS.BLOCKED / │
                         │                     │  RESULTS.GRANTED  │
                         ▼                     └───────────────────┘
                ┌────────────────┐
                │ RESULTS.DENIED │
                └────────────────┘
                         │
                         ▼
      ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
      ┃ request(PERMISSIONS.WINDOWS.WEBCAM) ┃
      ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
                         │
               Does the user accept
                  the request ?
                         │           ╔════╗
                         ├───────────║ NO ║──────────────┐
                         │           ╚════╝              │
                      ╔═════╗                            ▼
                      ║ YES ║                   ┌─────────────────┐
                      ╚═════╝                   │ RESULTS.BLOCKED │
                         │                      └─────────────────┘
                         ▼
                ┌─────────────────┐
                │ RESULTS.GRANTED │
                └─────────────────┘
    

    API

    Supported permissions

    Android permissions
    import {PERMISSIONS} from 'react-native-permissions';
    
    PERMISSIONS.ANDROID.ACCEPT_HANDOVER;
    PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION;
    PERMISSIONS.ANDROID.ACCESS_COARSE_LOCATION;
    PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION;
    PERMISSIONS.ANDROID.ACTIVITY_RECOGNITION;
    PERMISSIONS.ANDROID.ADD_VOICEMAIL;
    PERMISSIONS.ANDROID.ANSWER_PHONE_CALLS;
    PERMISSIONS.ANDROID.BODY_SENSORS;
    PERMISSIONS.ANDROID.CALL_PHONE;
    PERMISSIONS.ANDROID.CAMERA;
    PERMISSIONS.ANDROID.GET_ACCOUNTS;
    PERMISSIONS.ANDROID.PROCESS_OUTGOING_CALLS;
    PERMISSIONS.ANDROID.READ_CALENDAR;
    PERMISSIONS.ANDROID.READ_CALL_LOG;
    PERMISSIONS.ANDROID.READ_CONTACTS;
    PERMISSIONS.ANDROID.READ_EXTERNAL_STORAGE;
    PERMISSIONS.ANDROID.READ_PHONE_NUMBERS;
    PERMISSIONS.ANDROID.READ_PHONE_STATE;
    PERMISSIONS.ANDROID.READ_SMS;
    PERMISSIONS.ANDROID.RECEIVE_MMS;
    PERMISSIONS.ANDROID.RECEIVE_SMS;
    PERMISSIONS.ANDROID.RECEIVE_WAP_PUSH;
    PERMISSIONS.ANDROID.RECORD_AUDIO;
    PERMISSIONS.ANDROID.SEND_SMS;
    PERMISSIONS.ANDROID.USE_SIP;
    PERMISSIONS.ANDROID.WRITE_CALENDAR;
    PERMISSIONS.ANDROID.WRITE_CALL_LOG;
    PERMISSIONS.ANDROID.WRITE_CONTACTS;
    PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE;
    iOS permissions
    import {PERMISSIONS} from 'react-native-permissions';
    
    PERMISSIONS.IOS.APP_TRACKING_TRANSPARENCY;
    PERMISSIONS.IOS.BLUETOOTH_PERIPHERAL;
    PERMISSIONS.IOS.CALENDARS;
    PERMISSIONS.IOS.CAMERA;
    PERMISSIONS.IOS.CONTACTS;
    PERMISSIONS.IOS.FACE_ID;
    PERMISSIONS.IOS.LOCATION_ALWAYS;
    PERMISSIONS.IOS.LOCATION_WHEN_IN_USE;
    PERMISSIONS.IOS.MEDIA_LIBRARY;
    PERMISSIONS.IOS.MICROPHONE;
    PERMISSIONS.IOS.MOTION;
    PERMISSIONS.IOS.PHOTO_LIBRARY;
    PERMISSIONS.IOS.PHOTO_LIBRARY_ADD_ONLY;
    PERMISSIONS.IOS.REMINDERS;
    PERMISSIONS.IOS.SIRI;
    PERMISSIONS.IOS.SPEECH_RECOGNITION;
    PERMISSIONS.IOS.STOREKIT;
    Windows permissions
    import {PERMISSIONS} from 'react-native-permissions';
    
    PERMISSIONS.WINDOWS.ACCESSORY_MANAGER;
    PERMISSIONS.WINDOWS.ACTIVITY;
    PERMISSIONS.WINDOWS.ALLOW_ELEVATION;
    PERMISSIONS.WINDOWS.ALL_APP_MODS;
    PERMISSIONS.WINDOWS.ALL_JOYN;
    PERMISSIONS.WINDOWS.APPOINTMENTS;
    PERMISSIONS.WINDOWS.APPOINTMENTS_SYSTEM;
    PERMISSIONS.WINDOWS.APP_BROADCAST_SERVICES;
    PERMISSIONS.WINDOWS.APP_CAPTURE_SERVICES;
    PERMISSIONS.WINDOWS.APP_CAPTURE_SETTINGS;
    PERMISSIONS.WINDOWS.APP_DIAGNOSTICS;
    PERMISSIONS.WINDOWS.APP_LICENSING;
    PERMISSIONS.WINDOWS.AUDIO_DEVICE_CONFIGURATION;
    PERMISSIONS.WINDOWS.BACKGROUND_MEDIA_PLAYBACK;
    PERMISSIONS.WINDOWS.BACKGROUND_MEDIA_RECORDING;
    PERMISSIONS.WINDOWS.BACKGROUND_SPATIAL_PERCEPTION;
    PERMISSIONS.WINDOWS.BACKGROUND_VOIP;
    PERMISSIONS.WINDOWS.BLOCKED_CHAT_MESSAGES;
    PERMISSIONS.WINDOWS.BLUETOOTH;
    PERMISSIONS.WINDOWS.BROAD_FILE_SYSTEM_ACCESS;
    PERMISSIONS.WINDOWS.CAMERA_PROCESSING_EXTENSION;
    PERMISSIONS.WINDOWS.CELLULAR_DEVICE_CONTROL;
    PERMISSIONS.WINDOWS.CELLULAR_DEVICE_IDENTITY;
    PERMISSIONS.WINDOWS.CELLULAR_MESSAGING;
    PERMISSIONS.WINDOWS.CHAT_SYSTEM;
    PERMISSIONS.WINDOWS.CODE_GENERATION;
    PERMISSIONS.WINDOWS.CONFIRM_APP_CLOSE;
    PERMISSIONS.WINDOWS.CONTACTS;
    PERMISSIONS.WINDOWS.CONTACTS_SYSTEM;
    PERMISSIONS.WINDOWS.CORTANA_PERMISSIONS;
    PERMISSIONS.WINDOWS.CORTANA_SPEECH_ACCESSORY;
    PERMISSIONS.WINDOWS.CUSTOM_INSTALL_ACTIONS;
    PERMISSIONS.WINDOWS.DEVELOPMENT_MODE_NETWORK;
    PERMISSIONS.WINDOWS.DEVICE_MANAGEMENT_DM_ACCOUNT;
    PERMISSIONS.WINDOWS.DEVICE_MANAGEMENT_EMAIL_ACCOUNT;
    PERMISSIONS.WINDOWS.DEVICE_MANAGEMENT_FOUNDATION;
    PERMISSIONS.WINDOWS.DEVICE_MANAGEMENT_WAP_SECURITY_POLICIES;
    PERMISSIONS.WINDOWS.DEVICE_PORTAL_PROVIDER;
    PERMISSIONS.WINDOWS.DEVICE_UNLOCK;
    PERMISSIONS.WINDOWS.DOCUMENTS_LIBRARY;
    PERMISSIONS.WINDOWS.DUAL_SIM_TILES;
    PERMISSIONS.WINDOWS.EMAIL;
    PERMISSIONS.WINDOWS.EMAIL_SYSTEM;
    PERMISSIONS.WINDOWS.ENTERPRISE_AUTHENTICATION;
    PERMISSIONS.WINDOWS.ENTERPRISE_CLOUD_S_S_O;
    PERMISSIONS.WINDOWS.ENTERPRISE_DATA_POLICY;
    PERMISSIONS.WINDOWS.ENTERPRISE_DEVICE_LOCKDOWN;
    PERMISSIONS.WINDOWS.EXPANDED_RESOURCES;
    PERMISSIONS.WINDOWS.EXTENDED_BACKGROUND_TASK_TIME;
    PERMISSIONS.WINDOWS.EXTENDED_EXECUTION_BACKGROUND_AUDIO;
    PERMISSIONS.WINDOWS.EXTENDED_EXECUTION_CRITICAL;
    PERMISSIONS.WINDOWS.EXTENDED_EXECUTION_UNCONSTRAINED;
    PERMISSIONS.WINDOWS.FIRST_SIGN_IN_SETTINGS;
    PERMISSIONS.WINDOWS.GAME_BAR_SERVICES;
    PERMISSIONS.WINDOWS.GAME_LIST;
    PERMISSIONS.WINDOWS.GAME_MONITOR;
    PERMISSIONS.WINDOWS.GAZE_INPUT;
    PERMISSIONS.WINDOWS.GLOBAL_MEDIA_CONTROL;
    PERMISSIONS.WINDOWS.HUMANINTERFACEDEVICE;
    PERMISSIONS.WINDOWS.INPUT_FOREGROUND_OBSERVATION;
    PERMISSIONS.WINDOWS.INPUT_INJECTION_BROKERED;
    PERMISSIONS.WINDOWS.INPUT_OBSERVATION;
    PERMISSIONS.WINDOWS.INPUT_SUPPRESSION;
    PERMISSIONS.WINDOWS.INTERNET_CLIENT;
    PERMISSIONS.WINDOWS.INTERNET_CLIENT_SERVER;
    PERMISSIONS.WINDOWS.INTEROP_SERVICES;
    PERMISSIONS.WINDOWS.IOT;
    PERMISSIONS.WINDOWS.LOCAL_SYSTEM_SERVICES;
    PERMISSIONS.WINDOWS.LOCATION;
    PERMISSIONS.WINDOWS.LOCATION_HISTORY;
    PERMISSIONS.WINDOWS.LOCATION_SYSTEM;
    PERMISSIONS.WINDOWS.LOW_LEVEL;
    PERMISSIONS.WINDOWS.LOW_LEVEL_DEVICES;
    PERMISSIONS.WINDOWS.MICROPHONE;
    PERMISSIONS.WINDOWS.MOBILE;
    PERMISSIONS.WINDOWS.MODIFIABLE_APP;
    PERMISSIONS.WINDOWS.MUSIC_LIBRARY;
    PERMISSIONS.WINDOWS.NETWORKING_VPN_PROVIDER;
    PERMISSIONS.WINDOWS.NETWORK_CONNECTION_MANAGER_PROVISIONING;
    PERMISSIONS.WINDOWS.NETWORK_DATA_PLAN_PROVISIONING;
    PERMISSIONS.WINDOWS.NETWORK_DATA_USAGE_MANAGEMENT;
    PERMISSIONS.WINDOWS.OEM_DEPLOYMENT;
    PERMISSIONS.WINDOWS.OEM_PUBLIC_DIRECTORY;
    PERMISSIONS.WINDOWS.ONE_PROCESS_VOIP;
    PERMISSIONS.WINDOWS.OPTICAL;
    PERMISSIONS.WINDOWS.PACKAGED_SERVICES;
    PERMISSIONS.WINDOWS.PACKAGES_SERVICES;
    PERMISSIONS.WINDOWS.PACKAGE_MANAGEMENT;
    PERMISSIONS.WINDOWS.PACKAGE_POLICY_SYSTEM;
    PERMISSIONS.WINDOWS.PACKAGE_QUERY;
    PERMISSIONS.WINDOWS.PACKAGE_WRITE_REDIRECTION_COMPATIBILITY_SHIM;
    PERMISSIONS.WINDOWS.PHONE_CALL;
    PERMISSIONS.WINDOWS.PHONE_CALL_HISTORY;
    PERMISSIONS.WINDOWS.PHONE_CALL_HISTORY_SYSTEM;
    PERMISSIONS.WINDOWS.PHONE_LINE_TRANSPORT_MANAGEMENT;
    PERMISSIONS.WINDOWS.PICTURES_LIBRARY;
    PERMISSIONS.WINDOWS.POINT_OF_SERVICE;
    PERMISSIONS.WINDOWS.PREVIEW_INK_WORKSPACE;
    PERMISSIONS.WINDOWS.PREVIEW_PEN_WORKSPACE;
    PERMISSIONS.WINDOWS.PREVIEW_STORE;
    PERMISSIONS.WINDOWS.PREVIEW_UI_COMPOSITION;
    PERMISSIONS.WINDOWS.PRIVATE_NETWORK_CLIENT_SERVER;
    PERMISSIONS.WINDOWS.PROTECTED_APP;
    PERMISSIONS.WINDOWS.PROXIMITY;
    PERMISSIONS.WINDOWS.RADIOS;
    PERMISSIONS.WINDOWS.RECORDED_CALLS_FOLDER;
    PERMISSIONS.WINDOWS.REMOTE_PASSPORT_AUTHENTICATION;
    PERMISSIONS.WINDOWS.REMOTE_SYSTEM;
    PERMISSIONS.WINDOWS.REMOVABLE_STORAGE;
    PERMISSIONS.WINDOWS.RESCAP;
    PERMISSIONS.WINDOWS.RUN_FULL_TRUST;
    PERMISSIONS.WINDOWS.SCREEN_DUPLICATION;
    PERMISSIONS.WINDOWS.SECONDARY_AUTHENTICATION_FACTOR;
    PERMISSIONS.WINDOWS.SECURE_ASSESSMENT;
    PERMISSIONS.WINDOWS.SERIALCOMMUNICATION;
    PERMISSIONS.WINDOWS.SHARED_USER_CERTIFICATES;
    PERMISSIONS.WINDOWS.SLAPI_QUERY_LICENSE_VALUE;
    PERMISSIONS.WINDOWS.SMBIOS;
    PERMISSIONS.WINDOWS.SMS_SEND;
    PERMISSIONS.WINDOWS.SPATIAL_PERCEPTION;
    PERMISSIONS.WINDOWS.START_SCREEN_MANAGEMENT;
    PERMISSIONS.WINDOWS.STORE_LICENSE_MANAGEMENT;
    PERMISSIONS.WINDOWS.SYSTEM_MANAGEMENT;
    PERMISSIONS.WINDOWS.TARGETED_CONTENT;
    PERMISSIONS.WINDOWS.TEAM_EDITION_DEVICE_CREDENTIAL;
    PERMISSIONS.WINDOWS.TEAM_EDITION_EXPERIENCE;
    PERMISSIONS.WINDOWS.TEAM_EDITION_VIEW;
    PERMISSIONS.WINDOWS.UAP;
    PERMISSIONS.WINDOWS.UI_AUTOMATION;
    PERMISSIONS.WINDOWS.UNVIRTUALIZED_RESOURCES;
    PERMISSIONS.WINDOWS.USB;
    PERMISSIONS.WINDOWS.USER_ACCOUNT_INFORMATION;
    PERMISSIONS.WINDOWS.USER_DATA_ACCOUNTS_PROVIDER;
    PERMISSIONS.WINDOWS.USER_DATA_SYSTEM;
    PERMISSIONS.WINDOWS.USER_PRINCIPAL_NAME;
    PERMISSIONS.WINDOWS.USER_SYSTEM_ID;
    PERMISSIONS.WINDOWS.VIDEOS_LIBRARY;
    PERMISSIONS.WINDOWS.VOIP_CALL;
    PERMISSIONS.WINDOWS.WALLET_SYSTEM;
    PERMISSIONS.WINDOWS.WEBCAM;
    PERMISSIONS.WINDOWS.WIFI_CONTROL;
    PERMISSIONS.WINDOWS.XBOX_ACCESSORY_MANAGEMENT;

    Permissions statuses

    Permission checks and requests resolve into one of these statuses:

    Return value Notes
    RESULTS.UNAVAILABLE This feature is not available (on this device / in this context)
    RESULTS.DENIED The permission has not been requested / is denied but requestable
    RESULTS.GRANTED The permission is granted
    RESULTS.LIMITED The permission is granted but with limitations
    RESULTS.BLOCKED The permission is denied and not requestable anymore

    Methods

    // type used in usage examples
    type PermissionStatus = 'unavailable' | 'denied' | 'limited' | 'granted' | 'blocked';

    check

    Check one permission status.

    function check(permission: string): Promise<PermissionStatus>;
    import {check, PERMISSIONS, RESULTS} from 'react-native-permissions';
    
    check(PERMISSIONS.IOS.LOCATION_ALWAYS)
      .then((result) => {
        switch (result) {
          case RESULTS.UNAVAILABLE:
            console.log('This feature is not available (on this device / in this context)');
            break;
          case RESULTS.DENIED:
            console.log('The permission has not been requested / is denied but requestable');
            break;
          case RESULTS.LIMITED:
            console.log('The permission is limited: some actions are possible');
            break;
          case RESULTS.GRANTED:
            console.log('The permission is granted');
            break;
          case RESULTS.BLOCKED:
            console.log('The permission is denied and not requestable anymore');
            break;
        }
      })
      .catch((error) => {
        // …
      });

    request

    Request one permission.

    type Rationale = {
      title: string;
      message: string;
      buttonPositive?: string;
      buttonNegative?: string;
      buttonNeutral?: string;
    };
    
    function request(permission: string, rationale?: Rationale): Promise<PermissionStatus>;
    import {request, PERMISSIONS} from 'react-native-permissions';
    
    request(PERMISSIONS.IOS.LOCATION_ALWAYS).then((result) => {
      // …
    });

    checkNotifications

    Check notifications permission status and get notifications settings values.

    type NotificationSettings = {
      // properties only available on iOS
      // unavailable settings will not be included in the response object
      alert?: boolean;
      badge?: boolean;
      sound?: boolean;
      carPlay?: boolean;
      criticalAlert?: boolean;
      provisional?: boolean;
      lockScreen?: boolean;
      notificationCenter?: boolean;
    };
    
    function checkNotifications(): Promise<{
      status: PermissionStatus;
      settings: NotificationSettings;
    }>;
    import {checkNotifications} from 'react-native-permissions';
    
    checkNotifications().then(({status, settings}) => {
      // …
    });

    requestNotifications

    Request notifications permission status and get notifications settings values.

    You cannot request notifications permissions on Windows. Disabling or enabling notifications can only be done through the App Settings.
    You cannot request notifications permissions on Android. requestNotifications is the same than checkNotifications on this platform.

    // only used on iOS
    type NotificationOption = 'alert' | 'badge' | 'sound' | 'criticalAlert' | 'carPlay' | 'provisional';
    
    type NotificationSettings = {
      // properties only available on iOS
      // unavailable settings will not be included in the response object
      alert?: boolean;
      badge?: boolean;
      sound?: boolean;
      carPlay?: boolean;
      criticalAlert?: boolean;
      provisional?: boolean;
      lockScreen?: boolean;
      notificationCenter?: boolean;
    };
    
    function requestNotifications(options: NotificationOption[]): Promise<{
      status: PermissionStatus;
      settings: NotificationSettings;
    }>;
    import {requestNotifications} from 'react-native-permissions';
    
    requestNotifications(['alert', 'sound']).then(({status, settings}) => {
      // …
    });

    checkMultiple

    Check multiples permissions in parallel.

    function checkMultiple<P extends Permission[]>(
      permissions: P,
    ): Promise<Record<P[number], PermissionStatus>>;
    import {checkMultiple, PERMISSIONS} from 'react-native-permissions';
    
    checkMultiple([PERMISSIONS.IOS.CAMERA, PERMISSIONS.IOS.FACE_ID]).then((statuses) => {
      console.log('Camera', statuses[PERMISSIONS.IOS.CAMERA]);
      console.log('FaceID', statuses[PERMISSIONS.IOS.FACE_ID]);
    });

    requestMultiple

    Request multiple permissions in sequence.

    function requestMultiple<P extends Permission[]>(
      permissions: P,
    ): Promise<Record<P[number], PermissionStatus>>;
    import {requestMultiple, PERMISSIONS} from 'react-native-permissions';
    
    requestMultiple([PERMISSIONS.IOS.CAMERA, PERMISSIONS.IOS.FACE_ID]).then((statuses) => {
      console.log('Camera', statuses[PERMISSIONS.IOS.CAMERA]);
      console.log('FaceID', statuses[PERMISSIONS.IOS.FACE_ID]);
    });

    openSettings

    Open application settings.

    function openSettings(): Promise<void>;
    import {openSettings} from 'react-native-permissions';
    
    openSettings().catch(() => console.warn('cannot open settings'));

    openLimitedPhotoLibraryPicker (iOS 14+)

    Open a picker to update the photo selection when PhotoLibrary permission is limited. This will reject if unsupported or if full permission is already granted.

    function openLimitedPhotoLibraryPicker(): Promise<void>;
    import {openLimitedPhotoLibraryPicker} from 'react-native-permissions';
    
    openLimitedPhotoLibraryPicker().catch(() => {
      console.warn('Cannot open photo library picker');
    });

    checkLocationAccuracy (iOS 14+)

    When LocationAlways or LocationWhenInUse is granted, allow checking if the user share his precise location.

    type LocationAccuracy = 'full' | 'reduced';
    
    function checkLocationAccuracy(): Promise<LocationAccuracy>;
    import {checkLocationAccuracy} from 'react-native-permissions';
    
    checkLocationAccuracy()
      .then((accuracy) => console.log(`Location accuracy is: ${accuracy}`))
      .catch(() => console.warn('Cannot check location accuracy'));

    requestLocationAccuracy (iOS 14+)

    When LocationAlways or LocationWhenInUse is granted, allow requesting the user for his precise location. Will resolve immediately if full accuracy is already authorized.

    type LocationAccuracyOptions = {
      purposeKey: string;
    };
    
    type LocationAccuracy = 'full' | 'reduced';
    
    function requestLocationAccuracy(options: LocationAccuracyOptions): Promise<LocationAccuracy>;
    import {requestLocationAccuracy} from 'react-native-permissions';
    
    requestLocationAccuracy({purposeKey: 'YOUR-PURPOSE-KEY'})
      .then((accuracy) => console.log(`Location accuracy is: ${accuracy}`))
      .catch(() => console.warn('Cannot request location accuracy'));

    About iOS LOCATION_ALWAYS permission

    If you are requesting PERMISSIONS.IOS.LOCATION_ALWAYS, there won't be a Always Allow button in the system dialog. Only Allow Once, Allow While Using App and Don't Allow. This is expected behaviour, check the Apple Developer Docs.

    When requesting PERMISSIONS.IOS.LOCATION_ALWAYS, if the user choose Allow While Using App, a provisional "always" status will be granted. The user will see While Using in the settings and later will be informed that your app is using the location in background. That looks like this:

    alt text

    Subsequently, if you are requesting LOCATION_ALWAYS permission, there is no need to request LOCATION_WHEN_IN_USE. If the user accepts, LOCATION_WHEN_IN_USE will be granted too. If the user denies, LOCATION_WHEN_IN_USE will be denied too.

    Testing with Jest

    If you don't already have a Jest setup file configured, please add the following to your Jest configuration file and create the new jest.setup.js file in project root:

    setupFiles: ['<rootDir>/jest.setup.js'];

    You can then add the following line to that setup file to mock the NativeModule.RNPermissions:

    jest.mock('react-native-permissions', () => require('react-native-permissions/mock'));

    Install

    npm i react-native-permissions

    DownloadsWeekly Downloads

    140,255

    Version

    3.0.5

    License

    MIT

    Unpacked Size

    484 kB

    Total Files

    172

    Last publish

    Collaborators

    • avatar