React Native Permissions

https://github.com/zoontek/react-native-permissions
Admin
An unified permissions API for React Native on iOS, Android and Windows platforms.
Tokens:36,862
Snippets:416
Trust Score:9.5
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Configure iOS Podfile

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Include the setup script and define required permissions in your Podfile.

```ruby
node_require('react-native-permissions/scripts/setup.rb')
```

```ruby
setup_permissions([
  'Camera',
  'Microphone',
  'Contacts',
])
```

--------------------------------

### Configure Jest setup file

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Add this configuration to your Jest setup file to include the necessary setup script.

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

--------------------------------

### Install react-native-permissions

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Use npm or yarn to add the library to your project dependencies.

```bash
npm install react-native-permissions
# or
yarn add react-native-permissions
```

--------------------------------

### Provide notification settings shortcut

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

This example demonstrates attempting to open notification settings directly, with a fallback to the main application settings.

```typescript
import {openSettings} from 'react-native-permissions';

const promptNotificationSettings = async () => {
  alert(
    'Enable Notifications',
    'Would you like to enable notifications?',
    [
      {
        text: 'Open Settings',
        onPress: async () => {
          try {
            await openSettings('notifications');
          } catch (error) {
            await openSettings('application');
          }
        }
      },
      {text: 'Later', onPress: () => {}},
    ]
  );
};
```

--------------------------------

### Usage of RationaleObject

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/types.md

Example implementation of a RationaleObject configuration.

```typescript
const rationale: RationaleObject = {
  title: 'Camera Permission',
  message: 'We need access to your camera to take photos',
  buttonPositive: 'Grant',
  buttonNegative: 'Deny',
};
```

--------------------------------

### Handle user's choice

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/requestLocationAccuracy.md

Example showing how to trigger different application behaviors based on the user's accuracy selection.

```typescript
import {requestLocationAccuracy, openSettings} from 'react-native-permissions';

const requestAccuracyAndRespond = async () => {
  try {
    const accuracy = await requestLocationAccuracy({
      purposeKey: 'realtime_tracking',
    });
    
    if (accuracy === 'full') {
      console.log('Full location accuracy enabled');
      startPreciseTracking();
    } else {
      console.log('User chose to keep approximate location');
      startApproximateTracking();
      
      // Optionally inform user about limitations
      alert('Some features work better with precise location');
    }
  } catch (error) {
    console.log('Feature not available on this device');
    startApproximateTracking();
  }
};
```

--------------------------------

### Check permissions by platform

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/constants.md

Example of checking permissions using the PERMISSIONS constant.

```typescript
import {check, PERMISSIONS, RESULTS} from 'react-native-permissions';

// Android example
const cameraStatus = await check(PERMISSIONS.ANDROID.CAMERA);

// iOS example
const contactsStatus = await check(PERMISSIONS.IOS.CONTACTS);

// Windows example
const locationStatus = await check(PERMISSIONS.WINDOWS.LOCATION);
```

--------------------------------

### Photo selection flow

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openPhotoPicker.md

Example showing the conceptual flow of requesting permissions before opening the picker.

```typescript
import {openPhotoPicker} from 'react-native-permissions';

const userSelectPhoto = async () => {
  try {
    // Request photo library permission first if needed
    // const status = await request(PERMISSIONS.IOS.PHOTO_LIBRARY);
    
    // Open the native photo picker
    await openPhotoPicker();
    
    // The selected photo is handled by native code
    // You would need to bridge back to React Native through native modules
    // or use react-native-image-picker as an alternative
  } catch (error) {
    console.error('Photo selection failed:', error);
  }
};
```

--------------------------------

### Guide user to enable a blocked camera permission

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Use this pattern to prompt users to open settings when a permission request returns a BLOCKED status.

```typescript
import {request, openSettings, PERMISSIONS, RESULTS} from 'react-native-permissions';

const enableCameraFeature = async () => {
  const status = await request(PERMISSIONS.ANDROID.CAMERA);
  
  if (status === RESULTS.BLOCKED) {
    alert(
      'Camera Access Required',
      'This feature requires camera permission. Please enable it in app settings.',
      [
        {text: 'Open Settings', onPress: () => openSettings('application')},
        {text: 'Cancel', onPress: () => {}},
      ]
    );
  }
};
```

--------------------------------

### Configure Expo app.json

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/constants.md

Example configuration for the react-native-permissions plugin inside an Expo app.json file.

```json
{
  "plugins": [
    [
      "react-native-permissions",
      {
        "iosPermissions": [
          "Camera",
          "Microphone",
          "Contacts"
        ]
      }
    ]
  ]
}
```

--------------------------------

### Handle permission status

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/constants.md

Example of using the RESULTS constant to handle different permission states.

```typescript
import {RESULTS} from 'react-native-permissions';

const handlePermissionStatus = (status) => {
  if (status === RESULTS.GRANTED) {
    // Proceed with feature
  } else if (status === RESULTS.BLOCKED) {
    // Open settings for user to enable
  } else if (status === RESULTS.DENIED) {
    // Can request again
  }
};
```

--------------------------------

### Guide user through blocked permission recovery

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Checks for blocked permissions and provides a fallback message if the settings page cannot be opened automatically.

```typescript
import {check, openSettings, PERMISSIONS, RESULTS} from 'react-native-permissions';

const handleBlockedPermission = async (permission) => {
  const status = await check(permission);
  
  if (status === RESULTS.BLOCKED) {
    console.log('Permission is blocked. User must enable in settings.');
    console.log('Opening app settings...');
    
    try {
      await openSettings('application');
    } catch (error) {
      console.log('Could not open settings automatically');
      console.log('Please enable this permission in Settings > [App Name] > Permissions');
    }
  }
};
```

--------------------------------

### openSettings()

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Opens the application settings screen. This function returns a Promise that resolves immediately after the settings app is launched.

```APIDOC
## openSettings()

### Description
Opens the application settings screen to allow users to manage permissions manually. Note that the promise resolves immediately upon launching the settings app, not when the user returns to the application.

### Signature
`openSettings(): Promise<void>`

### Parameters
- **type** (string) - Optional - The type of settings to open (defaults to 'application').

### Usage Example
```typescript
import {openSettings} from 'react-native-permissions';

const handleOpenSettings = async () => {
  try {
    await openSettings();
  } catch (error) {
    console.error(error);
  }
};
```
```

--------------------------------

### openSettings()

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/INDEX.md

Opens the application settings screen to allow users to manually enable permissions.

```APIDOC
## openSettings()

### Description
Directs the user to the application settings page.
```

--------------------------------

### Open main application settings

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Navigates the user to the main settings page for the current application.

```typescript
import {openSettings} from 'react-native-permissions';

const openAppSettings = async () => {
  try {
    await openSettings('application');
  } catch (error) {
    console.log('Could not open settings:', error);
  }
};
```

--------------------------------

### openSettings(type?)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Opens the system settings application to allow the user to manage permissions.

```APIDOC
## openSettings(type?)

### Description
Opens the system settings application to allow the user to manage permissions.

### Parameters
- **type** (string) - Optional - The specific settings page type to open.
```

--------------------------------

### Configure iOS Info.plist

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Add usage description keys to your Info.plist file to explain permission requirements.

```xml
<key>NSCameraUsageDescription</key>
<string>We need access to your camera</string>
```

--------------------------------

### openSettings(type?: 'application' | 'alarms' | 'fullscreen' | 'notifications'): Promise<void>

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Opens the device's system settings application. The optional 'type' parameter allows specifying a sub-page, though platform support for these types varies.

```APIDOC
## openSettings(type?: 'application' | 'alarms' | 'fullscreen' | 'notifications'): Promise<void>

### Description
Opens the device's system settings application, optionally to a specific permission settings page.

### Parameters
- **type** (string) - Optional - Default: 'application'. The type of settings page to open. Valid values: 'application', 'alarms', 'fullscreen', 'notifications'.

### Return Type
- **Promise<void>** - Resolves when the system settings app is successfully launched.

### Errors
- **Promise.reject** - Called on platforms without settings support (unsupported build).
- **Error** - Native module fails to open settings.

### Example
```typescript
import {openSettings} from 'react-native-permissions';

const openAppSettings = async () => {
  try {
    await openSettings('application');
  } catch (error) {
    console.log('Could not open settings:', error);
  }
};
```
```

--------------------------------

### openSettings

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Opens the application, alarms, notifications, or fullscreen settings. Defaults to application settings.

```APIDOC
## openSettings(type?: 'application' | 'alarms' | 'fullscreen' | 'notifications')

### Description
Opens the system settings page for the application or specific features like alarms, notifications, or fullscreen intent. Note that specific settings are only available on certain Android and iOS versions.

### Parameters
- **type** (string) - Optional - The specific settings page to open. Defaults to 'application'.
```

--------------------------------

### Import Main Module

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Import core permission methods and constants from the main module.

```typescript
import {
  check,
  request,
  checkMultiple,
  requestMultiple,
  checkNotifications,
  requestNotifications,
  openSettings,
  checkLocationAccuracy,
  requestLocationAccuracy,
  openPhotoPicker,
  openContactPicker,
  canScheduleExactAlarms,
  canUseFullScreenIntent,
  PERMISSIONS,
  RESULTS,
} from 'react-native-permissions';
```

--------------------------------

### Request permission and open picker

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openPhotoPicker.md

Workflow for verifying photo library permissions before attempting to open the picker.

```typescript
import {request, PERMISSIONS, RESULTS} from 'react-native-permissions';

const requestPhotoLibraryAndOpen = async () => {
  // Ensure permission is granted
  const status = await request(PERMISSIONS.IOS.PHOTO_LIBRARY);
  
  if (status !== RESULTS.GRANTED) {
    console.log('Photo library permission not granted');
    return;
  }
  
  // Open picker
  try {
    await openPhotoPicker();
  } catch (error) {
    console.log('Could not open photo picker');
  }
};
```

--------------------------------

### Documentation Output Directory Structure

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/_COMPLETION_REPORT.md

The file structure generated for the react-native-permissions documentation project.

```text
output/
├── INDEX.md                    # Navigation guide
├── README.md                   # Project overview
├── SUMMARY.txt                 # Generation summary
├── types.md                    # Type definitions
├── constants.md                # Constants reference
├── platform-matrix.md          # Compatibility matrix
├── errors-and-edge-cases.md   # Error handling
└── api-reference/              # Method documentation
    ├── check.md
    ├── request.md
    ├── checkMultiple.md
    ├── requestMultiple.md
    ├── checkNotifications.md
    ├── requestNotifications.md
    ├── openSettings.md
    ├── checkLocationAccuracy.md
    ├── requestLocationAccuracy.md
    ├── openPhotoPicker.md
    ├── openContactPicker.md
    ├── canScheduleExactAlarms.md
    └── canUseFullScreenIntent.md
```

--------------------------------

### Register Android Package

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Import and add the RNPermissionsPackage to your MainApplication class.

```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;
  }

  // …
}
```

--------------------------------

### Handle all permission outcomes

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/request.md

Demonstrates handling all possible permission states including granted, denied, blocked, and unavailable.

```typescript
import {request, PERMISSIONS, RESULTS} from 'react-native-permissions';

const requestAndHandle = async () => {
  const status = await request(PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION, {
    title: 'Location Permission',
    message: 'This app needs access to your location',
    buttonPositive: 'Grant',
    buttonNegative: 'Deny',
  });
  
  switch (status) {
    case RESULTS.GRANTED:
      console.log('Location permission granted');
      break;
    case RESULTS.DENIED:
      console.log('User denied, can ask again later');
      break;
    case RESULTS.BLOCKED:
      console.log('Permission blocked, user must enable in settings');
      break;
    case RESULTS.UNAVAILABLE:
      console.log('Location not available on this device');
      break;
  }
};
```

--------------------------------

### Open with error handling

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openPhotoPicker.md

Implementation demonstrating how to catch and handle specific errors, such as the iOS version requirement.

```typescript
import {openPhotoPicker} from 'react-native-permissions';

const selectPhotoSafely = async () => {
  try {
    await openPhotoPicker();
  } catch (error) {
    if (error.message.includes('iOS 14')) {
      console.log('Photo picker requires iOS 14 or later');
    } else {
      console.log('Could not open photo picker:', error.message);
    }
  }
};
```

--------------------------------

### Context-aware settings opening

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Dynamically selects the settings page type based on the provided context string.

```typescript
import {openSettings} from 'react-native-permissions';

const openContextSettings = async (context: 'notifications' | 'location' | 'camera') => {
  try {
    switch (context) {
      case 'notifications':
        await openSettings('notifications');
        break;
      case 'location':
      case 'camera':
      default:
        await openSettings('application');
        break;
    }
  } catch (error) {
    console.log('Could not open settings');
  }
};
```

--------------------------------

### request(permission: Permission, rationale?: Rationale)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/request.md

Requests a specific permission from the user. Optionally displays a rationale before the system prompt.

```APIDOC
## request(permission: Permission, rationale?: Rationale)

### Description
Requests a specific permission from the user if not already granted. Optionally displays a rationale before the system prompt.

### Parameters
- **permission** (Permission) - Required - The specific permission to request.
- **rationale** (Rationale) - Optional - Optional rationale to show before requesting. Can be a RationaleObject or async function returning boolean.

### Return Type
Promise<PermissionStatus>

### Return Values
- 'unavailable': Permission is not available
- 'blocked': User denied and selected "don't ask again"
- 'denied': User denied the request
- 'granted': User approved the permission
- 'limited': Permission granted with limitations (iOS only)

### Rationale Types
- **RationaleObject**: { title: string, message: string, buttonPositive: string, buttonNegative?: string }
- **Function**: () => Promise<boolean> (Return true to proceed, false to cancel)
```

--------------------------------

### Configure Android Manifest

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Declare necessary permissions in the AndroidManifest.xml file.

```xml
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.RECORD_AUDIO" />
```

--------------------------------

### Request with all available options

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/requestNotifications.md

Requests permission for the full suite of available notification options.

```typescript
import {requestNotifications} from 'react-native-permissions';

const requestAllNotifications = async () => {
  const {status, settings} = await requestNotifications([
    'alert',
    'badge',
    'sound',
    'carPlay',
    'criticalAlert',
    'provisional',
    'providesAppSettings',
  ]);
  
  return {status, settings};
};
```

--------------------------------

### request(permission, rationale?)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Requests a single permission from the user, optionally providing a rationale for Android.

```APIDOC
## request(permission, rationale?)

### Description
Requests a single permission from the user, optionally providing a rationale for Android.

### Parameters
- **permission** (string) - Required - The permission identifier to request.
- **rationale** (object) - Optional - Rationale configuration for Android permission requests.
```

--------------------------------

### Check multiple different permissions sequentially

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/check.md

Shows how to perform multiple sequential permission checks and return the combined results.

```typescript
import {check, PERMISSIONS} from 'react-native-permissions';

const checkDevicePermissions = async () => {
  const cameraStatus = await check(PERMISSIONS.IOS.CAMERA);
  const micStatus = await check(PERMISSIONS.IOS.MICROPHONE);
  
  return {camera: cameraStatus, microphone: micStatus};
};
```

--------------------------------

### Access Windows Permissions

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

List of available Windows permission constants provided by the library.

```javascript
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;
```

--------------------------------

### Basic permission check

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/check.md

Demonstrates how to check the status of a single permission and log the result.

```typescript
import {check, PERMISSIONS} from 'react-native-permissions';

const checkCameraPermission = async () => {
  const status = await check(PERMISSIONS.IOS.CAMERA);
  console.log('Camera permission status:', status);
};
```

--------------------------------

### Open System Settings

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Opens specific application, alarm, notification, or fullscreen settings. Fallbacks to application settings if the requested type is unavailable.

```ts
function openSettings(
  type?: 'application' | 'alarms' | 'fullscreen' | 'notifications',
): Promise<void>;
```

```ts
import {openSettings} from 'react-native-permissions';

openSettings('application').catch(() => console.warn('Cannot open app settings'));
```

--------------------------------

### openSettings(type)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Opens the application settings page. On Android, specific settings pages can be targeted using the type parameter.

```APIDOC
## openSettings(type)

### Description
Opens the device settings page for the application. On Android, it supports deep-linking to specific permission categories.

### Parameters
- **type** (string) - Optional - The specific settings page to open. 
  - 'application': Opens the app's main settings page (Default).
  - 'alarms': Opens Schedule Exact Alarms settings (Android 12+).
  - 'fullscreen': Opens Use Full Screen Intent settings (Android 14+).
  - 'notifications': Opens notification settings.

### Usage
```typescript
import { openSettings } from 'react-native-permissions';

// Open main app settings
await openSettings('application');

// Open notification settings
await openSettings('notifications');
```
```

--------------------------------

### Basic multiple permission check

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/checkMultiple.md

Demonstrates checking the status of several iOS permissions and logging the resulting object.

```typescript
import {checkMultiple, PERMISSIONS, RESULTS} from 'react-native-permissions';

const checkMultipleIOS = async () => {
  const statuses = await checkMultiple([
    PERMISSIONS.IOS.CAMERA,
    PERMISSIONS.IOS.MICROPHONE,
    PERMISSIONS.IOS.CONTACTS,
  ]);
  
  console.log(statuses);
  // {
  //   'ios.permission.CAMERA': 'granted',
  //   'ios.permission.MICROPHONE': 'denied',
  //   'ios.permission.CONTACTS': 'unavailable'
  // }
};
```

--------------------------------

### Import Mock Module

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Import the mock module for testing purposes.

```typescript
import {
  check,
  request,
  // ... all methods ...
  PERMISSIONS,
  RESULTS,
} from 'react-native-permissions/mock';
```

--------------------------------

### Configure Android settings.gradle

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Include the react-native-permissions project in your Android settings file.

```gradle
include ':react-native-permissions'
project(':react-native-permissions').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-permissions/android')
```

--------------------------------

### Define and use Rationale types

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/types.md

Shows how to define static or dynamic Rationale objects for Android permission requests.

```typescript
import type {Rationale} from 'react-native-permissions';
import {request, PERMISSIONS} from 'react-native-permissions';

const staticRationale: Rationale = {
  title: 'Camera Access',
  message: 'Please allow camera access',
  buttonPositive: 'Allow',
};

const dynamicRationale: Rationale = async () => {
  // Async logic to decide whether to show request
  const userNeedsFeature = await checkFeatureRequirement();
  return userNeedsFeature;
};

await request(PERMISSIONS.ANDROID.CAMERA, staticRationale);
```

--------------------------------

### Open photo picker

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openPhotoPicker.md

Basic implementation for invoking the photo picker and handling the promise resolution.

```typescript
import {openPhotoPicker} from 'react-native-permissions';

const pickPhoto = async () => {
  try {
    await openPhotoPicker();
    console.log('Photo picker closed');
    // Photo selection is handled by native system
  } catch (error) {
    console.log('Photo picker not available:', error.message);
  }
};
```

--------------------------------

### Request with Settings Fallback

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/errors-and-edge-cases.md

Automatically opens application settings if a permission request returns a BLOCKED status.

```typescript
const requestWithFallback = async (permission: Permission) => {
  const status = await request(permission);
  
  if (status === RESULTS.BLOCKED) {
    try {
      await openSettings('application');
    } catch (error) {
      console.log('Could not open settings');
    }
  }
  
  return status;
};
```

--------------------------------

### Request Multiple Permissions

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Request multiple permissions in sequence.

```ts
function requestMultiple<P extends Permission[]>(
  permissions: P,
): Promise<Record<P[number], PermissionStatus>>;
```

```ts
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]);
});
```

--------------------------------

### Request permission with rationale

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/request.md

Provides a rationale object to explain the permission request to the user on Android.

```typescript
import {request, PERMISSIONS, RESULTS} from 'react-native-permissions';

const requestCameraWithRationale = async () => {
  const status = await request(PERMISSIONS.ANDROID.CAMERA, {
    title: 'Camera Permission',
    message: 'We need access to your camera to take photos',
    buttonPositive: 'Allow',
    buttonNegative: 'Deny',
  });
  
  return status === RESULTS.GRANTED;
};
```

--------------------------------

### Open contact picker

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openContactPicker.md

Basic implementation of the contact picker with a standard try-catch block.

```typescript
import {openContactPicker} from 'react-native-permissions';

const pickContact = async () => {
  try {
    await openContactPicker();
    console.log('Contact picker closed');
  } catch (error) {
    console.log('Contact picker not available:', error.message);
  }
};
```

--------------------------------

### Access iOS Permissions

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

List of available iOS permission constants provided by the library.

```javascript
import {PERMISSIONS} from 'react-native-permissions';

PERMISSIONS.IOS.APP_TRACKING_TRANSPARENCY;
PERMISSIONS.IOS.BLUETOOTH;
PERMISSIONS.IOS.CALENDARS;
PERMISSIONS.IOS.CALENDARS_WRITE_ONLY;
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;
```

--------------------------------

### Multi-permission recovery flow

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Use this approach to check multiple permissions and redirect the user to settings if any are found to be blocked.

```typescript
import {checkMultiple, openSettings, PERMISSIONS, RESULTS} from 'react-native-permissions';

const checkAndRecoverPermissions = async () => {
  const permissions = [
    PERMISSIONS.ANDROID.CAMERA,
    PERMISSIONS.ANDROID.RECORD_AUDIO,
  ];
  
  const statuses = await checkMultiple(permissions);
  
  const blocked = Object.entries(statuses)
    .filter(([_, status]) => status === RESULTS.BLOCKED)
    .map(([permission]) => permission);
  
  if (blocked.length > 0) {
    console.log('The following permissions are blocked:', blocked);
    console.log('Opening app settings to enable them...');
    await openSettings('application');
  }
};
```

--------------------------------

### Request Multiple Permissions

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Request several permissions simultaneously and verify that all were granted.

```typescript
import {requestMultiple, PERMISSIONS, RESULTS} from 'react-native-permissions';

const requestMediaPermissions = async () => {
  const statuses = await requestMultiple([
    PERMISSIONS.IOS.CAMERA,
    PERMISSIONS.IOS.MICROPHONE,
    PERMISSIONS.IOS.PHOTO_LIBRARY,
  ]);
  
  return Object.values(statuses).every(s => s === RESULTS.GRANTED);
};
```

--------------------------------

### request(permission, rationale?)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/request.md

Requests a specific permission from the user. Optionally accepts a rationale object (Android) or an async function to determine if the request should proceed.

```APIDOC
## request(permission, rationale?)

### Description
Requests a specific permission from the user. Returns a promise that resolves to the permission status (GRANTED, DENIED, BLOCKED, or UNAVAILABLE).

### Parameters
- **permission** (string) - Required - The permission constant to request (e.g., PERMISSIONS.IOS.CAMERA).
- **rationale** (object|function) - Optional - An object containing title, message, buttonPositive, and buttonNegative for Android, or an async function that returns a boolean to decide if the request should be shown.

### Usage Example
```typescript
import {request, PERMISSIONS, RESULTS} from 'react-native-permissions';

const status = await request(PERMISSIONS.IOS.CAMERA);
if (status === RESULTS.GRANTED) {
  // Access granted
}
```
```

--------------------------------

### Open notification settings

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Directs the user specifically to the notification configuration page for the app.

```typescript
import {openSettings} from 'react-native-permissions';

const openNotificationSettings = async () => {
  try {
    await openSettings('notifications');
  } catch (error) {
    console.log('Could not open notification settings');
  }
};
```

--------------------------------

### Mock react-native-permissions in Jest

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Add this line to your jest.setup.js file to mock the NativeModule.RNPermissions.

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

--------------------------------

### openPhotoPicker()

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openPhotoPicker.md

Opens the native photo picker interface on supported iOS versions.

```APIDOC
## function openPhotoPicker()

### Description
Opens the native photo picker interface, allowing the user to select photos or videos from the photo library. This method is only supported on iOS 14 and above.

### Signature
`function openPhotoPicker(): Promise<void>`

### Return Type
`Promise<void>` - Resolves when the photo picker closes. Note that the selection result is handled by the native system and not returned to JavaScript.

### Errors
- `Error: Only supported by iOS 14 and above` - Thrown if called on Android, Windows, or iOS versions below 14.

### Example
```typescript
import {openPhotoPicker} from 'react-native-permissions';

const pickPhoto = async () => {
  try {
    await openPhotoPicker();
    console.log('Photo picker closed');
  } catch (error) {
    console.log('Photo picker not available:', error.message);
  }
};
```
```

--------------------------------

### Define RESULTS constant

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/constants.md

Enumeration of all possible permission statuses.

```typescript
const RESULTS = {
  UNAVAILABLE: 'unavailable',
  BLOCKED: 'blocked',
  DENIED: 'denied',
  GRANTED: 'granted',
  LIMITED: 'limited',
} as const;
```

--------------------------------

### Open after permission is blocked

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Automatically redirects the user to settings when a requested permission returns a BLOCKED status.

```typescript
import {request, openSettings, PERMISSIONS, RESULTS} from 'react-native-permissions';

const requestWithFallback = async () => {
  const status = await request(PERMISSIONS.ANDROID.CAMERA);
  
  if (status === RESULTS.BLOCKED) {
    console.log('Permission blocked. Opening settings...');
    await openSettings('application');
  }
};
```

--------------------------------

### Requesting Location Accuracy Workflow

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/requestLocationAccuracy.md

Demonstrates the standard flow of requesting location permissions followed by checking and upgrading location accuracy.

```typescript
import {request, checkLocationAccuracy, requestLocationAccuracy, PERMISSIONS, RESULTS} from 'react-native-permissions';

const setupLocationTracking = async () => {
  // Step 1: Check if location permission is granted
  const permStatus = await request(PERMISSIONS.IOS.LOCATION_WHEN_IN_USE);
  
  if (permStatus !== RESULTS.GRANTED) {
    console.log('Location permission not granted');
    return false;
  }
  
  // Step 2: Check current accuracy level
  try {
    const currentAccuracy = await checkLocationAccuracy();
    
    if (currentAccuracy === 'full') {
      console.log('Already have full accuracy');
      return true;
    }
    
    // Step 3: Request upgrade to full accuracy
    console.log('Requesting full location accuracy');
    const requestedAccuracy = await requestLocationAccuracy({
      purposeKey: 'realtime_tracking',
    });
    
    return requestedAccuracy === 'full';
  } catch (error) {
    console.log('Accuracy check/request not supported');
    return true;
  }
};
```

--------------------------------

### requestMultiple(permissions: P)

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Requests multiple permissions in sequence.

```APIDOC
## requestMultiple(permissions: P)

### Description
Requests multiple permissions in sequence.

### Parameters
- **permissions** (Permission[]) - Required - An array of permissions to request.

### Returns
- **Promise<Record<P[number], PermissionStatus>>** - A promise that resolves to an object mapping each permission to its status.
```

--------------------------------

### Check Full-Screen Intent Capability in TypeScript

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/canUseFullScreenIntent.md

Use this pattern to conditionally launch a full-screen UI or fall back to a notification system based on the availability of the full-screen intent permission.

```typescript
import {canUseFullScreenIntent, openSettings} from 'react-native-permissions';

const handleIncomingCall = async (callData) => {
  try {
    const canShowFullScreen = await canUseFullScreenIntent();
    
    if (canShowFullScreen) {
      // Launch full-screen call activity
      startFullScreenCallUI(callData);
    } else {
      // Show heads-up notification
      showCallHeadsUpNotification(callData);
      
      // Optionally suggest enabling the permission
      console.log('User could enable full-screen intents for better UX');
      // Could offer: await openSettings('fullscreen');
    }
  } catch (error) {
    // Android < 14
    console.log('Device does not support this check');
  }
};
```

--------------------------------

### Check and Request Permission

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Verify current permission status and request access if not already granted.

```typescript
import {check, request, PERMISSIONS, RESULTS} from 'react-native-permissions';

const enableCamera = async () => {
  let status = await check(PERMISSIONS.IOS.CAMERA);
  
  if (status !== RESULTS.GRANTED) {
    status = await request(PERMISSIONS.IOS.CAMERA);
  }
  
  return status === RESULTS.GRANTED;
};
```

--------------------------------

### Open full-screen intent settings (Android)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Opens the full-screen intent settings page, specific to Android platforms.

```typescript
import {openSettings} from 'react-native-permissions';

const openFullScreenSettings = async () => {
  try {
    await openSettings('fullscreen');
  } catch (error) {
    console.log('Could not open full-screen settings');
  }
};
```

--------------------------------

### Add Android dependencies

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Include the library in your app-level build.gradle dependencies.

```gradle
dependencies {
  // ...
  implementation project(':react-native-permissions')
}
```

--------------------------------

### Check and Schedule Exact Alarms in TypeScript

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/canScheduleExactAlarms.md

Verify permission status before scheduling an alarm, providing a fallback for inexact alarms if permission is denied or unsupported.

```typescript
import {request, canScheduleExactAlarms, PERMISSIONS, RESULTS} from 'react-native-permissions';

const setupExactAlarm = async (alarmTime) => {
  try {
    // Check if exact alarms are allowed
    const canScheduleExact = await canScheduleExactAlarms();
    
    if (canScheduleExact) {
      console.log('Scheduling exact alarm');
      // Use exact alarm API
      NativeModules.AlarmModule.scheduleExactAlarm(alarmTime);
    } else {
      console.log('Using inexact alarm instead');
      // Use inexact alarm fallback
      NativeModules.AlarmModule.scheduleInexactAlarm(alarmTime);
    }
  } catch (error) {
    console.log('Device does not support this check');
  }
};
```

--------------------------------

### Show different notification types based on capability

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/canUseFullScreenIntent.md

Conditional logic to determine whether to show a full-screen UI or a standard notification based on permission status.

```typescript
import {canUseFullScreenIntent} from 'react-native-permissions';

const showIncomingCallNotification = async (callerInfo) => {
  try {
    const canShowFullScreen = await canUseFullScreenIntent();
    
    if (canShowFullScreen) {
      console.log('Showing full-screen incoming call notification');
      // Launch full-screen call UI
      showFullScreenCallActivity(callerInfo);
    } else {
      console.log('Showing regular notification for incoming call');
      // Show standard notification in notification center
      showRegularCallNotification(callerInfo);
    }
  } catch (error) {
    console.log('Device does not support full-screen intents');
    showRegularCallNotification(callerInfo);
  }
};
```

--------------------------------

### Configure Expo Permissions via Static Configuration

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Use this approach in app.json to define permissions statically. This requires adding the plugin and platform-specific permission keys within the expo object.

```jsonc
{
  "expo": {
    // …
    "plugins": [
      [
        "react-native-permissions",
        {
          // Add setup_permissions to your Podfile (see iOS setup - steps 1, 2 and 3)
          "iosPermissions": ["Camera", "Microphone"],
        },
      ],
    ],
    "ios": {
      // Add descriptions to your Info.plist (see iOS setup - step 4)
      "infoPlist": {
        "NSCameraUsageDescription": "[REASON]",
        "NSMicrophoneUsageDescription": "[REASON]",
      },
    },
    "android": {
      // Add permissions to your AndroidManifest.xml (see Android setup)
      "permissions": ["android.permission.CAMERA", "android.permission.RECORD_AUDIO"],
    },
  },
}
```

--------------------------------

### PERMISSIONS

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/constants.md

Namespaced object containing all available permission identifiers organized by platform (Android, iOS, Windows).

```APIDOC
## PERMISSIONS

### Description
The `PERMISSIONS` constant provides a namespaced object containing all available permissions organized by platform.

### Usage
```typescript
import {check, PERMISSIONS} from 'react-native-permissions';

// Android example
const cameraStatus = await check(PERMISSIONS.ANDROID.CAMERA);

// iOS example
const contactsStatus = await check(PERMISSIONS.IOS.CONTACTS);

// Windows example
const locationStatus = await check(PERMISSIONS.WINDOWS.LOCATION);
```
```

--------------------------------

### Request Permission

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Request a single permission, optionally providing a rationale for Android users.

```ts
function request(permission: Permission, rationale?: Rationale): Promise<PermissionStatus>;
```

```ts
import {request, PERMISSIONS} from 'react-native-permissions';

request(PERMISSIONS.IOS.CAMERA).then((status) => {
  // …
});
```

--------------------------------

### canUseFullScreenIntent()

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/canUseFullScreenIntent.md

Checks if the application can use full-screen intents. This method should be called before attempting to use full-screen intent functionality to ensure compatibility.

```APIDOC
## canUseFullScreenIntent()

### Description
Checks if the application is permitted to use full-screen intents. This is particularly relevant for Android 14+ devices.

### Signature
`async canUseFullScreenIntent(): Promise<boolean>`

### Usage
```typescript
import {canUseFullScreenIntent} from 'react-native-permissions';

const check = async () => {
  const isSupported = await canUseFullScreenIntent();
  if (isSupported) {
    // Proceed with full-screen intent logic
  }
};
```

### Notes
- This method may throw an error on non-Android platforms or specific Android versions where the feature is not supported.
- It is recommended to wrap the call in a try-catch block to handle potential platform-specific exceptions.
```

--------------------------------

### request(permission)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/INDEX.md

Requests a single permission from the user.

```APIDOC
## request(permission)

### Description
Prompts the user to grant a single permission.

### Parameters
- **permission** (string) - Required - The permission identifier to request.
```

--------------------------------

### Link iOS Podfile

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Add the RNPermissions pod to your Podfile to manually link the library on iOS.

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

--------------------------------

### Check single permission with types

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/types.md

Demonstrates using Permission and PermissionStatus types to check a specific permission.

```typescript
import type {Permission, PermissionStatus} from 'react-native-permissions';
import {PERMISSIONS, check} from 'react-native-permissions';

async function checkSinglePermission(perm: Permission): Promise<PermissionStatus> {
  return check(perm);
}

// Usage
const status = await checkSinglePermission(PERMISSIONS.IOS.CAMERA);
```

--------------------------------

### RESULTS

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/constants.md

Enumeration of all possible permission statuses returned by permission checks.

```APIDOC
## RESULTS

### Description
Enumeration of all possible permission statuses. Use these constants when checking permission results.

### Fields
- **UNAVAILABLE** ('unavailable') - Permission not available on this platform or device
- **BLOCKED** ('blocked') - Permission denied by user; "don't ask again" was selected (Android)
- **DENIED** ('denied') - Permission denied by user; can be requested again
- **GRANTED** ('granted') - Permission granted; app can use the resource
- **LIMITED** ('limited') - Permission partially granted (iOS photo/media library access)
```

--------------------------------

### Check before requesting permission

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/canScheduleExactAlarms.md

Pattern for verifying capability before attempting to request permissions or redirecting to settings.

```typescript
import {request, canScheduleExactAlarms, PERMISSIONS} from 'react-native-permissions';

const ensureExactAlarmCapability = async () => {
  try {
    const canSchedule = await canScheduleExactAlarms();
    
    if (canSchedule) {
      return true;
    }
    
    // Permission denied; offer to open settings
    console.log('Exact alarms not enabled');
    // Could offer: await openSettings('alarms');
    return false;
  } catch (error) {
    // Android < 12 or not Android
    return false;
  }
};
```

--------------------------------

### requestMultiple(permissions)

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/INDEX.md

Requests multiple permissions from the user in a batch.

```APIDOC
## requestMultiple(permissions)

### Description
Requests a list of permissions from the user.

### Parameters
- **permissions** (Array<string>) - Required - List of permission identifiers.
```

--------------------------------

### Handle openSettings errors in TypeScript

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/openSettings.md

Wraps the openSettings call in a try-catch block to handle potential failures gracefully and provide user feedback.

```typescript
import {openSettings} from 'react-native-permissions';

const safeOpenSettings = async (type = 'application') => {
  try {
    await openSettings(type);
  } catch (error) {
    console.warn(`Failed to open ${type} settings:`, error.message);
    // Fallback: provide manual instructions to user
    return false;
  }
  
  return true;
};
```

--------------------------------

### Import Expo Plugin

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/README.md

Import the Expo plugin for configuration within Expo projects.

```typescript
import {withPermissions} from 'react-native-permissions/expo';
// or as default export
import withPermissions from 'react-native-permissions/expo';
```

--------------------------------

### Access Android Permissions

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

List of available Android permission constants provided by the library.

```javascript
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.ACCESS_MEDIA_LOCATION;
PERMISSIONS.ANDROID.ACTIVITY_RECOGNITION;
PERMISSIONS.ANDROID.ADD_VOICEMAIL;
PERMISSIONS.ANDROID.ANSWER_PHONE_CALLS;
PERMISSIONS.ANDROID.BLUETOOTH_ADVERTISE;
PERMISSIONS.ANDROID.BLUETOOTH_CONNECT;
PERMISSIONS.ANDROID.BLUETOOTH_SCAN;
PERMISSIONS.ANDROID.BODY_SENSORS;
PERMISSIONS.ANDROID.BODY_SENSORS_BACKGROUND;
PERMISSIONS.ANDROID.CALL_PHONE;
PERMISSIONS.ANDROID.CAMERA;
PERMISSIONS.ANDROID.GET_ACCOUNTS;
PERMISSIONS.ANDROID.NEARBY_WIFI_DEVICES;
PERMISSIONS.ANDROID.POST_NOTIFICATIONS;
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_MEDIA_AUDIO;
PERMISSIONS.ANDROID.READ_MEDIA_IMAGES;
PERMISSIONS.ANDROID.READ_MEDIA_VIDEO;
PERMISSIONS.ANDROID.READ_MEDIA_VISUAL_USER_SELECTED;
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.UWB_RANGING;
PERMISSIONS.ANDROID.WRITE_CALENDAR;
PERMISSIONS.ANDROID.WRITE_CALL_LOG;
PERMISSIONS.ANDROID.WRITE_CONTACTS;
PERMISSIONS.ANDROID.WRITE_EXTERNAL_STORAGE;
```

--------------------------------

### Configure AndroidManifest.xml for Exact Alarms

Source: https://github.com/zoontek/react-native-permissions/blob/master/_autodocs/api-reference/canScheduleExactAlarms.md

Declare the SCHEDULE_EXACT_ALARM permission in the Android manifest to enable exact alarm functionality.

```xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
  <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
  <!-- ... rest of manifest ... -->
</manifest>
```

--------------------------------

### Open Photo Picker (iOS 14+)

Source: https://github.com/zoontek/react-native-permissions/blob/master/README.md

Opens a picker to update photo selection when permission is limited. Rejects if unsupported or already granted.

```ts
function openPhotoPicker(): Promise<void>;
```

```ts
import {openPhotoPicker} from 'react-native-permissions';

openPhotoPicker().catch(() => console.warn('Cannot open photo library picker'));
```
Tokens:
Raw