### Complete Initialization and Permission Checking

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

This example shows how to initialize and check all required permissions when your application starts. It handles platform-specific permissions for iOS and Android and provides a UI to request permissions if they are not granted.

```typescript
import React, {useEffect, useState} from 'react';
import {View, Text, Button, Platform, Alert} from 'react-native';
import {
  check,
  request,
  PERMISSIONS,
  RESULTS,
  openSettings,
} from 'react-native-permissions';

interface PermissionStatus {
  camera: boolean;
  microphone: boolean;
  contacts: boolean;
}

export const PermissionInitializer = () => {
  const [permissions, setPermissions] = useState<PermissionStatus>({
    camera: false,
    microphone: false,
    contacts: false,
  });
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    checkPermissions();
  }, []);

  const checkPermissions = async () => {
    try {
      const perms = Platform.select({
        ios: {
          camera: PERMISSIONS.IOS.CAMERA,
          microphone: PERMISSIONS.IOS.MICROPHONE,
          contacts: PERMISSIONS.IOS.CONTACTS,
        },
        android: {
          camera: PERMISSIONS.ANDROID.CAMERA,
          microphone: PERMISSIONS.ANDROID.RECORD_AUDIO,
          contacts: PERMISSIONS.ANDROID.READ_CONTACTS,
        },
      });

      if (!perms) return;

      const [cameraStatus, micStatus, contactsStatus] = await Promise.all([
        check(perms.camera),
        check(perms.microphone),
        check(perms.contacts),
      ]);

      setPermissions({
        camera: cameraStatus === RESULTS.GRANTED,
        microphone: micStatus === RESULTS.GRANTED,
        contacts: contactsStatus === RESULTS.GRANTED,
      });
    } finally {
      setLoading(false);
    }
  };

  const requestPermission = async (
    permission: string,
    key: keyof PermissionStatus
  ) => {
    try {
      const status = await request(permission);

      if (status === RESULTS.GRANTED) {
        setPermissions((prev) => ({...prev, [key]: true}));
      } else if (status === RESULTS.BLOCKED) {
        Alert.alert(
          'Permission Blocked',
          'This permission is blocked. Please enable it in settings.',
          [{text: 'OK'}, {text: 'Open Settings', onPress: openSettings}]
        );
      }
    } catch (error) {
      console.error('Permission request failed:', error);
    }
  };

  if (loading) {
    return <Text>Loading...</Text>;
  }

  return (
    <View>
      <Button
        title={permissions.camera ? '✓ Camera' : '✗ Grant Camera'}
        onPress={() => {
          const perm = Platform.select({
            ios: PERMISSIONS.IOS.CAMERA,
            android: PERMISSIONS.ANDROID.CAMERA,
          });
          if (perm) requestPermission(perm, 'camera');
        }}
      />
      <Button
        title={permissions.microphone ? '✓ Microphone' : '✗ Grant Microphone'}
        onPress={() => {
          const perm = Platform.select({
            ios: PERMISSIONS.IOS.MICROPHONE,
            android: PERMISSIONS.ANDROID.RECORD_AUDIO,
          });
          if (perm) requestPermission(perm, 'microphone');
        }}
      />
      <Button
        title={permissions.contacts ? '✓ Contacts' : '✗ Grant Contacts'}
        onPress={() => {
          const perm = Platform.select({
            ios: PERMISSIONS.IOS.CONTACTS,
            android: PERMISSIONS.ANDROID.READ_CONTACTS,
          });
          if (perm) requestPermission(perm, 'contacts');
        }}
      />
    </View>
  );
};

```

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

### iOS Podfile Setup

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

Include the react-native-permissions setup script in your Podfile and call setup_permissions for specific native modules.

```ruby
node_require('react-native-permissions/scripts/setup.rb')
setup_permissions(['Camera', 'Microphone'])
```

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

### Install react-native-permissions

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

Install the library using npm or yarn.

```bash
$ npm i -S react-native-permissions
# --- or ---
$ yarn add react-native-permissions
```

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

### Complete Expo Plugin Configuration Example

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

A comprehensive example demonstrating the dynamic configuration of the react-native-permissions Expo plugin. This includes detailed iOS Info.plist keys and Android manifest permissions for camera, photo library, and microphone access.

```typescript
import type {ConfigContext, ExpoConfig} from 'expo/config';
import permissions from 'react-native-permissions/expo';

export default ({config}: ConfigContext): ExpoConfig => ({
  name: 'CameraApp',
  slug: 'cameraapp',
  version: '1.0.0',
  
  plugins: [
    permissions({
      iosPermissions: ['Camera', 'PhotoLibrary', 'Microphone'],
    }),
  ],

  ios: {
    bundleIdentifier: 'com.example.cameraapp',
    infoPlist: {
      NSCameraUsageDescription: 'We need camera access to take photos and videos',
      NSPhotoLibraryUsageDescription: 'We need access to your photo library',
      NSPhotoLibraryAddUsageDescription: 'We need permission to save photos',
      NSMicrophoneUsageDescription: 'We need microphone access for video recording',
    },
  },

  android: {
    package: 'com.example.cameraapp',
    permissions: [
      'android.permission.CAMERA',
      'android.permission.READ_EXTERNAL_STORAGE',
      'android.permission.WRITE_EXTERNAL_STORAGE',
      'android.permission.RECORD_AUDIO',
    ],
  },
});
```

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

### Mock CheckMultiple Function Example

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

Example of using checkMultiple to get the status of multiple permissions.

```javascript
import {checkMultiple, PERMISSIONS, RESULTS} from 'react-native-permissions/mock';

const statuses = await checkMultiple([
  PERMISSIONS.IOS.CAMERA,
  PERMISSIONS.IOS.MICROPHONE,
]);

// Result:
// {
//   'ios.permission.CAMERA': 'granted',
//   'ios.permission.MICROPHONE': 'granted'
// }
```

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

### Complete Test Example for App Permissions

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

A comprehensive example demonstrating how to use mock functions for testing various permission checks and requests in a React Native application.

```javascript
import {check, request, checkMultiple, PERMISSIONS, RESULTS} from 'react-native-permissions/mock';

describe('App permissions', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  it('should check camera permission', async () => {
    const status = await check(PERMISSIONS.IOS.CAMERA);
    expect(status).toBe(RESULTS.GRANTED);
    expect(check).toHaveBeenCalledWith(PERMISSIONS.IOS.CAMERA);
  });

  it('should handle denied camera permission', async () => {
    check.mockResolvedValue(RESULTS.DENIED);
    
    const status = await check(PERMISSIONS.IOS.CAMERA);
    expect(status).toBe(RESULTS.DENIED);
  });

  it('should request multiple permissions', async () => {
    const statuses = await checkMultiple([
      PERMISSIONS.IOS.CAMERA,
      PERMISSIONS.IOS.MICROPHONE,
    ]);
    
    expect(statuses[PERMISSIONS.IOS.CAMERA]).toBe(RESULTS.GRANTED);
    expect(statuses[PERMISSIONS.IOS.MICROPHONE]).toBe(RESULTS.GRANTED);
  });

  it('should handle partial permission grant', async () => {
    checkMultiple.mockResolvedValue({
      [PERMISSIONS.IOS.CAMERA]: RESULTS.GRANTED,
      [PERMISSIONS.IOS.MICROPHONE]: RESULTS.DENIED,
    });

    const statuses = await checkMultiple([
      PERMISSIONS.IOS.CAMERA,
      PERMISSIONS.IOS.MICROPHONE,
    ]);

    expect(statuses[PERMISSIONS.IOS.CAMERA]).toBe(RESULTS.GRANTED);
    expect(statuses[PERMISSIONS.IOS.MICROPHONE]).toBe(RESULTS.DENIED);
  });

  it('should track request calls', async () => {
    await request(PERMISSIONS.ANDROID.CAMERA);
    
    expect(request).toHaveBeenCalledTimes(1);
    expect(request).toHaveBeenCalledWith(PERMISSIONS.ANDROID.CAMERA, undefined);
  });
});
```

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

### Manual Linking for iOS Podfile

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

Add this line to your `ios/Podfile` and run `pod install` for manual linking. This is typically for special cases.

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

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

### Declare Windows Capabilities in Manifest

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

Example of how to declare necessary capabilities in the app's Package.appxmanifest file for Windows applications.

```xml
<Capabilities>
  <Capability Name="webcam" />
  <Capability Name="microphone" />
</Capabilities>
```

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

### Mock RequestMultiple Function Example

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

Example of using requestMultiple to request multiple permissions and get their statuses.

```javascript
const statuses = await requestMultiple([
  PERMISSIONS.ANDROID.CAMERA,
  PERMISSIONS.ANDROID.RECORD_AUDIO,
]);

// Result:
// {
//   'android.permission.CAMERA': 'granted',
//   'android.permission.RECORD_AUDIO': 'granted'
// }
```

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

### Test Camera Permission Check

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

Example of importing and using the check function in a test to verify camera permission status.

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

describe('permissions', () => {
  it('should check camera permission', async () => {
    const status = await check(PERMISSIONS.IOS.CAMERA);
    expect(status).toBe(RESULTS.GRANTED);
  });
});
```

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

### Check Notification Status Example

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

Example of how to check the current notification permission status and access associated settings. This is useful for conditionally enabling features that rely on notifications.

```javascript
const {status, settings} = await checkNotifications();

if (status === RESULTS.GRANTED) {
  console.log('Notifications enabled');
  console.log('Alerts:', settings.alert);
  console.log('Sound:', settings.sound);
}
```

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

### Request Permission with Native Rationale

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

Example of requesting a permission using a RationaleObject for a native Android dialog.

```javascript
const rationale = {
  title: 'Camera Permission',
  message: 'We need camera access to capture photos',
  buttonPositive: 'Allow',
  buttonNegative: 'Cancel',
};

request(PERMISSIONS.ANDROID.CAMERA, rationale);
```

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

### Static Configuration in app.json

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

Example of how to configure iOS permissions using the plugin within the static app.json configuration file, including necessary Info.plist entries.

```json
{
  "expo": {
    "plugins": [
      [
        "react-native-permissions",
        {
          "iosPermissions": ["Camera", "Microphone"]
        }
      ]
    ],
    "ios": {
      "infoPlist": {
        "NSCameraUsageDescription": "We need camera access to capture photos",
        "NSMicrophoneUsageDescription": "We need microphone access for video calls"
      }
    }
  }
}
```

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

### Import Mock Functions

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

Import the mock versions of check, request, PERMISSIONS, and RESULTS for use in test setup.

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

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

### Example Usage in app.config.ts (Default Export)

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

Demonstrates how to use the default exported permissions plugin in your Expo app.config.ts file to configure iOS permissions.

```typescript
import type {ConfigContext, ExpoConfig} from 'expo/config';
import permissions from 'react-native-permissions/expo';

export default ({config}: ConfigContext): ExpoConfig => ({
  // …
  plugins: [
    permissions({
      iosPermissions: ['Camera', 'Microphone'],
    }),
  ],
  // …
});
```

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

### Default Object Import Example

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

Demonstrates using the default export object to access module methods and constants. This provides a single point of access for all library features.

```typescript
import RNPermissions from 'react-native-permissions';

const status = await RNPermissions.check(RNPermissions.PERMISSIONS.IOS.CAMERA);
```

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

### Jest Mock Setup

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

Mock the react-native-permissions module for Jest testing. This ensures tests run reliably by providing predictable mock return values.

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

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

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

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

### Configure iOS Podfile for Permissions

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

Modify your Podfile to include the react-native-permissions setup script and specify the permissions required for your iOS application. This ensures only necessary permissions are linked.

```ruby
def node_require(script)
  # Resolve script with node to allow for hoisting
  require Pod::Executable.execute_command('node', ['-p',
    "require.resolve(
      '#{script}',
      {paths: [process.argv[1]]},
    )", __dir__]).strip
end

# Use it to require both react-native's and this package's scripts:
node_require('react-native/scripts/react_native_pods.rb')
node_require('react-native-permissions/scripts/setup.rb')
```

```ruby
# …

platform :ios, min_ios_version_supported
prepare_react_native_project!

# ⬇️ uncomment the permissions you need
setup_permissions([
  # 'AppTrackingTransparency',
  # 'Bluetooth',
  # 'Calendars',
  # 'CalendarsWriteOnly',
  # 'Camera',
  # 'Contacts',
  # 'FaceID',
  # 'LocationAccuracy',
  # 'LocationAlways',
  # 'LocationWhenInUse',
  # 'MediaLibrary',
  # 'Microphone',
  # 'Motion',
  # 'Notifications',
  # 'PhotoLibrary',
  # 'PhotoLibraryAddOnly',
  # 'Reminders',
  # 'Siri',
  # 'SpeechRecognition',
  # 'StoreKit',
])

# …
```

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

### Request Permission with Custom Rationale Callback

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

Example of requesting a permission using a custom callback function that returns a promise for rationale handling.

```javascript
const rationale = async () => {
  const result = await showCustomRationaleModal();
  return result === 'proceed';
};

request(PERMISSIONS.ANDROID.CAMERA, rationale);
```

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

### Request Single Permission with Custom Callback Rationale

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

This example demonstrates requesting a permission on Android using a custom callback for the rationale. The callback should return a promise that resolves to a boolean indicating whether the user accepted the rationale, allowing the request to proceed.

```javascript
request(PERMISSIONS.ANDROID.CAMERA, async () => {
  // Show custom UI to user
  const userAccepted = await showCustomRationaleDialog();
  return userAccepted;
})
  .then(status => console.log('Permission:', status));
```

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

### Permission Categories Overview

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

Lists various permission categories like Media, Location, Hardware, Networking, Messaging, File System, Device/System, Content Restriction, Enterprise/Developer, and Other. Note that Windows permissions are configured via app manifest at installation time.

```plaintext
### Permission Categories

**Media:**
- MICROPHONE - Access microphone
- WEBCAM - Access camera
- MUSIC_LIBRARY - Access music library
- VIDEOS_LIBRARY - Access video library
- PICTURES_LIBRARY - Access pictures library

**Location:**
- LOCATION - Access location
- LOCATION_HISTORY - Access location history

**Hardware:**
- BLUETOOTH - Bluetooth access
- USB - USB device access
- PROXIMITY - Proximity detection
- OPTICAL - Optical device access

**Networking:**
- INTERNET_CLIENT - Internet client capability
- INTERNET_CLIENT_SERVER - Internet client/server
- PRIVATE_NETWORK_CLIENT_SERVER - Private network access
- NETWORKING_VPN_PROVIDER - VPN provider capability

**Messaging:**
- SMS_SEND - Send SMS messages
- EMAIL - Email access
- PHONE_CALL - Make phone calls
- VOIP_CALL - VoIP calling
- PHONE_CALL_HISTORY - Access call history

**File System:**
- DOCUMENTS_LIBRARY - Access documents
- BROAD_FILE_SYSTEM_ACCESS - Broad file system access
- REMOVABLE_STORAGE - Access removable storage

**Device/System:**
- CONTACTS - Access contacts
- APPOINTMENTS - Access appointments
- REMINDERS - Access reminders
- ACTIVITY - Report device activity
- MOTION - Access motion data
- GAZE_INPUT - Eye tracking/gaze input

**Content Restriction:**
- BLOCKED_CHAT_MESSAGES - Blocked chat messages
- CHAT_SYSTEM - Chat system access

**Enterprise/Developer:**
- ENTERPRISE_AUTHENTICATION - Enterprise single sign-on
- ENTERPRISE_DATA_POLICY - Enterprise data policy
- DEVELOPMENT_MODE_NETWORK - Development mode

**Other:**
- RADIOS - Control wireless radios
- SPATIAL_PERCEPTION - 3D spatial perception
- STOREKIT - Store license management
- GAME_BAR_SERVICES - Xbox Game Bar

**Note:** Windows permissions are configured via app manifest at installation time, not at runtime like iOS/Android.

**Source:** `src/permissions.windows.ts:5-150`
```

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

### Example Usage in app.config.ts (withPermissions)

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

Shows how to directly use the 'withPermissions' named export in your Expo plugin array for configuring iOS permissions.

```typescript
import {withPermissions} from 'react-native-permissions/expo';

export default ({config}: ConfigContext): ExpoConfig => ({
  plugins: [
    withPermissions({
      iosPermissions: ['Camera'],
    }),
  ],
});
```

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

### Setup Expo Permissions Plugin

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

Configures the react-native-permissions plugin for Expo projects. Allows specifying iOS permissions to be included in the build. Requires importing the permissions plugin from the library.

```typescript
import permissions from 'react-native-permissions/expo';

export default {
  plugins: [
    permissions({
      iosPermissions: ['Camera', 'Microphone'],
    }),
  ],
};
```

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

### Dynamic Configuration with Expo Plugin

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

Configure iOS and Android permissions dynamically within your app.config.ts file using the react-native-permissions Expo plugin. This example shows how to specify iOS permissions and their corresponding usage descriptions in Info.plist, as well as Android permissions.

```typescript
import type {ConfigContext, ExpoConfig} from 'expo/config';
import permissions from 'react-native-permissions/expo';

export default ({config}: ConfigContext): ExpoConfig => ({
  name: 'MyApp',
  slug: 'myapp',
  version: '1.0.0',
  plugins: [
    permissions({
      iosPermissions: ['Camera', 'Microphone', 'Contacts'],
    }),
  ],
  ios: {
    infoPlist: {
      NSCameraUsageDescription: 'Camera access for photos',
      NSMicrophoneUsageDescription: 'Microphone access for calls',
      NSContactsUsageDescription: 'Contacts access',
    },
  },
  android: {
    permissions: [
      'android.permission.CAMERA',
      'android.permission.RECORD_AUDIO',
      'android.permission.READ_CONTACTS',
    ],
  },
});
```

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

### Importing from Package Entry Points

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

Demonstrates how to import the main module, Expo plugin, or mock based on the package.json 'exports' configuration.

```javascript
// Main module - resolves based on import/require
import from 'react-native-permissions';
require('react-native-permissions');

// Expo plugin
import from 'react-native-permissions/expo';

// Mock
import from 'react-native-permissions/mock';
```

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

### Request Location Accuracy Example

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

Example of how to request a specific location accuracy level on iOS, providing a purpose key for context. This is only applicable for iOS 14+.

```javascript
await requestLocationAccuracy({
  purposeKey: 'INDOOR_NAVIGATION',
});
```

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

### Manual Linking for Windows app.cpp

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

Add the PackageProviders line before InitializeComponent() in `app.cpp` for Windows manual linking.

```csharp
PackageProviders().Append(winrt::RNPermissions::ReactPackageProvider());
```

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

### Manual Linking for Android MainApplication.java

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

Import and link the RNPermissionsPackage in `MainApplication.java` for manual linking.

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

  // …
}
```

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

### Platform Selection for Permissions

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

Demonstrates how to select the correct permission constant based on the current platform using Platform.select.

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

const permission = Platform.select({
  ios: PERMISSIONS.IOS.CAMERA,
  android: PERMISSIONS.ANDROID.CAMERA,
  windows: PERMISSIONS.WINDOWS.CAMERA,
});

if (permission) {
  const status = await check(permission);
}
```

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

### Handle openSettings Unsupported on Windows

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

This snippet demonstrates how to handle the 'openSettings' function when called on a Windows platform, where it is unsupported. It includes a fallback behavior to open the application's info screen.

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

openSettings('application')
  .catch(error => {
    console.warn('Cannot open app settings:', error.message);
  });
```

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

### openSettings

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

Mocks the openSettings function. This function resolves immediately without any error, simulating the action of opening the app's settings.

```APIDOC
## openSettings

### Description
Simulates opening the application settings. This mock function resolves immediately without error.

### Method
Asynchronous function call
```

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

### Platform-Specific Error Handling for Location Accuracy

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

This example shows how to catch errors from checkLocationAccuracy() and handle iOS-specific error messages gracefully.

```javascript
import {Platform} from 'react-native';

checkLocationAccuracy()
  .then(accuracy => {
    console.log('Accuracy:', accuracy);
  })
  .catch(error => {
    if (Platform.OS === 'ios' && error.message.includes('iOS 14')) {
      // Gracefully degrade on older iOS
      console.log('Location accuracy not available');
    } else {
      console.error('Unexpected error:', error);
    }
  });
```

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

### Manual Linking for Windows Project Reference

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

Add a reference to RNPermissions in your main application project's .vcxproj file for Windows manual linking.

```csharp
- Right-click main application project > Add > Reference...
- Check `RNPermissions` from Solution Projects.
```

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

### Check Notifications Settings

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

Checks the status and settings for notification permissions. On Android 13+, use requestNotifications to get blocked status.

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

checkNotifications().then(({status, settings}) => {
  // …
});
```

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

### Import Main API Functions

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

Import the core functions for checking and requesting permissions, managing notifications, and accessing device settings.

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

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

### iOS Info.plist Permissions

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

Add usage descriptions for camera and microphone permissions in your Info.plist file.

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

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

### Manual Linking for Windows Solution

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

Add the RNPermissions project to your Visual Studio solution for Windows manual linking.

```csharp
- 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`
```

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

### Configure iOS Info.plist for Permissions

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

Add the necessary permission usage descriptions to your application's Info.plist file. Ensure that only the permissions enabled in the Podfile are included.

```xml
<?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 specified in `setup_permissions` 🚨 -->

  <key>NSAppleMusicUsageDescription</key>
  <string>[REASON]</string>
  <key>NSBluetoothAlwaysUsageDescription</key>
  <string>[REASON]</string>
  <key>NSBluetoothPeripheralUsageDescription</key>
  <string>[REASON]</string>
  <key>NSCalendarsFullAccessUsageDescription</key>
  <string>[REASON]</string>
  <key>NSCalendarsWriteOnlyAccessUsageDescription</key>
  <string>[REASON]</string>
  <key>NSCameraUsageDescription</key>
  <string>[REASON]</string>
  <key>NSContactsUsageDescription</key>
  <string>[REASON]</string>
  <key>NSFaceIDUsageDescription</key>
  <string>[REASON]</string>
  <key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
  <string>[REASON]</string>
  <key>NSLocationTemporaryUsageDescriptionDictionary</key>
  <dict>
    <key>YOUR-PURPOSE-KEY</key>
    <string>[REASON]</string>
  </dict>
  <key>NSLocationWhenInUseUsageDescription</key>
  <string>[REASON]</string>
  <key>NSMicrophoneUsageDescription</key>
  <string>[REASON]</string>
  <key>NSMotionUsageDescription</key>
  <string>[REASON]</string>
  <key>NSPhotoLibraryUsageDescription</key>
  <string>[REASON]</string>
  <key>NSPhotoLibraryAddUsageDescription</key>
  <string>[REASON]</string>
  <key>NSRemindersFullAccessUsageDescription</key>
  <string>[REASON]</string>
  <key>NSSpeechRecognitionUsageDescription</key>
  <string>[REASON]</string>
  <key>NSSiriUsageDescription</key>
  <string>[REASON]</string>
  <key>NSUserTrackingUsageDescription</key>
  <string>[REASON]</string>

  <!-- … -->

</dict>
</plist>
```

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

### RationaleObject

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

Configuration object for native Android permission request dialog, including title, message, and button texts.

```APIDOC
## Type: RationaleObject

### Description
Configuration object for native Android permission request dialog.

### Type Definition
```typescript
type RationaleObject = {
  title: string;
  message: string;
  buttonPositive: string;
  buttonNegative?: string;
};
```

### Fields
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| title | string | Yes | Dialog title shown to user |
| message | string | Yes | Explanation of why permission is needed |
| buttonPositive | string | Yes | Text for "allow/accept" button |
| buttonNegative | string | No | Text for "deny/cancel" button; if omitted only positive button shown |

### Usage
**Used by:** `request()`, `requestNotifications()` (Android only)
```

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

### canUseFullScreenIntent

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

Mocks the canUseFullScreenIntent function. This function always resolves to true, simulating that the full-screen intent can be used.

```APIDOC
## canUseFullScreenIntent

### Description
Simulates checking if the full-screen intent can be used. This mock function always resolves to `true`.

### Method
Asynchronous function call

### Response
#### Success Response
* **(boolean)** - Always returns `true`.
```

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

### Check Single Permission Status

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

This snippet demonstrates how to check the status of a single permission. It uses Platform.select to get the correct permission constant for the current operating system and then awaits the result of the check function. The feature can be used if the status is GRANTED.

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

const permission = Platform.select({
  ios: PERMISSIONS.IOS.CAMERA,
  android: PERMISSIONS.ANDROID.CAMERA,
  windows: PERMISSIONS.WINDOWS.CAMERA,
});

const status = await check(permission);
if (status === RESULTS.GRANTED) {
  // Use feature
}
```

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

### Testing Permissions with Mock Module

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

Demonstrates how to test permission checks and requests using the mock module. This is useful for simulating different permission states during development and testing.

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

describe('Camera Feature', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  it('should check camera permission', async () => {
    const status = await check(PERMISSIONS.IOS.CAMERA);
    expect(status).toBe(RESULTS.GRANTED);
    expect(check).toHaveBeenCalledWith(PERMISSIONS.IOS.CAMERA);
  });

  it('should handle permission denied', async () => {
    check.mockResolvedValue(RESULTS.DENIED);

    const status = await check(PERMISSIONS.IOS.CAMERA);
    expect(status).toBe(RESULTS.DENIED);
  });

  it('should request multiple permissions', async () => {
    const statuses = await checkMultiple([
      PERMISSIONS.IOS.CAMERA,
      PERMISSIONS.IOS.MICROPHONE,
    ]);

    expect(statuses[PERMISSIONS.IOS.CAMERA]).toBe(RESULTS.GRANTED);
    expect(statuses[PERMISSIONS.IOS.MICROPHONE]).toBe(RESULTS.GRANTED);
  });

  it('should handle partial permissions', async () => {
    checkMultiple.mockResolvedValue({
      [PERMISSIONS.IOS.CAMERA]: RESULTS.GRANTED,
      [PERMISSIONS.IOS.MICROPHONE]: RESULTS.DENIED,
    });

    const statuses = await checkMultiple([
      PERMISSIONS.IOS.CAMERA,
      PERMISSIONS.IOS.MICROPHONE,
    ]);

    expect(statuses[PERMISSIONS.IOS.CAMERA]).toBe(RESULTS.GRANTED);
    expect(statuses[PERMISSIONS.IOS.MICROPHONE]).toBe(RESULTS.DENIED);
  });

  it('should track request calls with rationale', async () => {
    await request(PERMISSIONS.ANDROID.CAMERA, {
      title: 'Camera Permission',
      message: 'We need camera access',
      buttonPositive: 'Allow',
    });

    expect(request).toHaveBeenCalledWith(
      PERMISSIONS.ANDROID.CAMERA,
      expect.objectContaining({
        title: 'Camera Permission',
      })
    );
  });
});

```

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

### Android Manifest Permissions

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

Declare camera and record audio permissions in your AndroidManifest.xml file.

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

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

### openPhotoPicker

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

Mocks the openPhotoPicker function. This function resolves immediately without any error, simulating the action of opening the photo picker.

```APIDOC
## openPhotoPicker

### Description
Simulates opening the photo picker. This mock function resolves immediately without error.

### Method
Asynchronous function call
```

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

### openSettings

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

Opens the app settings screen or specific system settings. The available settings types depend on the platform and OS version.

```APIDOC
## openSettings

### Description
Opens the app settings screen or specific system settings. The available settings types depend on the platform and OS version.

### Method
```typescript
function openSettings(type?: 'application' | 'alarms' | 'fullscreen' | 'notifications'): Promise<void>;
```

### Parameters
#### Query Parameters
- **type** (string) - Optional - 'application' (app info), 'alarms' (alarm settings), 'fullscreen' (full screen intent), or 'notifications'. Defaults to 'application'.

### Return type
`Promise<void>` resolves when settings screen is opened or rejects if not available.

### Platform-specific behavior
- **iOS:** Opens app settings. Settings types not supported; falls back to application.
- **Android 8+:** Supports 'notifications', 'application', 'alarms' (Android 12+), and 'fullscreen' (Android 14+).
- **Android <8:** Only 'application' supported.
- **Windows:** Not supported; always rejects.

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

openSettings('notifications')
  .catch(() => console.warn('Cannot open notification settings'));
```
```

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

### Manual Linking for Android settings.gradle

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

Add these lines to `android/settings.gradle` for manual linking of the react-native-permissions package.

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

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

### Manual Linking for Android build.gradle

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

Add the implementation line to the dependencies in `android/app/build.gradle` for manual linking.

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

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

### Open Application Settings

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

Opens the application settings. It can also open specific settings like notifications, alarms, or fullscreen settings, with fallbacks to application settings if a specific choice is unavailable. Notification and alarm settings have platform and version specific availability.

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

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

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

### Manual Linking for Windows pch.h

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

Include the necessary header in `pch.h` for Windows manual linking.

```csharp
#include "winrt/RNPermissions.h"
```

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

### Import Mock Functions for Testing

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

Import mock versions of the API functions and constants for use in testing environments.

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

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

### Main Module Exports

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

Import all methods, constants, and types from the main module. This is the most comprehensive way to import functionalities.

```typescript
import {
  check,
  request,
  checkMultiple,
  requestMultiple,
  checkNotifications,
  requestNotifications,
  openSettings,
  openPhotoPicker,
  checkLocationAccuracy,
  requestLocationAccuracy,
  canScheduleExactAlarms,
  canUseFullScreenIntent,
  
  PERMISSIONS,
  RESULTS,
  
  Permission,
  PermissionStatus,
  RationaleObject,
  Rationale,
  NotificationOption,
  NotificationSettings,
  NotificationsResponse,
  LocationAccuracy,
  LocationAccuracyOptions,
  AndroidPermission,
  IOSPermission,
  WindowsPermission,
} from 'react-native-permissions';
```

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

### Settings & Features

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

Methods for opening app settings, managing specific features like photo pickers and location accuracy, and checking capabilities.

```APIDOC
## openSettings(type?)

### Description
Opens the app's settings screen or specific settings like alarm or notification settings.

### Method
`openSettings`

### Parameters
#### Path Parameters
- **type** (string) - Optional - The type of settings to open (e.g., 'alarm', 'notification').

### Returns
Promise<void>
```

```APIDOC
## openPhotoPicker()

### Description
Opens the photo picker to allow the user to select photos, relevant for limited photo library access on iOS 14+.

### Method
`openPhotoPicker`

### Returns
Promise<void>
```

```APIDOC
## checkLocationAccuracy()

### Description
Checks if the location accuracy is set to precise or reduced on iOS 14+.

### Method
`checkLocationAccuracy`

### Returns
Promise<'full' | 'reduced'>
```

```APIDOC
## requestLocationAccuracy(options)

### Description
Requests precise location accuracy from the user on iOS 14+.

### Method
`requestLocationAccuracy`

### Parameters
#### Path Parameters
- **options** (object) - Required - Options for requesting location accuracy.

### Returns
Promise<'full' | 'reduced'>
```

```APIDOC
## canScheduleExactAlarms()

### Description
Checks if the app has the capability to schedule exact alarms on Android 12+.

### Method
`canScheduleExactAlarms`

### Returns
Promise<boolean>
```

```APIDOC
## canUseFullScreenIntent()

### Description
Checks if the app has the capability to use the full-screen intent on Android 14+.

### Method
`canUseFullScreenIntent`

### Returns
Promise<boolean>
```

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

### Request Camera Permission

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

Shows how to request the camera permission. The rationale parameter is used on Android.

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

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

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

### Request Single Permission with Rationale

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

Use `request` to prompt the user for a single permission. On Android, you can provide a `rationale` object or a callback to explain why the permission is needed before the system prompt. If the user previously denied the permission on Android, the status will be 'blocked'.

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

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

request(PERMISSIONS.ANDROID.CAMERA, {
  title: 'Camera Permission',
  message: 'This app needs access to your camera to take photos',
  buttonPositive: 'Allow',
  buttonNegative: 'Deny',
})
  .then(status => {
    if (status === RESULTS.GRANTED) {
      console.log('Camera permission granted');
    }
  });
```

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

### Windows Permissions List

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

Lists all available Windows permissions that can be accessed via the PERMISSIONS.WINDOWS object. Ensure you have the necessary imports.

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

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

### Package.json Exports Field

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

Defines the entry points for the library, allowing conditional imports based on module type (import/require) and specific features like Expo or mock.

```json
{
  "exports": {
    ".": {
      "import": "./dist/module/index.js",
      "require": "./dist/commonjs/index.js",
      "types": "./dist/typescript/commonjs/index.d.ts"
    },
    "./expo": {
      "import": "./dist/module/extras/expo.js",
      "require": "./dist/commonjs/extras/expo.js"
    },
    "./mock": {
      "import": "./dist/module/extras/mock.js",
      "require": "./dist/commonjs/extras/mock.js"
    }
  }
}
```