0
# React Native Permissions
1

2
React Native Permissions provides a unified permissions API for React Native applications across iOS, Android, and Windows platforms. It abstracts platform-specific permission handling differences and provides a consistent API with clear permission status results.
3

4
## Package Information
5

6
- **Package Name**: react-native-permissions
7
- **Package Type**: npm
8
- **Language**: TypeScript
9
- **Installation**: `npm install react-native-permissions`
10

11
## Core Imports
12

13
```typescript
14
import {
15
  PERMISSIONS,
16
  RESULTS,
17
  check,
18
  request,
19
  checkMultiple,
20
  requestMultiple,
21
  checkNotifications,
22
  requestNotifications,
23
  openSettings,
24
  type Permission,
25
  type PermissionStatus,
26
  type NotificationsResponse
27
} from "react-native-permissions";
28
```
29

30
For CommonJS:
31

32
```javascript
33
const {
34
  PERMISSIONS,
35
  RESULTS,
36
  check,
37
  request,
38
  checkMultiple,
39
  requestMultiple,
40
  checkNotifications,
41
  requestNotifications,
42
  openSettings
43
} = require("react-native-permissions");
44
```
45

46
Default import (contains all APIs):
47

48
```typescript
49
import RNPermissions from "react-native-permissions";
50
// Access via RNPermissions.check, RNPermissions.PERMISSIONS, etc.
51
```
52

53
## Basic Usage
54

55
```typescript
56
import {
57
  PERMISSIONS,
58
  RESULTS,
59
  check,
60
  request,
61
  checkMultiple,
62
  requestNotifications
63
} from "react-native-permissions";
64

65
// Check single permission
66
const cameraStatus = await check(PERMISSIONS.IOS.CAMERA);
67
if (cameraStatus === RESULTS.GRANTED) {
68
  console.log("Camera permission granted");
69
}
70

71
// Request permission with rationale
72
const micStatus = await request(PERMISSIONS.ANDROID.RECORD_AUDIO, {
73
  title: "Microphone Permission",
74
  message: "App needs microphone access to record audio",
75
  buttonPositive: "OK",
76
  buttonNegative: "Cancel"
77
});
78

79
// Check multiple permissions at once
80
const statuses = await checkMultiple([
81
  PERMISSIONS.IOS.CAMERA,
82
  PERMISSIONS.IOS.MICROPHONE,
83
  PERMISSIONS.IOS.PHOTO_LIBRARY
84
]);
85

86
// Request notifications with specific options
87
const notificationResult = await requestNotifications(['alert', 'badge', 'sound']);
88
console.log(notificationResult.status, notificationResult.settings);
89
```
90

91
## Architecture
92

93
React Native Permissions is built around several key components:
94

95
- **Platform Constants**: `PERMISSIONS` object containing platform-specific permission identifiers
96
- **Status Constants**: `RESULTS` object defining possible permission states
97
- **Core Methods**: Functions for checking and requesting permissions individually or in batches
98
- **Specialized Methods**: Platform-specific functionality like location accuracy and notification settings
99
- **Type System**: Complete TypeScript definitions for all permissions, statuses, and method signatures
100
- **Native Bridge**: TurboModule implementation connecting JavaScript to native platform APIs
101

102
## Capabilities
103

104
### Permission Checking
105

106
Core functionality for checking the current status of device permissions. Returns status without requesting permission from the user.
107

108
```typescript { .api }
109
function check(permission: Permission): Promise<PermissionStatus>;
110

111
function checkMultiple<P extends Permission[]>(
112
  permissions: P
113
): Promise<Record<P[number], PermissionStatus>>;
114
```
115

116
[Permission Checking](./permission-checking.md)
117

118
### Permission Requesting  
119

120
Request permissions from the user with optional rationale dialogs. Handles the native permission request flow.
121

122
```typescript { .api }
123
function request(permission: Permission, rationale?: Rationale): Promise<PermissionStatus>;
124

125
function requestMultiple<P extends Permission[]>(
126
  permissions: P
127
): Promise<Record<P[number], PermissionStatus>>;
128

129
type Rationale = RationaleObject | (() => Promise<boolean>);
130

131
interface RationaleObject {
132
  title: string;
133
  message: string;
134
  buttonPositive: string;
135
  buttonNegative?: string;
136
}
137
```
138

139
[Permission Requesting](./permission-requesting.md)
140

141
### Notification Permissions
142

143
Specialized handling for notification permissions with granular control over notification types and settings.
144

145
```typescript { .api }
146
function checkNotifications(): Promise<NotificationsResponse>;
147

148
function requestNotifications(
149
  options?: NotificationOption[],
150
  rationale?: Rationale
151
): Promise<NotificationsResponse>;
152

153
interface NotificationsResponse {
154
  status: PermissionStatus;
155
  settings: NotificationSettings;
156
}
157

158
type NotificationOption = 
159
  | 'alert'
160
  | 'badge' 
161
  | 'sound'
162
  | 'carPlay'
163
  | 'criticalAlert'
164
  | 'provisional'
165
  | 'providesAppSettings';
166
```
167

168
[Notification Permissions](./notification-permissions.md)
169

170
### Platform-Specific Features
171

172
iOS location accuracy control, Android alarm permissions, and other platform-specific functionality.
173

174
```typescript { .api }
175
// iOS location accuracy
176
function checkLocationAccuracy(): Promise<LocationAccuracy>;
177
function requestLocationAccuracy(options: LocationAccuracyOptions): Promise<LocationAccuracy>;
178

179
// iOS photo picker
180
function openPhotoPicker(): Promise<void>;
181

182
// Android alarm permissions  
183
function canScheduleExactAlarms(): Promise<boolean>;
184
function canUseFullScreenIntent(): Promise<boolean>;
185

186
// Settings access
187
function openSettings(type?: 'application' | 'alarms' | 'fullscreen' | 'notifications'): Promise<void>;
188
```
189

190
[Platform-Specific Features](./platform-specific-features.md)
191

192
### Permission Constants
193

194
Platform-specific permission identifiers organized by operating system. Each platform provides different permission types.
195

196
```typescript { .api }
197
interface PermissionsConstants {
198
  ANDROID: AndroidPermissionMap;
199
  IOS: IOSPermissionMap; 
200
  WINDOWS: WindowsPermissionMap;
201
}
202

203
declare const PERMISSIONS: PermissionsConstants;
204
```
205

206
[Permission Constants](./permission-constants.md)
207

208
## Core Types  
209

210
```typescript { .api }
211
// Union of all platform permission types
212
type Permission = AndroidPermission | IOSPermission | WindowsPermission;
213

214
// Possible permission states
215
type PermissionStatus = 'unavailable' | 'blocked' | 'denied' | 'granted' | 'limited';
216

217
// iOS location accuracy levels
218
type LocationAccuracy = 'full' | 'reduced';
219

220
interface LocationAccuracyOptions {
221
  purposeKey: string;
222
}
223

224
// Notification settings object
225
interface NotificationSettings {
226
  alert?: boolean;
227
  badge?: boolean;
228
  sound?: boolean;
229
  carPlay?: boolean;
230
  criticalAlert?: boolean;
231
  provisional?: boolean;
232
  providesAppSettings?: boolean;
233
  lockScreen?: boolean;
234
  notificationCenter?: boolean;
235
}
236

237
// Permission status constants
238
declare const RESULTS: {
239
  readonly UNAVAILABLE: 'unavailable';
240
  readonly BLOCKED: 'blocked';
241
  readonly DENIED: 'denied';
242
  readonly GRANTED: 'granted';
243
  readonly LIMITED: 'limited';
244
};
245
```