react-native-permission-flow 0.1.25

package/plugin/build/index.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("expo/config-plugins");
+// ─── Permission Maps ───────────────────────────────────────────────────────────
+/** Simple 1-to-1 mapping: plugin key → single Android manifest permission. */
+const SIMPLE_PERMISSION_MAP = {
+    batteryOptimization: 'android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS',
+    overlay: 'android.permission.SYSTEM_ALERT_WINDOW',
+    usageStats: 'android.permission.PACKAGE_USAGE_STATS',
+    exactAlarm: 'android.permission.SCHEDULE_EXACT_ALARM',
+    useExactAlarm: 'android.permission.USE_EXACT_ALARM',
+    fullScreenIntent: 'android.permission.USE_FULL_SCREEN_INTENT',
+    dndAccess: 'android.permission.ACCESS_NOTIFICATION_POLICY',
+    notifications: 'android.permission.POST_NOTIFICATIONS',
+};
+/** Location requires both fine and coarse (Google Play requirement). */
+const LOCATION_PERMISSIONS = [
+    'android.permission.ACCESS_FINE_LOCATION',
+    'android.permission.ACCESS_COARSE_LOCATION',
+];
+/**
+ * Granular media permission mapping.
+ * - 'media' (bare) = ALL media permissions (backward compatible)
+ * - 'media:photo' = only photo-related permissions
+ * - 'media:video' = only video-related permissions
+ * - 'media:audio' = only audio-related permissions
+ * - 'media:all' = MANAGE_EXTERNAL_STORAGE (full file manager access)
+ *
+ * Legacy READ/WRITE_EXTERNAL_STORAGE are shared across photo/video/audio for pre-API 33 devices.
+ */
+const MEDIA_BASE_PERMISSIONS = [
+    'android.permission.READ_EXTERNAL_STORAGE',
+    'android.permission.WRITE_EXTERNAL_STORAGE',
+];
+const MEDIA_TYPE_MAP = {
+    photo: [
+        'android.permission.READ_MEDIA_IMAGES',
+        'android.permission.READ_MEDIA_VISUAL_USER_SELECTED',
+    ],
+    video: [
+        'android.permission.READ_MEDIA_VIDEO',
+        'android.permission.READ_MEDIA_VISUAL_USER_SELECTED',
+    ],
+    audio: [
+        'android.permission.READ_MEDIA_AUDIO',
+    ],
+    all: [
+        'android.permission.MANAGE_EXTERNAL_STORAGE',
+    ],
+};
+/** Full set of all media permissions (for backward-compatible bare 'media' key). */
+const ALL_MEDIA_PERMISSIONS = [
+    ...MEDIA_BASE_PERMISSIONS,
+    ...new Set(Object.values(MEDIA_TYPE_MAP).reduce((acc, val) => acc.concat(val), [])),
+];
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+/** Safely adds a list of Android permissions, skipping any that already exist. */
+function addPermissions(usesPermission, existingPermissions, permissionsToAdd) {
+    for (const perm of permissionsToAdd) {
+        if (!existingPermissions.includes(perm)) {
+            usesPermission.push({ $: { 'android:name': perm } });
+        }
+    }
+}
+/**
+ * Parses 'media', 'media:photo', 'media:video', 'media:audio', 'media:all'
+ * from the permissions array and returns the Android permissions to inject.
+ */
+function resolveMediaPermissions(permissions) {
+    // Check for bare 'media' (backward compatible — adds everything)
+    if (permissions.includes('media')) {
+        return ALL_MEDIA_PERMISSIONS;
+    }
+    // Check for granular 'media:photo', 'media:video', etc.
+    const mediaTypes = permissions
+        .filter((p) => p.startsWith('media:'))
+        .map((p) => p.split(':')[1]);
+    if (mediaTypes.length === 0)
+        return [];
+    // Collect the unique permissions needed for the requested types
+    const perms = new Set(MEDIA_BASE_PERMISSIONS); // always include legacy
+    for (const type of mediaTypes) {
+        const typePerms = MEDIA_TYPE_MAP[type];
+        if (typePerms) {
+            typePerms.forEach((p) => perms.add(p));
+        }
+    }
+    return [...perms];
+}
+/** Returns true if any media-related permission key is present. */
+function hasMediaPermission(permissions) {
+    return permissions.some((p) => p === 'media' || p.startsWith('media:'));
+}
+// ─── Plugin ────────────────────────────────────────────────────────────────────
+const withPermissionKit = (config, props) => {
+    var _a, _b, _c;
+    const permissions = (props === null || props === void 0 ? void 0 : props.permissions) || [];
+    const locationDescription = (_a = props === null || props === void 0 ? void 0 : props.locationDescription) !== null && _a !== void 0 ? _a : '$(PRODUCT_NAME) needs access to your location.';
+    const photoDescription = (_b = props === null || props === void 0 ? void 0 : props.photoDescription) !== null && _b !== void 0 ? _b : '$(PRODUCT_NAME) needs access to your photos.';
+    const appleMusicDescription = (_c = props === null || props === void 0 ? void 0 : props.appleMusicDescription) !== null && _c !== void 0 ? _c : '$(PRODUCT_NAME) needs access to your music.';
+    // ─── Android Manifest permissions ─────────────────────────────────────────
+    const hasAnyAndroidPermission = permissions.some((p) => p in SIMPLE_PERMISSION_MAP || p === 'location' || p === 'media' || p.startsWith('media:'));
+    if (hasAnyAndroidPermission) {
+        config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+            const androidManifest = config.modResults;
+            if (!androidManifest.manifest['uses-permission']) {
+                androidManifest.manifest['uses-permission'] = [];
+            }
+            const usesPermission = androidManifest.manifest['uses-permission'];
+            const existingPermissions = usesPermission.map((p) => p.$['android:name']);
+            // Simple 1-to-1 permissions
+            for (const [key, androidPermission] of Object.entries(SIMPLE_PERMISSION_MAP)) {
+                if (permissions.includes(key)) {
+                    addPermissions(usesPermission, existingPermissions, [androidPermission]);
+                }
+            }
+            // Location (1-to-many)
+            if (permissions.includes('location')) {
+                addPermissions(usesPermission, existingPermissions, LOCATION_PERMISSIONS);
+            }
+            // Media — supports both bare 'media' and granular 'media:photo', 'media:video', etc.
+            const mediaPerms = resolveMediaPermissions(permissions);
+            if (mediaPerms.length > 0) {
+                addPermissions(usesPermission, existingPermissions, mediaPerms);
+            }
+            return config;
+        });
+    }
+    // ─── iOS Info.plist ───────────────────────────────────────────────────────
+    const needsMediaPlist = hasMediaPermission(permissions);
+    if (permissions.includes('location') || needsMediaPlist) {
+        config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
+            if (permissions.includes('location')) {
+                config.modResults['NSLocationWhenInUseUsageDescription'] = locationDescription;
+            }
+            if (needsMediaPlist) {
+                // Determine which iOS plist entries are needed
+                const mediaTypes = permissions.includes('media')
+                    ? ['photo', 'video', 'audio'] // bare 'media' = all types
+                    : permissions.filter((p) => p.startsWith('media:')).map((p) => p.split(':')[1]);
+                if (mediaTypes.includes('photo') || mediaTypes.includes('video')) {
+                    config.modResults['NSPhotoLibraryUsageDescription'] = photoDescription;
+                }
+                if (mediaTypes.includes('audio')) {
+                    config.modResults['NSAppleMusicUsageDescription'] = appleMusicDescription;
+                }
+            }
+            return config;
+        });
+    }
+    return config;
+};
+exports.default = withPermissionKit;

package/src/ExpoPermissionKit.types.ts

@@ -0,0 +1 @@
+// Define your exported module types here.

package/src/ExpoPermissionKitModule.ts

@@ -0,0 +1,64 @@
+import { requireNativeModule } from 'expo';
+
+export interface PermissionKitNativeModule {
+  isBatteryOptimizationEnabled(): Promise<boolean>;
+  openBatteryOptimizationSettings(): Promise<void>;
+  isOverlayPermissionEnabled(): Promise<boolean>;
+  openOverlayPermissionSettings(): Promise<void>;
+  isUsageStatsPermissionEnabled(): Promise<boolean>;
+  openUsageStatsSettings(): Promise<void>;
+  isExactAlarmPermissionEnabled(): Promise<boolean>;
+  openExactAlarmSettings(): Promise<void>;
+  isFullScreenIntentPermissionEnabled(): Promise<boolean>;
+  openFullScreenIntentSettings(): Promise<void>;
+  isAccessibilityPermissionEnabled(serviceName: string): Promise<boolean>;
+  openAccessibilitySettings(): Promise<void>;
+  isDndAccessPermissionEnabled(): Promise<boolean>;
+  openDndAccessSettings(): Promise<void>;
+  checkNotificationsStatus(): Promise<{ granted: boolean; canAskAgain: boolean }>;
+  requestNotifications(): Promise<{ granted: boolean; canAskAgain: boolean }>;
+  openNotificationSettings(): Promise<void>;
+  checkLocationStatus(): Promise<{
+    granted: boolean;
+    canAskAgain: boolean;
+    restricted: boolean;
+    servicesEnabled: boolean;
+  }>;
+  requestLocation(timeoutMs: number, accuracy: string): Promise<
+    | { status: 'granted'; latitude: number; longitude: number; accuracy: number; altitude: number; timestamp: number }
+    | { status: 'granted'; error: 'TIMEOUT' | 'LOCATION_UNAVAILABLE' }
+    | { status: 'denied'; canAskAgain: boolean }
+    | { status: 'denied'; error: 'LOCATION_SERVICES_DISABLED' }
+    | { status: 'restricted' }
+  >;
+  /** Request location permission only — no GPS fetch. */
+  requestLocationPermissionOnly(): Promise<
+    | { status: 'granted' }
+    | { status: 'denied'; canAskAgain: boolean }
+    | { status: 'restricted' }
+  >;
+  /** Show a native alert dialog guiding the user to Settings. Resolves when dismissed. */
+  showPermissionAlertAndOpenSettings(title: string, description: string, settingsType: string): Promise<void>;
+  openLocationSettings(): Promise<void>;
+  openAppLocationSettings(): Promise<void>;
+  checkMediaStatus(type: string): Promise<{
+    status: 'granted' | 'limited' | 'denied' | 'restricted' | 'unavailable';
+    canAskAgain?: boolean;
+  }>;
+  requestMedia(type: string): Promise<{
+    status: 'granted' | 'limited' | 'denied' | 'restricted' | 'unavailable';
+    canAskAgain?: boolean;
+  }>;
+  openMediaSettings(): Promise<void>;
+  openAllFilesSettings(): Promise<void>;
+  presentLimitedLibraryPicker(): Promise<void>;
+}
+
+let _nativeModule: PermissionKitNativeModule | null = null;
+try {
+  _nativeModule = requireNativeModule<PermissionKitNativeModule>('ExpoPermissionKit');
+} catch {
+  // Native module not available on this platform (e.g., iOS simulator, web)
+}
+
+export default _nativeModule;

package/src/ExpoPermissionKitModule.web.ts

@@ -0,0 +1,6 @@
+import { registerWebModule, NativeModule } from 'expo';
+
+// ExpoPermissionKitModule is not available on the web platform.
+class ExpoPermissionKitModule extends NativeModule<{}> {}
+
+export default registerWebModule(ExpoPermissionKitModule, 'ExpoPermissionKitModule');

package/src/PermissionKit.ts

@@ -0,0 +1,376 @@
+import { Alert, AppState, Platform, ToastAndroid } from 'react-native';
+import NativeModule from './ExpoPermissionKitModule';
+import {
+  AccessibilityOptions,
+  AndroidSettingsResult,
+  BaseAlertOptions,
+  LocationOptions,
+  LocationPermissionStatus,
+  LocationResult,
+  MediaOptions,
+  MediaResult,
+  NotificationOptions
+} from './types';
+
+/** Fallback native message (Toast for Android, Alert for iOS) */
+const showNativeMessage = (message: string) => {
+  if (Platform.OS === 'android') {
+    ToastAndroid.show(message, ToastAndroid.LONG);
+  } else {
+    Alert.alert('Notice', message, [{ text: 'OK' }]);
+  }
+};
+
+/** Wait for the app to resume from background (e.g. after opening Settings). */
+function waitForResume(): Promise<void> {
+  return new Promise(resolve => {
+    let wentToBackground = false;
+
+    const sub = AppState.addEventListener('change', (state) => {
+      if (state === 'background' || state === 'inactive') {
+        wentToBackground = true;
+      }
+
+      if (state === 'active' && wentToBackground) {
+        sub.remove();
+        // Short delay to allow the OS to propagate permission changes
+        setTimeout(resolve, 400);
+      }
+    });
+  });
+}
+
+/** Handles the native alert popup when a runtime permission is permanently denied. */
+async function handlePermanentDenialAlert(
+  status: string,
+  canAskAgain: boolean | undefined,
+  settingsType: 'notifications' | 'location' | 'media',
+  opts?: BaseAlertOptions,
+  defaultTitle?: string,
+  defaultDescription?: string
+) {
+  if (status === 'denied' && canAskAgain === false && opts?.showAlert !== false) {
+    const title = opts?.alertTitle ?? defaultTitle ?? `${settingsType} Permission Required`;
+    const description = opts?.alertDescription ?? defaultDescription ?? `Please enable ${settingsType} access in Settings to continue.`;
+    await NativeModule!.showPermissionAlertAndOpenSettings(title, description, settingsType);
+  }
+}
+
+/**
+ * Generic check for any Android settings-based permission.
+ * Returns 'unavailable' on iOS, 'granted'/'denied' based on the native check.
+ */
+async function checkAndroidSettingsPermission(
+  checkFn: () => Promise<boolean>,
+): Promise<AndroidSettingsResult> {
+  if (Platform.OS === 'ios' || !NativeModule) {
+    return { status: 'unavailable' };
+  }
+  const enabled = await checkFn();
+  return { status: enabled ? 'granted' : 'denied' };
+}
+
+/**
+ * Generic request for any Android settings-based permission.
+ * Handles: check → open settings → catch MISSING_PERMISSION → waitForResume → re-check.
+ */
+async function requestAndroidSettingsPermission(
+  pluginName: string,
+  checkFn: () => Promise<AndroidSettingsResult>,
+  openSettingsFn: () => Promise<void>,
+): Promise<AndroidSettingsResult> {
+  if (Platform.OS === 'ios' || !NativeModule) {
+    return { status: 'unavailable' };
+  }
+
+  const check = await checkFn();
+  if (check.status === 'granted') return check;
+
+  try {
+    await openSettingsFn();
+  } catch (error: any) {
+    if (error?.message?.includes('MISSING_PERMISSION')) {
+      console.warn(
+        `[react-native-permission-flow] Missing Permission: You forgot to add '${pluginName}' to your app.json plugin.`
+      );
+      return { status: 'denied' };
+    }
+    throw error;
+  }
+
+  await waitForResume();
+  return await checkFn();
+}
+
+// ─── Android Settings-Based Permissions (DRY) ─────────────────────────────────
+
+export const checkBatteryOptimization = () =>
+  checkAndroidSettingsPermission(() => NativeModule!.isBatteryOptimizationEnabled());
+
+export const batteryOptimization = () =>
+  requestAndroidSettingsPermission('batteryOptimization', checkBatteryOptimization, () => NativeModule!.openBatteryOptimizationSettings());
+
+export const checkOverlay = () =>
+  checkAndroidSettingsPermission(() => NativeModule!.isOverlayPermissionEnabled());
+
+export const overlay = () =>
+  requestAndroidSettingsPermission('overlay', checkOverlay, () => NativeModule!.openOverlayPermissionSettings());
+
+export const checkUsageStats = () =>
+  checkAndroidSettingsPermission(() => NativeModule!.isUsageStatsPermissionEnabled());
+
+export const usageStats = () =>
+  requestAndroidSettingsPermission('usageStats', checkUsageStats, () => NativeModule!.openUsageStatsSettings());
+
+export const checkExactAlarm = () =>
+  checkAndroidSettingsPermission(() => NativeModule!.isExactAlarmPermissionEnabled());
+
+export const exactAlarm = () =>
+  requestAndroidSettingsPermission('exactAlarm', checkExactAlarm, () => NativeModule!.openExactAlarmSettings());
+
+export const checkFullScreenIntent = () =>
+  checkAndroidSettingsPermission(() => NativeModule!.isFullScreenIntentPermissionEnabled());
+
+export const fullScreenIntent = () =>
+  requestAndroidSettingsPermission('fullScreenIntent', checkFullScreenIntent, () => NativeModule!.openFullScreenIntentSettings());
+
+export const checkDndAccess = () =>
+  checkAndroidSettingsPermission(() => NativeModule!.isDndAccessPermissionEnabled());
+
+export const dndAccess = () =>
+  requestAndroidSettingsPermission('dndAccess', checkDndAccess, () => NativeModule!.openDndAccessSettings());
+
+// ─── Accessibility (slightly different — takes runtime options, no MISSING_PERMISSION check) ───
+
+export async function checkAccessibility(options: AccessibilityOptions) {
+  if (Platform.OS === 'ios' || !NativeModule) {
+    return { status: 'unavailable' as const };
+  }
+  const enabled = await NativeModule.isAccessibilityPermissionEnabled(options.androidServicePath);
+  return {
+    status: (enabled ? 'granted' : 'denied') as 'granted' | 'denied',
+  };
+}
+
+export async function accessibility(options: AccessibilityOptions) {
+  if (Platform.OS === 'ios' || !NativeModule) {
+    return { status: 'unavailable' as const };
+  }
+
+  const check = await checkAccessibility(options);
+  if (check.status === 'granted') return check;
+
+  await NativeModule.openAccessibilitySettings();
+  await waitForResume();
+
+  return await checkAccessibility(options);
+}
+
+// ─── Notifications (cross-platform, runtime dialog, canAskAgain logic) ─────
+
+export async function checkNotifications() {
+  if (!NativeModule) {
+    return { status: 'unavailable' as const };
+  }
+  const result = await NativeModule.checkNotificationsStatus();
+  return {
+    status: (result.granted ? 'granted' : 'denied') as 'granted' | 'denied',
+    canAskAgain: result.canAskAgain,
+  };
+}
+
+export async function notifications(opts?: NotificationOptions) {
+  if (!NativeModule) {
+    return { status: 'unavailable' as const };
+  }
+
+  const check = await checkNotifications();
+
+  // Already granted — nothing to do
+  if (check.status === 'granted') {
+    return { status: 'granted' as const };
+  }
+
+  if (check.canAskAgain) {
+    // OS dialog CAN be shown — request it and let the user decide
+    const requested = await NativeModule.requestNotifications();
+    return {
+      status: (requested.granted ? 'granted' : 'denied') as 'granted' | 'denied',
+      canAskAgain: requested.canAskAgain,
+    };
+  }
+
+  // Permanently denied — show native alert if caller opted in (default: true)
+  await handlePermanentDenialAlert(
+    'denied',
+    false,
+    'notifications',
+    opts,
+    'Notifications Required',
+    'Please enable notifications in Settings to continue.'
+  );
+
+  return { status: 'denied' as const, canAskAgain: false };
+}
+
+// ─── Location (cross-platform, GPS fetch, services check, error alerts) ────
+
+/**
+ * Read-only permission status check. No prompts, no GPS hardware.
+ * Use this to know the current state before calling location().
+ */
+export async function checkLocation(): Promise<LocationPermissionStatus> {
+  if (!NativeModule) {
+    return { status: 'unavailable' };
+  }
+  const s = await NativeModule.checkLocationStatus();
+  if (s.restricted) return { status: 'restricted' };
+  if (s.granted) {
+    // Surface location services being off even when permission is granted
+    if (!s.servicesEnabled) {
+      return { status: 'denied', canAskAgain: false, error: 'LOCATION_SERVICES_DISABLED' };
+    }
+    return { status: 'granted' };
+  }
+  return {
+    status: 'denied',
+    canAskAgain: s.canAskAgain,
+    ...(s.servicesEnabled === false ? { error: 'LOCATION_SERVICES_DISABLED' as const } : {}),
+  };
+}
+
+export async function location(opts?: LocationOptions): Promise<LocationResult> {
+  if (!NativeModule) {
+    return { status: 'unavailable' };
+  }
+
+  const timeoutMs = opts?.timeout ?? 10000;
+  const accuracy = opts?.accuracy ?? 'balanced';
+  const fetchCoordinates = opts?.fetchCoordinates ?? true;
+
+  if (!fetchCoordinates) {
+    // Permission-only mode: request the permission but skip GPS fetch
+    const result = await NativeModule.requestLocationPermissionOnly();
+    return result as LocationResult;
+  }
+
+  // The native layer handles the full lifecycle:
+  //   - iOS: notDetermined → dialog → fetch | denied | restricted
+  //   - Android: no permission → dialog → fetch | denied
+  //   - Both: Location Services OFF → error
+  const result = await NativeModule.requestLocation(timeoutMs, accuracy);
+
+  // Show alert modal if permanently denied and caller opted in (default: true)
+  await handlePermanentDenialAlert(
+    result.status,
+    'canAskAgain' in result ? result.canAskAgain : undefined,
+    'location',
+    opts,
+    'Location Permission Required',
+    'Please enable location access in Settings to continue.'
+  );
+
+  // Show native error toasts/alerts by default (unless explicitly opted out)
+  const showErrorAlerts = opts?.showErrorAlerts ?? true;
+
+  if (showErrorAlerts) {
+    if (result.status === 'denied' && 'error' in result && result.error === 'LOCATION_SERVICES_DISABLED') {
+      showNativeMessage(opts?.errorMessages?.servicesDisabled ?? 'Please turn on location services to continue.');
+    } else if (result.status === 'granted' && 'error' in result && result.error === 'TIMEOUT') {
+      showNativeMessage(opts?.errorMessages?.timeout ?? 'Could not determine your location in time. Please try again.');
+    } else if (result.status === 'granted' && 'error' in result && result.error === 'LOCATION_UNAVAILABLE') {
+      showNativeMessage(opts?.errorMessages?.unavailable ?? 'Location unavailable. Please check your device settings.');
+    }
+  }
+
+  return result as LocationResult;
+}
+
+// ─── Media (cross-platform, fragmentation handling, limited picker) ────────
+
+export async function checkMedia(opts: MediaOptions): Promise<MediaResult> {
+  if (!NativeModule) return { status: 'unavailable' };
+  
+  try {
+    return await NativeModule.checkMediaStatus(opts.type);
+  } catch (error) {
+    return { status: 'unavailable' };
+  }
+}
+
+export async function media(opts: MediaOptions): Promise<MediaResult> {
+  if (!NativeModule) return { status: 'unavailable' };
+
+  // First, check if already granted
+  const check = await checkMedia(opts);
+  if (!opts.requestMore && (check.status === 'granted' || check.status === 'limited' || check.status === 'restricted')) {
+    return check;
+  }
+  
+  if (opts.requestMore && check.status === 'limited' && Platform.OS === 'ios') {
+    await NativeModule.presentLimitedLibraryPicker();
+    // Re-check status after they potentially interacted with the picker.
+    // (Note: on iOS the picker is an out-of-process system UI, but it doesn't background the app, 
+    // so we return immediately. The developer can check status again later if needed)
+    return await checkMedia(opts);
+  }
+
+  // If it's the "all" files permission, we must go straight to settings on Android
+  if (opts.type === 'all' && Platform.OS === 'android') {
+    await NativeModule.openAllFilesSettings();
+    await waitForResume();
+    return await checkMedia(opts);
+  }
+
+  // Request runtime permission
+  let result;
+  try {
+    result = await NativeModule.requestMedia(opts.type);
+  } catch (error: any) {
+    if (error?.message?.includes('MISSING_PERMISSION')) {
+      console.warn(
+        `[react-native-permission-flow] Missing Permission: You forgot to add 'media' to your app.json plugin.`
+      );
+      return { status: 'denied' };
+    }
+    throw error;
+  }
+
+  // Show native alert modal if permanently denied and caller opted in (default: true)
+  await handlePermanentDenialAlert(
+    result.status,
+    result.canAskAgain,
+    'media',
+    opts,
+    'Media Permission Required',
+    'Please enable media access in Settings to continue.'
+  );
+
+  // Denied (whether canAskAgain is true or false) or granted
+  return result;
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────────
+
+export const PermissionKit = {
+  batteryOptimization,
+  checkBatteryOptimization,
+  overlay,
+  checkOverlay,
+  usageStats,
+  checkUsageStats,
+  exactAlarm,
+  checkExactAlarm,
+  fullScreenIntent,
+  checkFullScreenIntent,
+  accessibility,
+  checkAccessibility,
+  dndAccess,
+  checkDndAccess,
+  notifications,
+  checkNotifications,
+  location,
+  checkLocation,
+  media,
+  checkMedia,
+};