0
# Permission Constants
1

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

4
## Capabilities
5

6
### PERMISSIONS Object
7

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

10
```typescript { .api }
11
/**
12
 * Main permission constants object with platform-specific permission maps
13
 */
14
interface PermissionsConstants {
15
  ANDROID: AndroidPermissionMap;
16
  IOS: IOSPermissionMap; 
17
  WINDOWS: WindowsPermissionMap;
18
}
19

20
declare const PERMISSIONS: PermissionsConstants;
21

22
// Usage pattern: PERMISSIONS.PLATFORM.PERMISSION_NAME
23
// Examples:
24
// PERMISSIONS.ANDROID.CAMERA
25
// PERMISSIONS.IOS.CAMERA  
26
// PERMISSIONS.WINDOWS.WEBCAM
27
```
28

29
## Android Permissions
30

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

33
```typescript { .api }
34
interface AndroidPermissionMap {
35
  // Location permissions
36
  readonly ACCESS_COARSE_LOCATION: 'android.permission.ACCESS_COARSE_LOCATION';
37
  readonly ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION';
38
  readonly ACCESS_BACKGROUND_LOCATION: 'android.permission.ACCESS_BACKGROUND_LOCATION';
39
  readonly ACCESS_MEDIA_LOCATION: 'android.permission.ACCESS_MEDIA_LOCATION';
40
  
41
  // Camera and media permissions
42
  readonly CAMERA: 'android.permission.CAMERA';
43
  readonly RECORD_AUDIO: 'android.permission.RECORD_AUDIO';
44
  readonly READ_MEDIA_IMAGES: 'android.permission.READ_MEDIA_IMAGES';
45
  readonly READ_MEDIA_VIDEO: 'android.permission.READ_MEDIA_VIDEO';
46
  readonly READ_MEDIA_AUDIO: 'android.permission.READ_MEDIA_AUDIO';
47
  readonly READ_MEDIA_VISUAL_USER_SELECTED: 'android.permission.READ_MEDIA_VISUAL_USER_SELECTED';
48
  
49
  // Storage permissions (legacy)
50
  readonly READ_EXTERNAL_STORAGE: 'android.permission.READ_EXTERNAL_STORAGE';
51
  readonly WRITE_EXTERNAL_STORAGE: 'android.permission.WRITE_EXTERNAL_STORAGE';
52
  
53
  // Contact permissions
54
  readonly READ_CONTACTS: 'android.permission.READ_CONTACTS';
55
  readonly WRITE_CONTACTS: 'android.permission.WRITE_CONTACTS';
56
  readonly GET_ACCOUNTS: 'android.permission.GET_ACCOUNTS';
57
  
58
  // Calendar permissions
59
  readonly READ_CALENDAR: 'android.permission.READ_CALENDAR';
60
  readonly WRITE_CALENDAR: 'android.permission.WRITE_CALENDAR';
61
  
62
  // Phone and SMS permissions
63
  readonly READ_PHONE_STATE: 'android.permission.READ_PHONE_STATE';
64
  readonly READ_PHONE_NUMBERS: 'android.permission.READ_PHONE_NUMBERS';
65
  readonly CALL_PHONE: 'android.permission.CALL_PHONE';
66
  readonly ANSWER_PHONE_CALLS: 'android.permission.ANSWER_PHONE_CALLS';
67
  readonly ADD_VOICEMAIL: 'com.android.voicemail.permission.ADD_VOICEMAIL';
68
  readonly USE_SIP: 'android.permission.USE_SIP';
69
  readonly PROCESS_OUTGOING_CALLS: 'android.permission.PROCESS_OUTGOING_CALLS';
70
  readonly READ_CALL_LOG: 'android.permission.READ_CALL_LOG';
71
  readonly WRITE_CALL_LOG: 'android.permission.WRITE_CALL_LOG';
72
  readonly SEND_SMS: 'android.permission.SEND_SMS';
73
  readonly RECEIVE_SMS: 'android.permission.RECEIVE_SMS';
74
  readonly READ_SMS: 'android.permission.READ_SMS';
75
  readonly RECEIVE_MMS: 'android.permission.RECEIVE_MMS';
76
  readonly RECEIVE_WAP_PUSH: 'android.permission.RECEIVE_WAP_PUSH';
77
  
78
  // Bluetooth permissions (Android 12+)
79
  readonly BLUETOOTH_ADVERTISE: 'android.permission.BLUETOOTH_ADVERTISE';
80
  readonly BLUETOOTH_CONNECT: 'android.permission.BLUETOOTH_CONNECT';
81
  readonly BLUETOOTH_SCAN: 'android.permission.BLUETOOTH_SCAN';
82
  
83
  // Sensor permissions
84
  readonly BODY_SENSORS: 'android.permission.BODY_SENSORS';
85
  readonly BODY_SENSORS_BACKGROUND: 'android.permission.BODY_SENSORS_BACKGROUND';
86
  readonly ACTIVITY_RECOGNITION: 'android.permission.ACTIVITY_RECOGNITION';
87
  
88
  // Network and connectivity
89
  readonly NEARBY_WIFI_DEVICES: 'android.permission.NEARBY_WIFI_DEVICES';
90
  readonly UWB_RANGING: 'android.permission.UWB_RANGING';
91
  
92
  // Notification permissions (Android 13+)
93
  readonly POST_NOTIFICATIONS: 'android.permission.POST_NOTIFICATIONS';
94
  
95
  // Alarm and scheduling permissions (Android 12+)
96
  readonly SCHEDULE_EXACT_ALARM: 'android.permission.SCHEDULE_EXACT_ALARM';
97
  readonly USE_FULL_SCREEN_INTENT: 'android.permission.USE_FULL_SCREEN_INTENT';
98
  
99
  // Phone call handling
100
  readonly ACCEPT_HANDOVER: 'android.permission.ACCEPT_HANDOVER';
101
}
102

103
type AndroidPermission = AndroidPermissionMap[keyof AndroidPermissionMap];
104
```
105

106
**Usage Examples:**
107

108
```typescript
109
import { PERMISSIONS, check, request } from "react-native-permissions";
110

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

115
// Location permissions hierarchy
116
await request(PERMISSIONS.ANDROID.ACCESS_COARSE_LOCATION); // Approximate location
117
await request(PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION);   // Precise location  
118
await request(PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION); // Background location
119

120
// Media permissions (Android 13+)
121
const mediaPermissions = [
122
  PERMISSIONS.ANDROID.READ_MEDIA_IMAGES,
123
  PERMISSIONS.ANDROID.READ_MEDIA_VIDEO,
124
  PERMISSIONS.ANDROID.READ_MEDIA_AUDIO
125
];
126
const mediaStatuses = await checkMultiple(mediaPermissions);
127

128
// Bluetooth permissions (Android 12+)
129
const bluetoothPermissions = [
130
  PERMISSIONS.ANDROID.BLUETOOTH_ADVERTISE,
131
  PERMISSIONS.ANDROID.BLUETOOTH_CONNECT,
132
  PERMISSIONS.ANDROID.BLUETOOTH_SCAN
133
];
134

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

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

142
// Contact and calendar access
143
await request(PERMISSIONS.ANDROID.READ_CONTACTS);
144
await request(PERMISSIONS.ANDROID.READ_CALENDAR);
145
```
146

147
## iOS Permissions
148

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

151
```typescript { .api }
152
interface IOSPermissionMap {
153
  // Location permissions
154
  readonly LOCATION_ALWAYS: 'ios.permission.LOCATION_ALWAYS';
155
  readonly LOCATION_WHEN_IN_USE: 'ios.permission.LOCATION_WHEN_IN_USE';
156
  
157
  // Camera and media permissions
158
  readonly CAMERA: 'ios.permission.CAMERA';
159
  readonly MICROPHONE: 'ios.permission.MICROPHONE';
160
  readonly PHOTO_LIBRARY: 'ios.permission.PHOTO_LIBRARY';
161
  readonly PHOTO_LIBRARY_ADD_ONLY: 'ios.permission.PHOTO_LIBRARY_ADD_ONLY';
162
  readonly MEDIA_LIBRARY: 'ios.permission.MEDIA_LIBRARY';
163
  
164
  // Contact and calendar permissions
165
  readonly CONTACTS: 'ios.permission.CONTACTS';
166
  readonly CALENDARS: 'ios.permission.CALENDARS';
167
  readonly CALENDARS_WRITE_ONLY: 'ios.permission.CALENDARS_WRITE_ONLY';
168
  readonly REMINDERS: 'ios.permission.REMINDERS';
169
  
170
  // Biometric and security permissions
171
  readonly FACE_ID: 'ios.permission.FACE_ID';
172
  
173
  // Privacy and tracking permissions
174
  readonly APP_TRACKING_TRANSPARENCY: 'ios.permission.APP_TRACKING_TRANSPARENCY';
175
  
176
  // System integration permissions
177
  readonly SIRI: 'ios.permission.SIRI';
178
  readonly SPEECH_RECOGNITION: 'ios.permission.SPEECH_RECOGNITION';
179
  readonly MOTION: 'ios.permission.MOTION';
180
  readonly BLUETOOTH: 'ios.permission.BLUETOOTH';
181
  readonly STOREKIT: 'ios.permission.STOREKIT';
182
}
183

184
type IOSPermission = IOSPermissionMap[keyof IOSPermissionMap];
185
```
186

187
**Usage Examples:**
188

189
```typescript
190
import { PERMISSIONS, check, request } from "react-native-permissions";
191

192
// Camera and microphone access
193
await request(PERMISSIONS.IOS.CAMERA);
194
await request(PERMISSIONS.IOS.MICROPHONE);
195

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

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

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

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

210
// Contact and calendar access
211
await request(PERMISSIONS.IOS.CONTACTS);
212
await request(PERMISSIONS.IOS.CALENDARS);
213
await request(PERMISSIONS.IOS.CALENDARS_WRITE_ONLY);     // Write-only calendar access
214

215
// System integration
216
await request(PERMISSIONS.IOS.SIRI);                     // Siri integration
217
await request(PERMISSIONS.IOS.SPEECH_RECOGNITION);       // Speech recognition
218
await request(PERMISSIONS.IOS.MOTION);                   // Motion and fitness data
219
```
220

221
## Windows Permissions
222

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

225
```typescript { .api }
226
interface WindowsPermissionMap {
227
  // Basic device permissions
228
  readonly WEBCAM: string;
229
  readonly MICROPHONE: string;
230
  readonly LOCATION: string;
231
  readonly CONTACTS: string;
232
  
233
  // Media library permissions
234
  readonly PICTURES_LIBRARY: string;
235
  readonly MUSIC_LIBRARY: string;
236
  readonly VIDEOS_LIBRARY: string;
237
  readonly DOCUMENTS_LIBRARY: string;
238
  
239
  // Network permissions
240
  readonly INTERNET_CLIENT: string;
241
  readonly INTERNET_CLIENT_SERVER: string;
242
  readonly PRIVATE_NETWORK_CLIENT_SERVER: string;
243
  
244
  // Device access permissions
245
  readonly BLUETOOTH: string;
246
  readonly USB: string;
247
  readonly SERIALCOMMUNICATION: string;
248
  readonly PROXIMITY: string;
249
  
250
  // System permissions
251
  readonly SYSTEM_MANAGEMENT: string;
252
  readonly PACKAGE_MANAGEMENT: string;
253
  readonly UI_AUTOMATION: string;
254
  
255
  // Enterprise permissions
256
  readonly ENTERPRISE_AUTHENTICATION: string;
257
  readonly ENTERPRISE_DATA_POLICY: string;
258
  
259
  // Gaming permissions
260
  readonly GAME_BAR_SERVICES: string;
261
  readonly GAME_LIST: string;
262
  readonly XBOX_ACCESSORY_MANAGEMENT: string;
263
  
264
  // ... 150+ total Windows permissions
265
}
266

267
type WindowsPermission = WindowsPermissionMap[keyof WindowsPermissionMap];
268
```
269

270
**Usage Examples:**
271

272
```typescript
273
import { PERMISSIONS, check, request } from "react-native-permissions";
274

275
// Basic device access
276
await request(PERMISSIONS.WINDOWS.WEBCAM);
277
await request(PERMISSIONS.WINDOWS.MICROPHONE);
278
await request(PERMISSIONS.WINDOWS.LOCATION);
279

280
// Media libraries
281
const mediaLibraries = [
282
  PERMISSIONS.WINDOWS.PICTURES_LIBRARY,
283
  PERMISSIONS.WINDOWS.MUSIC_LIBRARY,
284
  PERMISSIONS.WINDOWS.VIDEOS_LIBRARY
285
];
286
const mediaStatuses = await checkMultiple(mediaLibraries);
287

288
// Network capabilities
289
await request(PERMISSIONS.WINDOWS.INTERNET_CLIENT);
290
await request(PERMISSIONS.WINDOWS.PRIVATE_NETWORK_CLIENT_SERVER);
291

292
// Device connectivity
293
await request(PERMISSIONS.WINDOWS.BLUETOOTH);
294
await request(PERMISSIONS.WINDOWS.USB);
295

296
// System integration (requires special capabilities)
297
await check(PERMISSIONS.WINDOWS.SYSTEM_MANAGEMENT);
298
await check(PERMISSIONS.WINDOWS.ENTERPRISE_AUTHENTICATION);
299
```
300

301
## Cross-Platform Usage Patterns
302

303
### Platform-Specific Permission Mapping
304

305
```typescript
306
import { Platform } from 'react-native';
307
import { PERMISSIONS, request } from "react-native-permissions";
308

309
async function requestCameraPermission() {
310
  let permission;
311
  
312
  if (Platform.OS === 'ios') {
313
    permission = PERMISSIONS.IOS.CAMERA;
314
  } else if (Platform.OS === 'android') {
315
    permission = PERMISSIONS.ANDROID.CAMERA;
316
  } else if (Platform.OS === 'windows') {
317
    permission = PERMISSIONS.WINDOWS.WEBCAM;
318
  } else {
319
    throw new Error('Unsupported platform');
320
  }
321
  
322
  return await request(permission);
323
}
324

325
// Location permission mapping
326
async function requestLocationPermission() {
327
  let permission;
328
  
329
  switch (Platform.OS) {
330
    case 'ios':
331
      permission = PERMISSIONS.IOS.LOCATION_WHEN_IN_USE;
332
      break;
333
    case 'android':
334
      permission = PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION;
335
      break;
336
    case 'windows':
337
      permission = PERMISSIONS.WINDOWS.LOCATION;
338
      break;
339
    default:
340
      throw new Error('Unsupported platform');
341
  }
342
  
343
  return await request(permission);
344
}
345
```
346

347
### Permission Feature Detection
348

349
```typescript
350
import { Platform } from 'react-native';
351
import { PERMISSIONS } from "react-native-permissions";
352

353
interface PlatformPermissions {
354
  camera: string;
355
  microphone: string;
356
  location: string;
357
  contacts: string;
358
  photoLibrary?: string;
359
  backgroundLocation?: string;
360
}
361

362
function getPlatformPermissions(): PlatformPermissions {
363
  const base = {
364
    camera: '',
365
    microphone: '',
366
    location: '',
367
    contacts: ''
368
  };
369
  
370
  switch (Platform.OS) {
371
    case 'ios':
372
      return {
373
        ...base,
374
        camera: PERMISSIONS.IOS.CAMERA,
375
        microphone: PERMISSIONS.IOS.MICROPHONE,
376
        location: PERMISSIONS.IOS.LOCATION_WHEN_IN_USE,
377
        contacts: PERMISSIONS.IOS.CONTACTS,
378
        photoLibrary: PERMISSIONS.IOS.PHOTO_LIBRARY,
379
        backgroundLocation: PERMISSIONS.IOS.LOCATION_ALWAYS
380
      };
381
      
382
    case 'android':
383
      return {
384
        ...base,
385
        camera: PERMISSIONS.ANDROID.CAMERA,
386
        microphone: PERMISSIONS.ANDROID.RECORD_AUDIO,
387
        location: PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION,
388
        contacts: PERMISSIONS.ANDROID.READ_CONTACTS,
389
        photoLibrary: PERMISSIONS.ANDROID.READ_MEDIA_IMAGES,
390
        backgroundLocation: PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION
391
      };
392
      
393
    case 'windows':
394
      return {
395
        ...base,
396
        camera: PERMISSIONS.WINDOWS.WEBCAM,
397
        microphone: PERMISSIONS.WINDOWS.MICROPHONE,
398
        location: PERMISSIONS.WINDOWS.LOCATION,
399
        contacts: PERMISSIONS.WINDOWS.CONTACTS,
400
        photoLibrary: PERMISSIONS.WINDOWS.PICTURES_LIBRARY
401
      };
402
      
403
    default:
404
      return base;
405
  }
406
}
407

408
// Usage
409
const platformPermissions = getPlatformPermissions();
410
await request(platformPermissions.camera);
411
```
412

413
### Permission Groups and Related Permissions
414

415
```typescript
416
import { PERMISSIONS, requestMultiple } from "react-native-permissions";
417

418
// Media access permission groups
419
const MEDIA_PERMISSIONS = {
420
  ios: [
421
    PERMISSIONS.IOS.CAMERA,
422
    PERMISSIONS.IOS.MICROPHONE,
423
    PERMISSIONS.IOS.PHOTO_LIBRARY
424
  ],
425
  android: [
426
    PERMISSIONS.ANDROID.CAMERA,
427
    PERMISSIONS.ANDROID.RECORD_AUDIO,
428
    PERMISSIONS.ANDROID.READ_MEDIA_IMAGES,
429
    PERMISSIONS.ANDROID.READ_MEDIA_VIDEO
430
  ],
431
  windows: [
432
    PERMISSIONS.WINDOWS.WEBCAM,
433
    PERMISSIONS.WINDOWS.MICROPHONE,
434
    PERMISSIONS.WINDOWS.PICTURES_LIBRARY,
435
    PERMISSIONS.WINDOWS.VIDEOS_LIBRARY
436
  ]
437
};
438

439
// Location permission hierarchy
440
const LOCATION_PERMISSIONS = {
441
  ios: {
442
    basic: PERMISSIONS.IOS.LOCATION_WHEN_IN_USE,
443
    background: PERMISSIONS.IOS.LOCATION_ALWAYS
444
  },
445
  android: {
446
    coarse: PERMISSIONS.ANDROID.ACCESS_COARSE_LOCATION,
447
    fine: PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION,
448
    background: PERMISSIONS.ANDROID.ACCESS_BACKGROUND_LOCATION
449
  },
450
  windows: {
451
    basic: PERMISSIONS.WINDOWS.LOCATION
452
  }
453
};
454

455
// Request permission groups
456
async function requestMediaPermissions() {
457
  const permissions = MEDIA_PERMISSIONS[Platform.OS] || [];
458
  return await requestMultiple(permissions);
459
}
460
```
461

462
## Permission Constants Best Practices
463

464
### Type-Safe Permission Usage
465

466
```typescript
467
import { PERMISSIONS, Permission } from "react-native-permissions";
468

469
// Type-safe permission checking
470
function isValidPermission(permission: unknown): permission is Permission {
471
  if (typeof permission !== 'string') return false;
472
  
473
  const allPermissions = [
474
    ...Object.values(PERMISSIONS.ANDROID),
475
    ...Object.values(PERMISSIONS.IOS),
476
    ...Object.values(PERMISSIONS.WINDOWS)
477
  ];
478
  
479
  return allPermissions.includes(permission as Permission);
480
}
481

482
// Permission validation before requests
483
async function safeRequest(permission: unknown) {
484
  if (!isValidPermission(permission)) {
485
    throw new Error(`Invalid permission: ${permission}`);
486
  }
487
  
488
  return await request(permission);
489
}
490
```
491

492
### Permission Documentation and Rationale
493

494
```typescript
495
import { PERMISSIONS } from "react-native-permissions";
496

497
// Document permission purposes
498
const PERMISSION_RATIONALES = {
499
  [PERMISSIONS.IOS.CAMERA]: {
500
    title: "Camera Access",
501
    message: "Take photos and videos to share with your contacts",
502
    feature: "Photo sharing"
503
  },
504
  [PERMISSIONS.ANDROID.ACCESS_FINE_LOCATION]: {
505
    title: "Location Access", 
506
    message: "Find nearby restaurants and get personalized recommendations",
507
    feature: "Location-based services"
508
  },
509
  [PERMISSIONS.IOS.CONTACTS]: {
510
    title: "Contacts Access",
511
    message: "Find friends who are already using the app",
512
    feature: "Friend discovery"
513
  }
514
};
515

516
// Get rationale for permission
517
function getPermissionRationale(permission: Permission) {
518
  return PERMISSION_RATIONALES[permission];
519
}
520
```