React Native permissions are not a single cross-platform switch. This guide gives you a repeatable way to map device capabilities, estimate implementation effort, choose between platform APIs and libraries, write useful permission explanations, and test first requests, denial recovery, limited access, settings redirects, and Expo development builds on both iOS and Android.
Overview
A permission flow has four separate concerns: declaring access in the native project, asking at the right moment, responding to the resulting state, and testing what happens after the user changes the decision. Treating these as one task is a common source of bugs. A request may appear to work in development while a release build lacks the required declaration, or a previously denied permission may need a different recovery path than a first request.
Start with a capability inventory rather than a library choice. For every feature, record the device resource it needs, the platform-specific permission or permissions involved, whether access is required in the foreground or background, and what the app can do when access is unavailable. Camera, microphone, contacts, location, notifications, and photos should each have an explicit product decision. Avoid requesting a group of unrelated permissions at startup simply because they are available.
For many teams, the decision is between direct platform APIs, a focused Expo module, or a general-purpose package such as react-native-permissions. The best option depends on the project’s native workflow, supported operating systems, New Architecture compatibility, testing needs, and how much control the team requires over platform-specific states. Check package maintenance, native configuration requirements, and compatibility before adding a dependency. The React Native native module compatibility guide is useful when evaluating that integration boundary.
How to estimate
Estimate permission work by scoring each capability across five inputs: native configuration, request-flow complexity, fallback behavior, test coverage, and release review risk. A simple worksheet makes estimates repeatable:
- Identify the capability. Name the user action, such as scanning a receipt with the camera or selecting a profile image.
- Separate iOS and Android behavior. Record the required native declarations, request method, possible result states, and settings path for each platform.
- Count user journeys. Include first request, temporary or limited access where applicable, denial, repeated denial, restricted access, revoked access, and unavailable hardware.
- Define the fallback. Decide whether the feature is blocked, degraded, replaced by a picker, or available through a manual workflow.
- Assign test cases. Include clean-install tests, upgrade tests, app-relaunch tests, and tests after changing access in system settings.
- Add release checks. Verify the manifest, Info.plist entries, build configuration, user-facing explanation, and store submission metadata against the current platform guidance.
Use a relative effort scale instead of pretending that every project has the same cost. A camera-only flow with a clear fallback may be low complexity. Background location, contacts synchronization, or a feature that combines camera, microphone, and storage can be high complexity because the state space and user explanation are broader. The estimate should increase when a capability is needed during background execution, must work offline, affects a critical transaction, or depends on several native modules.
| Capability | Typical decision points | Estimation signal |
|---|---|---|
| Camera | Capture required or optional; fallback to file or gallery picker | Moderate when capture is isolated; higher when combined with scanning |
| Microphone | Recording duration, interruption handling, unavailable input | Moderate to high |
| Location | Foreground versus background; approximate or precise needs | High when background behavior is required |
| Notifications | Permission timing, quiet states, deep links from a notification | Moderate; test cold and warm launches |
| Photos | Select versus save; full, limited, or user-selected access | Moderate; limited-access UX matters |
| Contacts | One-time lookup versus synchronization and revocation | High when data is persisted or synced |
Inputs and assumptions
Before implementation, maintain a permission matrix in the repository or product documentation. It should be specific enough that a developer, tester, and reviewer can reach the same conclusion without inspecting source code.
| State or event | Application response | QA check |
|---|---|---|
| Not determined | Explain the immediate value, then request from the user-triggered flow | Confirm the prompt appears once and the feature resumes after approval |
| Granted | Proceed and handle a later revocation gracefully | Use the feature, relaunch, and verify access remains correctly interpreted |
| Denied | Show a concise recovery message and a useful alternative | Deny, retry where appropriate, and confirm the app does not loop prompts |
| Limited or selected access | Use the permitted subset and offer a way to manage selection when supported | Choose a partial set, add or remove an item, and reopen the flow |
| Blocked or restricted | Explain that access must be changed outside the app; provide a settings action only when appropriate | Change the system setting, return to the app, and re-check state |
| Unavailable | Disable the dependent action or provide a non-device alternative | Test unsupported hardware, simulator limitations, and interrupted requests |
Native declarations are part of the feature, not a final build cleanup. iOS commonly requires purpose text in Info.plist. Android requires the relevant manifest declarations and may distinguish foreground and background access. Exact keys, behavior, and store expectations can change, so verify them against the current Apple and Android documentation before release. In an Expo project, use the module’s supported app configuration and config plugin path, then create a development build when native configuration cannot be represented by Expo Go alone. Rebuild after changing native permission configuration; JavaScript reloads do not replace a native rebuild.
User-facing rationale should be concrete and proportional. For example: “Allow camera access to scan the invoice on this screen.” For location: “Allow location while using the app to show nearby delivery options.” Do not promise functionality the app does not provide, and do not describe a permission as mandatory when the user can continue another way. Ask close to the action that needs access, keep the explanation short, and let the system prompt provide the formal choice.
Worked examples
Camera capture in an Expo development build
First, document that camera access is needed only when the user selects “Scan.” Configure the native declaration through the chosen Expo module and build profile. In the screen, check the current state, show the in-context explanation, request access, and then open the camera only after approval. If the user denies access, keep the scan screen usable with a manual-entry or file-upload alternative. If access is blocked, explain that it can be changed in system settings without repeatedly calling the request method.
Test on a fresh installation, after denial, after revocation in settings, after an app restart, and on a simulator where camera behavior may differ from a physical device. Confirm that an interrupted request does not leave the interface permanently loading. If the module is native, also verify it against the project’s React Native version and architecture settings; the native module compatibility guide can help structure that check.
Photo selection with limited access
Separate “choose a photo” from “scan with the camera.” A picker may provide a narrower and more appropriate access path than broad library access. Your matrix should state whether the app needs one selected item, repeated access to a collection, or the ability to save an edited result. Test a user who selects only some items, removes a previously selected item, cancels the picker, and returns from settings. The UI should describe what is missing rather than treating limited access as a generic failure.
Notifications and deep links
Request notification access when the user understands the benefit, such as enabling a reminder they just created. Test approval and denial, but also test the notification’s destination when the app is closed, backgrounded, or already open. A permission test is incomplete if the prompt works but the resulting navigation loses the relevant record or screen. For broader release coverage, combine permission cases with the end-to-end strategy described in the React Native testing tools comparison.
When to recalculate
Revisit the matrix whenever a feature adds a device capability, changes from foreground to background use, introduces a new native module, or changes its fallback. Recalculate before supporting a new major iOS or Android version, upgrading React Native or Expo, enabling a different architecture, or changing build profiles. A dependency update can alter configuration requirements even when the JavaScript API looks unchanged.
Make permission review part of release readiness rather than an annual surprise. Run the full matrix on at least one representative iOS device and Android device, then add targeted checks for OS versions and hardware that matter to your users. Include clean install, upgrade, denial, limited access, settings revocation, offline behavior, and interrupted-request cases. Store the results with the release candidate so regressions are traceable.
Finally, monitor production symptoms without collecting more personal data than necessary. Permission-related crashes, failed uploads, empty contact imports, and abandoned onboarding steps can reveal a broken state transition. Pair those signals with crash reporting and release triage practices from the React Native crash reporting guide. When an issue appears, reproduce the exact permission state first, then check native declarations, library compatibility, and the post-settings recheck. That workflow turns permissions from a one-time implementation task into a maintainable part of your React Native app development stack.