CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-react-native-permissions

Unified permissions API for React Native on iOS, Android and Windows platforms

—

Pending
Overview
Eval results
Files

permission-constants.mddocs/

Permission Constants

Platform-specific permission identifiers organized by operating system. Each platform provides different permission types that map to their respective system permissions.

Capabilities

PERMISSIONS Object

The main permission constants object containing platform-specific permission maps.

/**
 * Main permission constants object with platform-specific permission maps
 */
interface PermissionsConstants {
  ANDROID: AndroidPermissionMap;
  IOS: IOSPermissionMap; 
  WINDOWS: WindowsPermissionMap;
}

declare const PERMISSIONS: PermissionsConstants;

// Usage pattern: PERMISSIONS.PLATFORM.PERMISSION_NAME
// Examples:
// PERMISSIONS.ANDROID.CAMERA
// PERMISSIONS.IOS.CAMERA  
// PERMISSIONS.WINDOWS.WEBCAM

Android Permissions

Android permissions covering device capabilities, media access, location, communication, and sensors.

interface AndroidPermissionMap {
  // Location permissions
  readonly ACCESS_COARSE_LOCATION: 'android.permission.ACCESS_COARSE_LOCATION';
  readonly ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION';
  readonly ACCESS_BACKGROUND_LOCATION: 'android.permission.ACCESS_BACKGROUND_LOCATION';
  readonly ACCESS_MEDIA_LOCATION: 'android.permission.ACCESS_MEDIA_LOCATION';
  
  // Camera and media permissions
  readonly CAMERA: 'android.permission.CAMERA';
  readonly RECORD_AUDIO: 'android.permission.RECORD_AUDIO';
  readonly READ_MEDIA_IMAGES: 'android.permission.READ_MEDIA_IMAGES';
  readonly READ_MEDIA_VIDEO: 'android.permission.READ_MEDIA_VIDEO';
  readonly READ_MEDIA_AUDIO: 'android.permission.READ_MEDIA_AUDIO';
  readonly READ_MEDIA_VISUAL_USER_SELECTED: 'android.permission.READ_MEDIA_VISUAL_USER_SELECTED';
  
  // Storage permissions (legacy)
  readonly READ_EXTERNAL_STORAGE: 'android.permission.READ_EXTERNAL_STORAGE';
  readonly WRITE_EXTERNAL_STORAGE: 'android.permission.WRITE_EXTERNAL_STORAGE';
  
  // Contact permissions
  readonly READ_CONTACTS: 'android.permission.READ_CONTACTS';
  readonly WRITE_CONTACTS: 'android.permission.WRITE_CONTACTS';
  readonly GET_ACCOUNTS: 'android.permission.GET_ACCOUNTS';
  
  // Calendar permissions
  readonly READ_CALENDAR: 'android.permission.READ_CALENDAR';
  readonly WRITE_CALENDAR: 'android.permission.WRITE_CALENDAR';
  
  // Phone and SMS permissions
  readonly READ_PHONE_STATE: 'android.permission.READ_PHONE_STATE';
  readonly READ_PHONE_NUMBERS: 'android.permission.READ_PHONE_NUMBERS';
  readonly CALL_PHONE: 'android.permission.CALL_PHONE';
  readonly ANSWER_PHONE_CALLS: 'android.permission.ANSWER_PHONE_CALLS';
  readonly ADD_VOICEMAIL: 'com.android.voicemail.permission.ADD_VOICEMAIL';
  readonly USE_SIP: 'android.permission.USE_SIP';
  readonly PROCESS_OUTGOING_CALLS: 'android.permission.PROCESS_OUTGOING_CALLS';
  readonly READ_CALL_LOG: 'android.permission.READ_CALL_LOG';
  readonly WRITE_CALL_LOG: 'android.permission.WRITE_CALL_LOG';
  readonly SEND_SMS: 'android.permission.SEND_SMS';
  readonly RECEIVE_SMS: 'android.permission.RECEIVE_SMS';
  readonly READ_SMS: 'android.permission.READ_SMS';
  readonly RECEIVE_MMS: 'android.permission.RECEIVE_MMS';
  readonly RECEIVE_WAP_PUSH: 'android.permission.RECEIVE_WAP_PUSH';
  
  // Bluetooth permissions (Android 12+)
  readonly BLUETOOTH_ADVERTISE: 'android.permission.BLUETOOTH_ADVERTISE';
  readonly BLUETOOTH_CONNECT: 'android.permission.BLUETOOTH_CONNECT';
  readonly BLUETOOTH_SCAN: 'android.permission.BLUETOOTH_SCAN';
  
  // Sensor permissions
  readonly BODY_SENSORS: 'android.permission.BODY_SENSORS';
  readonly BODY_SENSORS_BACKGROUND: 'android.permission.BODY_SENSORS_BACKGROUND';
  readonly ACTIVITY_RECOGNITION: 'android.permission.ACTIVITY_RECOGNITION';
  
  // Network and connectivity
  readonly NEARBY_WIFI_DEVICES: 'android.permission.NEARBY_WIFI_DEVICES';
  readonly UWB_RANGING: 'android.permission.UWB_RANGING';
  
  // Notification permissions (Android 13+)
  readonly POST_NOTIFICATIONS: 'android.permission.POST_NOTIFICATIONS';
  
  // Alarm and scheduling permissions (Android 12+)
  readonly SCHEDULE_EXACT_ALARM: 'android.permission.SCHEDULE_EXACT_ALARM';
  readonly USE_FULL_SCREEN_INTENT: 'android.permission.USE_FULL_SCREEN_INTENT';
  
  // Phone call handling
  readonly ACCEPT_HANDOVER: 'android.permission.ACCEPT_HANDOVER';
}

type AndroidPermission = AndroidPermissionMap[keyof AndroidPermissionMap];

Usage Examples:

import { PERMISSIONS, check, request } from "react-native-permissions";

// Camera access
const cameraStatus = await check(PERMISSIONS.ANDROID.CAMERA);
await request(PERMISSIONS.ANDROID.CAMERA);

// Location permissions hierarchy
await request(PERMISSIONS.ANDROID.ACCESS_COARSE_LOCATION); // Approximate location
await request(PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION);   // Precise location  
await request(PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION); // Background location

// Media permissions (Android 13+)
const mediaPermissions = [
  PERMISSIONS.ANDROID.READ_MEDIA_IMAGES,
  PERMISSIONS.ANDROID.READ_MEDIA_VIDEO,
  PERMISSIONS.ANDROID.READ_MEDIA_AUDIO
];
const mediaStatuses = await checkMultiple(mediaPermissions);

// Bluetooth permissions (Android 12+)
const bluetoothPermissions = [
  PERMISSIONS.ANDROID.BLUETOOTH_ADVERTISE,
  PERMISSIONS.ANDROID.BLUETOOTH_CONNECT,
  PERMISSIONS.ANDROID.BLUETOOTH_SCAN
];

// Notification permissions (Android 13+)
await request(PERMISSIONS.ANDROID.POST_NOTIFICATIONS);

// Alarm and scheduling permissions (Android 12+) 
await request(PERMISSIONS.ANDROID.SCHEDULE_EXACT_ALARM);
await request(PERMISSIONS.ANDROID.USE_FULL_SCREEN_INTENT);

// Contact and calendar access
await request(PERMISSIONS.ANDROID.READ_CONTACTS);
await request(PERMISSIONS.ANDROID.READ_CALENDAR);

iOS Permissions

iOS permissions covering device capabilities, privacy-sensitive data, and system features.

interface IOSPermissionMap {
  // Location permissions
  readonly LOCATION_ALWAYS: 'ios.permission.LOCATION_ALWAYS';
  readonly LOCATION_WHEN_IN_USE: 'ios.permission.LOCATION_WHEN_IN_USE';
  
  // Camera and media permissions
  readonly CAMERA: 'ios.permission.CAMERA';
  readonly MICROPHONE: 'ios.permission.MICROPHONE';
  readonly PHOTO_LIBRARY: 'ios.permission.PHOTO_LIBRARY';
  readonly PHOTO_LIBRARY_ADD_ONLY: 'ios.permission.PHOTO_LIBRARY_ADD_ONLY';
  readonly MEDIA_LIBRARY: 'ios.permission.MEDIA_LIBRARY';
  
  // Contact and calendar permissions
  readonly CONTACTS: 'ios.permission.CONTACTS';
  readonly CALENDARS: 'ios.permission.CALENDARS';
  readonly CALENDARS_WRITE_ONLY: 'ios.permission.CALENDARS_WRITE_ONLY';
  readonly REMINDERS: 'ios.permission.REMINDERS';
  
  // Biometric and security permissions
  readonly FACE_ID: 'ios.permission.FACE_ID';
  
  // Privacy and tracking permissions
  readonly APP_TRACKING_TRANSPARENCY: 'ios.permission.APP_TRACKING_TRANSPARENCY';
  
  // System integration permissions
  readonly SIRI: 'ios.permission.SIRI';
  readonly SPEECH_RECOGNITION: 'ios.permission.SPEECH_RECOGNITION';
  readonly MOTION: 'ios.permission.MOTION';
  readonly BLUETOOTH: 'ios.permission.BLUETOOTH';
  readonly STOREKIT: 'ios.permission.STOREKIT';
}

type IOSPermission = IOSPermissionMap[keyof IOSPermissionMap];

Usage Examples:

import { PERMISSIONS, check, request } from "react-native-permissions";

// Camera and microphone access
await request(PERMISSIONS.IOS.CAMERA);
await request(PERMISSIONS.IOS.MICROPHONE);

// Photo library permissions
await request(PERMISSIONS.IOS.PHOTO_LIBRARY);           // Full photo library access
await request(PERMISSIONS.IOS.PHOTO_LIBRARY_ADD_ONLY);  // Add photos only

// Location permissions
await request(PERMISSIONS.IOS.LOCATION_WHEN_IN_USE);    // Location while app is active
await request(PERMISSIONS.IOS.LOCATION_ALWAYS);         // Background location access

// Privacy permissions (iOS 14+)
await request(PERMISSIONS.IOS.APP_TRACKING_TRANSPARENCY); // Cross-app tracking

// Biometric authentication
const faceIdStatus = await check(PERMISSIONS.IOS.FACE_ID);

// Contact and calendar access
await request(PERMISSIONS.IOS.CONTACTS);
await request(PERMISSIONS.IOS.CALENDARS);
await request(PERMISSIONS.IOS.CALENDARS_WRITE_ONLY);     // Write-only calendar access

// System integration
await request(PERMISSIONS.IOS.SIRI);                     // Siri integration
await request(PERMISSIONS.IOS.SPEECH_RECOGNITION);       // Speech recognition
await request(PERMISSIONS.IOS.MOTION);                   // Motion and fitness data

Windows Permissions

Windows permissions covering a comprehensive range of device capabilities, system access, and enterprise features.

interface WindowsPermissionMap {
  // Basic device permissions
  readonly WEBCAM: string;
  readonly MICROPHONE: string;
  readonly LOCATION: string;
  readonly CONTACTS: string;
  
  // Media library permissions
  readonly PICTURES_LIBRARY: string;
  readonly MUSIC_LIBRARY: string;
  readonly VIDEOS_LIBRARY: string;
  readonly DOCUMENTS_LIBRARY: string;
  
  // Network permissions
  readonly INTERNET_CLIENT: string;
  readonly INTERNET_CLIENT_SERVER: string;
  readonly PRIVATE_NETWORK_CLIENT_SERVER: string;
  
  // Device access permissions
  readonly BLUETOOTH: string;
  readonly USB: string;
  readonly SERIALCOMMUNICATION: string;
  readonly PROXIMITY: string;
  
  // System permissions
  readonly SYSTEM_MANAGEMENT: string;
  readonly PACKAGE_MANAGEMENT: string;
  readonly UI_AUTOMATION: string;
  
  // Enterprise permissions
  readonly ENTERPRISE_AUTHENTICATION: string;
  readonly ENTERPRISE_DATA_POLICY: string;
  
  // Gaming permissions
  readonly GAME_BAR_SERVICES: string;
  readonly GAME_LIST: string;
  readonly XBOX_ACCESSORY_MANAGEMENT: string;
  
  // ... 150+ total Windows permissions
}

type WindowsPermission = WindowsPermissionMap[keyof WindowsPermissionMap];

Usage Examples:

import { PERMISSIONS, check, request } from "react-native-permissions";

// Basic device access
await request(PERMISSIONS.WINDOWS.WEBCAM);
await request(PERMISSIONS.WINDOWS.MICROPHONE);
await request(PERMISSIONS.WINDOWS.LOCATION);

// Media libraries
const mediaLibraries = [
  PERMISSIONS.WINDOWS.PICTURES_LIBRARY,
  PERMISSIONS.WINDOWS.MUSIC_LIBRARY,
  PERMISSIONS.WINDOWS.VIDEOS_LIBRARY
];
const mediaStatuses = await checkMultiple(mediaLibraries);

// Network capabilities
await request(PERMISSIONS.WINDOWS.INTERNET_CLIENT);
await request(PERMISSIONS.WINDOWS.PRIVATE_NETWORK_CLIENT_SERVER);

// Device connectivity
await request(PERMISSIONS.WINDOWS.BLUETOOTH);
await request(PERMISSIONS.WINDOWS.USB);

// System integration (requires special capabilities)
await check(PERMISSIONS.WINDOWS.SYSTEM_MANAGEMENT);
await check(PERMISSIONS.WINDOWS.ENTERPRISE_AUTHENTICATION);

Cross-Platform Usage Patterns

Platform-Specific Permission Mapping

import { Platform } from 'react-native';
import { PERMISSIONS, request } from "react-native-permissions";

async function requestCameraPermission() {
  let permission;
  
  if (Platform.OS === 'ios') {
    permission = PERMISSIONS.IOS.CAMERA;
  } else if (Platform.OS === 'android') {
    permission = PERMISSIONS.ANDROID.CAMERA;
  } else if (Platform.OS === 'windows') {
    permission = PERMISSIONS.WINDOWS.WEBCAM;
  } else {
    throw new Error('Unsupported platform');
  }
  
  return await request(permission);
}

// Location permission mapping
async function requestLocationPermission() {
  let permission;
  
  switch (Platform.OS) {
    case 'ios':
      permission = PERMISSIONS.IOS.LOCATION_WHEN_IN_USE;
      break;
    case 'android':
      permission = PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION;
      break;
    case 'windows':
      permission = PERMISSIONS.WINDOWS.LOCATION;
      break;
    default:
      throw new Error('Unsupported platform');
  }
  
  return await request(permission);
}

Permission Feature Detection

import { Platform } from 'react-native';
import { PERMISSIONS } from "react-native-permissions";

interface PlatformPermissions {
  camera: string;
  microphone: string;
  location: string;
  contacts: string;
  photoLibrary?: string;
  backgroundLocation?: string;
}

function getPlatformPermissions(): PlatformPermissions {
  const base = {
    camera: '',
    microphone: '',
    location: '',
    contacts: ''
  };
  
  switch (Platform.OS) {
    case 'ios':
      return {
        ...base,
        camera: PERMISSIONS.IOS.CAMERA,
        microphone: PERMISSIONS.IOS.MICROPHONE,
        location: PERMISSIONS.IOS.LOCATION_WHEN_IN_USE,
        contacts: PERMISSIONS.IOS.CONTACTS,
        photoLibrary: PERMISSIONS.IOS.PHOTO_LIBRARY,
        backgroundLocation: PERMISSIONS.IOS.LOCATION_ALWAYS
      };
      
    case 'android':
      return {
        ...base,
        camera: PERMISSIONS.ANDROID.CAMERA,
        microphone: PERMISSIONS.ANDROID.RECORD_AUDIO,
        location: PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION,
        contacts: PERMISSIONS.ANDROID.READ_CONTACTS,
        photoLibrary: PERMISSIONS.ANDROID.READ_MEDIA_IMAGES,
        backgroundLocation: PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION
      };
      
    case 'windows':
      return {
        ...base,
        camera: PERMISSIONS.WINDOWS.WEBCAM,
        microphone: PERMISSIONS.WINDOWS.MICROPHONE,
        location: PERMISSIONS.WINDOWS.LOCATION,
        contacts: PERMISSIONS.WINDOWS.CONTACTS,
        photoLibrary: PERMISSIONS.WINDOWS.PICTURES_LIBRARY
      };
      
    default:
      return base;
  }
}

// Usage
const platformPermissions = getPlatformPermissions();
await request(platformPermissions.camera);

Permission Groups and Related Permissions

import { PERMISSIONS, requestMultiple } from "react-native-permissions";

// Media access permission groups
const MEDIA_PERMISSIONS = {
  ios: [
    PERMISSIONS.IOS.CAMERA,
    PERMISSIONS.IOS.MICROPHONE,
    PERMISSIONS.IOS.PHOTO_LIBRARY
  ],
  android: [
    PERMISSIONS.ANDROID.CAMERA,
    PERMISSIONS.ANDROID.RECORD_AUDIO,
    PERMISSIONS.ANDROID.READ_MEDIA_IMAGES,
    PERMISSIONS.ANDROID.READ_MEDIA_VIDEO
  ],
  windows: [
    PERMISSIONS.WINDOWS.WEBCAM,
    PERMISSIONS.WINDOWS.MICROPHONE,
    PERMISSIONS.WINDOWS.PICTURES_LIBRARY,
    PERMISSIONS.WINDOWS.VIDEOS_LIBRARY
  ]
};

// Location permission hierarchy
const LOCATION_PERMISSIONS = {
  ios: {
    basic: PERMISSIONS.IOS.LOCATION_WHEN_IN_USE,
    background: PERMISSIONS.IOS.LOCATION_ALWAYS
  },
  android: {
    coarse: PERMISSIONS.ANDROID.ACCESS_COARSE_LOCATION,
    fine: PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION,
    background: PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION
  },
  windows: {
    basic: PERMISSIONS.WINDOWS.LOCATION
  }
};

// Request permission groups
async function requestMediaPermissions() {
  const permissions = MEDIA_PERMISSIONS[Platform.OS] || [];
  return await requestMultiple(permissions);
}

Permission Constants Best Practices

Type-Safe Permission Usage

import { PERMISSIONS, Permission } from "react-native-permissions";

// Type-safe permission checking
function isValidPermission(permission: unknown): permission is Permission {
  if (typeof permission !== 'string') return false;
  
  const allPermissions = [
    ...Object.values(PERMISSIONS.ANDROID),
    ...Object.values(PERMISSIONS.IOS),
    ...Object.values(PERMISSIONS.WINDOWS)
  ];
  
  return allPermissions.includes(permission as Permission);
}

// Permission validation before requests
async function safeRequest(permission: unknown) {
  if (!isValidPermission(permission)) {
    throw new Error(`Invalid permission: ${permission}`);
  }
  
  return await request(permission);
}

Permission Documentation and Rationale

import { PERMISSIONS } from "react-native-permissions";

// Document permission purposes
const PERMISSION_RATIONALES = {
  [PERMISSIONS.IOS.CAMERA]: {
    title: "Camera Access",
    message: "Take photos and videos to share with your contacts",
    feature: "Photo sharing"
  },
  [PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION]: {
    title: "Location Access", 
    message: "Find nearby restaurants and get personalized recommendations",
    feature: "Location-based services"
  },
  [PERMISSIONS.IOS.CONTACTS]: {
    title: "Contacts Access",
    message: "Find friends who are already using the app",
    feature: "Friend discovery"
  }
};

// Get rationale for permission
function getPermissionRationale(permission: Permission) {
  return PERMISSION_RATIONALES[permission];
}

Install with Tessl CLI

npx tessl i tessl/npm-react-native-permissions

docs

index.md

notification-permissions.md

permission-checking.md

permission-constants.md

permission-requesting.md

platform-specific-features.md

tile.json