Разрешения: спросить, получить отказ, жить с ним

// expo-modules-core 57.0.13 · src/PermissionsInterface.ts; кавычки двойные, doc-комментарии убраны
export enum PermissionStatus {
  GRANTED = "granted",
  UNDETERMINED = "undetermined",
  DENIED = "denied",
}

export type PermissionExpiration = "never" | number;

export type PermissionResponse = {
  status: PermissionStatus;
  expires: PermissionExpiration;
  granted: boolean;
  canAskAgain: boolean;
};

declare function installNativeModuleProxy(providers: Record<string, () => object>): void;
declare function requireNativeModule<T>(name: string): T;
type Answer = "разрешить" | "запретить";
interface PermissionResponse {
  status: "granted" | "denied" | "undetermined";
  granted: boolean;
  canAskAgain: boolean;
}
interface PermissionsModule {
  getPermissionsAsync(): Promise<PermissionResponse>;
  requestPermissionsAsync(): Promise<PermissionResponse>;
}

// модель системы по правилам из таблицы: dialogsLeft — сколько отказов система ещё выслушает
function createPermissionSystem(platform: "ios" | "android", dialogs: Answer[]): PermissionsModule {
  let status: PermissionResponse["status"] = "undetermined";
  let dialogsLeft = platform === "ios" ? 1 : 2;
  const response = (): PermissionResponse => ({
    status,
    granted: status === "granted",
    canAskAgain: status !== "denied" || dialogsLeft > 0,
  });
  return {
    getPermissionsAsync: async () => response(),
    requestPermissionsAsync: async () => {
      if (status === "granted" || dialogsLeft === 0) return response();
      const answer = dialogs.shift() ?? "запретить";
      console.log("диалог системы:", answer);
      status = answer === "разрешить" ? "granted" : "denied";
      if (status === "denied") dialogsLeft -= 1;
      return response();
    },
  };
}

async function ensureNotifications(): Promise<string> {
  const Permissions = requireNativeModule<PermissionsModule>("ExpoNotificationPermissionsModule");
  const current = await Permissions.getPermissionsAsync();
  if (current.granted) return "уже разрешено";
  if (!current.canAskAgain) return "только через настройки";
  const answer = await Permissions.requestPermissionsAsync();
  if (answer.granted) return "разрешено";
  return answer.canAskAgain ? "отказ, спросим позже" : "отказ навсегда";
}

async function user(name: string, platform: "ios" | "android", dialogs: Answer[], attempts: number) {
  installNativeModuleProxy({ ExpoNotificationPermissionsModule: () => createPermissionSystem(platform, dialogs) });
  for (let i = 1; i <= attempts; i++) console.log(name + ", попытка " + i + ":", await ensureNotifications());
}

user("Лена, iPhone", "ios", ["разрешить"], 2)
  .then(() => user("Олег, iPhone", "ios", ["запретить"], 2))
  .then(() => user("Олег, Android", "android", ["запретить", "запретить"], 3));

declare function installNativeModuleProxy(providers: Record<string, () => object>): void;
declare function requireNativeModule<T>(name: string): T;
declare function createPermissionSystem(platform: "ios" | "android", script: { dialogs: string[] }): object;
const { Text, Pressable } = ReactNative;

interface PermissionResponse {
  status: "granted" | "denied" | "undetermined";
  granted: boolean;
  canAskAgain: boolean;
}
type PermissionMethod = () => Promise<PermissionResponse>;
type PermissionsModule = Record<"getPermissionsAsync" | "requestPermissionsAsync", PermissionMethod>;

// createPermissionHook из expo-modules-core 57 — без опций запроса и без флага isMounted
function createPermissionHook(methods: { getMethod: PermissionMethod; requestMethod: PermissionMethod }) {
  return function usePermission(): [PermissionResponse | null, PermissionMethod, PermissionMethod] {
    const [status, setStatus] = React.useState<PermissionResponse | null>(null);
    const settle = (response: PermissionResponse) => {
      setStatus(response);
      return response;
    };
    const getPermission = React.useCallback(() => methods.getMethod().then(settle), []);
    const requestPermission = React.useCallback(() => methods.requestMethod().then(settle), []);
    React.useEffect(() => {
      getPermission();
    }, [getPermission]);
    return [status, requestPermission, getPermission];
  };
}

installNativeModuleProxy({
  ExpoNotificationPermissionsModule: () => createPermissionSystem("android", { dialogs: ["запретить", "запретить"] }),
});
const Permissions = requireNativeModule<PermissionsModule>("ExpoNotificationPermissionsModule");
// так же в expo-image-picker собран useCameraPermissions
const useNotificationPermissions = createPermissionHook({
  getMethod: () => Permissions.getPermissionsAsync(),
  requestMethod: () => Permissions.requestPermissionsAsync(),
});

function RestReminder() {
  const [permission, requestPermission] = useNotificationPermissions();
  const screen = !permission ? "" : permission.granted ? "Напоминания включены"
    : permission.canAskAgain ? "Напоминать, когда отдых кончится" : "Включить уведомления можно в настройках";
  React.useEffect(() => {
    if (screen) console.log("экран:", screen);
  }, [screen]);
  return (
    <Pressable testID="ask" onPress={requestPermission}>
      <Text>{screen}</Text>
    </Pressable>
  );
}

mount(<RestReminder />);
setTimeout(() => fireEvent.press("ask"), 100);
setTimeout(() => fireEvent.press("ask"), 200);

// react-native 0.86.0 · Libraries/PermissionsAndroid/PermissionsAndroid.js, метод request;
// кавычки двойные, комментарии Flow убраны
if (rationale) {
  const shouldShowRationale =
    await NativePermissionsAndroid.shouldShowRequestPermissionRationale(
      permission,
    );

  if (shouldShowRationale && !!NativeDialogManagerAndroid) {
    return new Promise((resolve, reject) => {
      const options: DialogOptions = {
        ...rationale,
      };
      NativeDialogManagerAndroid.showAlert(
        options,
        () => reject(new Error("Error showing rationale")),
        () =>
          resolve(NativePermissionsAndroid.requestPermission(permission)),
      );
    });
  }
}
return NativePermissionsAndroid.requestPermission(permission);

declare function installNativeModuleProxy(providers: Record<string, () => object>): void;
declare function requireNativeModule<T>(name: string): T;
declare function createPermissionSystem(platform: "ios" | "android", script: { dialogs: string[]; settings?: string }): object;
declare function createPermissionHook(methods: { getMethod: PermissionMethod; requestMethod: PermissionMethod }): () => [PermissionResponse | null, PermissionMethod, PermissionMethod];
// модель Linking.openSettings(): пользователь уходит в настройки, щёлкает переключатель и возвращается
declare function openSettings(): Promise<void>;
interface PermissionResponse {
  status: "granted" | "denied" | "undetermined";
  granted: boolean;
  canAskAgain: boolean;
}
type PermissionMethod = () => Promise<PermissionResponse>;
interface ReminderProps {
  recheck: boolean;
}
const { View, Text, AppState } = ReactNative;

installNativeModuleProxy({
  ExpoNotificationPermissionsModule: () => createPermissionSystem("ios", { dialogs: ["запретить"], settings: "включить" }),
});
const Permissions = requireNativeModule<Record<"getPermissionsAsync" | "requestPermissionsAsync", PermissionMethod>>(
  "ExpoNotificationPermissionsModule",
);
const useNotificationPermissions = createPermissionHook({
  getMethod: () => Permissions.getPermissionsAsync(),
  requestMethod: () => Permissions.requestPermissionsAsync(),
});

function Reminder({ recheck }: ReminderProps) {
  const [permission, , getPermission] = useNotificationPermissions();
  React.useEffect(() => {
    if (!recheck) return;
    const sub = AppState.addEventListener("change", (state) => {
      if (state === "active") getPermission();
    });
    return () => sub.remove();
  }, [recheck, getPermission]);
  const screen = !permission ? null : permission.granted ? "напоминания включены" : "совет открыть настройки";
  React.useEffect(() => {
    if (screen) console.log(recheck ? "с проверкой:" : "без проверки:", screen);
  }, [screen]);
  return <Text>{screen}</Text>;
}

// история: Олег отказал в единственном диалоге iPhone, а потом открыл экран отдыха
Permissions.requestPermissionsAsync().then(() => {
  mount(
    <View>
      <Reminder recheck={false} />
      <Reminder recheck={true} />
    </View>,
  );
  setTimeout(openSettings, 100);
});

const { Pressable, Text, Linking } = ReactNative;

function SettingsHint() {
  const openAppSettings = async () => {
    console.log("нажали «Открыть настройки»");
    await Linking.openSettings();
    console.log("настройки открыты");
  };
  return (
    <Pressable testID="settings" onPress={openAppSettings}>
      <Text>Уведомления запрещены. Открыть настройки</Text>
    </Pressable>
  );
}

mount(<SettingsHint />);
setTimeout(() => fireEvent.press("settings"), 100);

// react-native 0.86.0 · Libraries/PermissionsAndroid/PermissionsAndroid.js, метод request; кавычки двойные
async request(
  permission: Permission,
  rationale?: Rationale,
): Promise<PermissionStatus> {
  if (Platform.OS !== "android") {
    console.warn(
      "\"PermissionsAndroid\" module works only for Android platform.",
    );
    return Promise.resolve(this.RESULTS.DENIED);
  }
  // …дальше объяснение и запрос, как в листинге раздела про хук
}

// permission-settings.ts — iOS и Android: у приложения есть своя страница в системных настройках
import { Linking } from "react-native";

export const canOpenSettings = true;
export function openPermissionSettings(): Promise<void> {
  return Linking.openSettings();
}

// permission-settings.web.ts — браузер: такой страницы нет, разрешение меняют в настройках сайта
export const canOpenSettings = false;
export function openPermissionSettings(): Promise<void> {
  return Promise.resolve();
}

import * as Notifications from "expo-notifications";

// expo-notifications 57: своего хука разрешений у пакета нет, только две функции
export async function askRestNotifications(): Promise<boolean> {
  const current = await Notifications.getPermissionsAsync();
  if (current.granted) return true;
  if (!current.canAskAgain) return false;
  // без аргумента пакет просит для iOS allowAlert, allowBadge и allowSound; значок таймеру не нужен
  const answer = await Notifications.requestPermissionsAsync({
    ios: { allowAlert: true, allowSound: true, allowBadge: false },
  });
  return answer.granted;
}

{
  "expo": {
    "plugins": [
      [
        "expo-image-picker",
        {
          "cameraPermission": "«Подход» снимает технику упражнения, чтобы вы сравнили подходы",
          "photosPermission": "«Подход» прикрепляет фото из галереи к тренировке",
          "microphonePermission": false
        }
      ]
    ]
  }
}