Уведомления: планировщик, канал, нажатие

// expo-notifications 57.0.14 · src/scheduleNotificationAsync.ts, сокращено; кавычки двойные
export async function scheduleNotificationAsync(request: NotificationRequestInput): Promise<string> {
  if (!NotificationScheduler.scheduleNotificationAsync) {
    throw new UnavailabilityError("Notifications", "scheduleNotificationAsync");
  }
  return await NotificationScheduler.scheduleNotificationAsync(
    request.identifier ?? uuid.v4(),
    request.content,
    parseTrigger(request.trigger)
  );
}

// из parseTrigger: null — «показать сейчас», а забытый триггер — ошибка
if (userFacingTrigger === undefined) {
  throw new TypeError(
    "Encountered an `undefined` notification trigger. If you want to trigger the notification immediately, pass in an explicit `null` value."
  );
}

declare function bootPhone(platform: "ios" | "android"): void;
declare function launchApp(): void;
declare function killApp(): void;
declare function passTime(seconds: number): Promise<void>;
// setTimeout процесса приложения: в модели он идёт по часам телефона
declare function processTimeout(fn: () => void, seconds: number): void;
declare function requireNativeModule<T>(name: string): T;
declare function uuidV4(): string;
interface NotificationRequestInput {
  identifier?: string;
  content: { title: string; body?: string };
  trigger: { type: "timeInterval"; seconds: number } | null;
}
interface SchedulerModule {
  scheduleNotificationAsync(identifier: string, content: object, trigger: object | null): Promise<string>;
}
const { AppRegistry, Text } = ReactNative;

// scheduleNotificationAsync из expo-notifications 57: identifier — от приложения или свежий uuid,
// триггер переводится в нативную форму (parseTrigger; здесь только timeInterval)
function scheduleNotificationAsync(request: NotificationRequestInput): Promise<string> {
  const Scheduler = requireNativeModule<SchedulerModule>("ExpoNotificationScheduler");
  const trigger = request.trigger && { type: "timeInterval", seconds: request.trigger.seconds, repeats: false };
  return Scheduler.scheduleNotificationAsync(request.identifier ?? uuidV4(), request.content, trigger);
}

function RestScreen() {
  React.useEffect(() => {
    // экранный таймер: секунды считает сам JavaScript
    processTimeout(() => console.log("таймер в JS: отдых окончен"), 90);
    // напоминание: секунды считает система
    scheduleNotificationAsync({
      content: { title: "Отдых окончен", body: "Жим лёжа, подход 3" },
      trigger: { type: "timeInterval", seconds: 90 },
    });
  }, []);
  return <Text>Отдых: 1:30</Text>;
}
AppRegistry.registerComponent("main", () => RestScreen);

async function gym() {
  bootPhone("ios");
  launchApp();
  // телефон положили на скамью, и через 20 секунд система выгрузила процесс
  await passTime(20);
  killApp();
  await passTime(70);
}
gym();

declare function bootPhone(platform: "ios" | "android", permissions?: object): void;
declare function createPermissionSystem(platform: "ios" | "android", script: { dialogs: string[] }): object;
declare function launchApp(): void;
declare function leaveApp(): void;
declare function passTime(seconds: number): Promise<void>;
declare function requireNativeModule<T>(name: string): T;
// обёртка из примера выше, теперь в подложке
declare function scheduleNotificationAsync(request: { content: object; trigger: object | null }): Promise<string>;
interface PermissionsModule {
  requestPermissionsAsync(): Promise<{ granted: boolean; canAskAgain: boolean }>;
}
const { AppRegistry, Text } = ReactNative;
AppRegistry.registerComponent("main", () => () => <Text>Отдых: 1:30</Text>);

async function gym() {
  // Олег на Android 14 ответил «запретить» в первом же окне
  bootPhone("android", createPermissionSystem("android", { dialogs: ["запретить"] }));
  launchApp();
  const Permissions = requireNativeModule<PermissionsModule>("ExpoNotificationPermissionsModule");
  const permission = await Permissions.requestPermissionsAsync();
  console.log("разрешение:", permission.granted, "| спросить снова:", permission.canAskAgain);
  // экран всё равно заводит напоминание: ответ окна он не проверил
  const id = await scheduleNotificationAsync({
    content: { title: "Отдых окончен" },
    trigger: { type: "timeInterval", seconds: 90 },
  });
  console.log("запрос принят, id из", id.length, "символов");
  leaveApp();
  await passTime(90);
}
gym();

declare function bootPhone(platform: "ios" | "android"): void;
declare function launchApp(): void;
declare function passTime(seconds: number): Promise<void>;
declare function requireNativeModule<T>(name: string): T;
// обёртка из первого раздела, в подложке
declare function scheduleNotificationAsync(request: { content: object; trigger: object | null }): Promise<string>;
type NotificationBehavior = Record<"shouldShowBanner" | "shouldShowList" | "shouldPlaySound" | "shouldSetBadge", boolean>;
type HandleEvent = { id: string; notification: object };
interface NotificationHandler {
  handleNotification(notification: object): Promise<NotificationBehavior>;
}
interface HandlerModule {
  addListener(event: "onHandleNotification", listener: (event: HandleEvent) => void): { remove(): void };
  handleNotificationAsync(id: string, behavior: NotificationBehavior): Promise<void>;
}
const { AppRegistry, Text } = ReactNative;

// setNotificationHandler из expo-notifications 57 — без таймаута, без handleError
// и без снятия прежней подписки
function setNotificationHandler(handler: NotificationHandler) {
  const Handler = requireNativeModule<HandlerModule>("ExpoNotificationsHandlerModule");
  Handler.addListener("onHandleNotification", async ({ id, notification }) => {
    const behavior = await handler.handleNotification(notification);
    await Handler.handleNotificationAsync(id, behavior);
  });
}

AppRegistry.registerComponent("main", () => () => <Text>Отдых: 1:30</Text>);
const rest = { content: { title: "Отдых окончен" }, trigger: { type: "timeInterval", seconds: 90 } };

async function gym() {
  bootPhone("ios");
  // Олег не сворачивает приложение и смотрит на таймер
  launchApp();
  await scheduleNotificationAsync(rest);
  await passTime(90);
  setNotificationHandler({
    handleNotification: async () => ({ shouldShowBanner: true, shouldShowList: true, shouldPlaySound: true, shouldSetBadge: false }),
  });
  await scheduleNotificationAsync(rest);
  await passTime(90);
}
gym();

declare function bootPhone(platform: "ios" | "android"): void;
declare function launchApp(): void;
declare function leaveApp(): void;
declare function passTime(seconds: number): Promise<void>;
declare function requireNativeModule<T>(name: string): T;
declare function scheduleNotificationAsync(request: { content: object; trigger: object | null }): Promise<string>;
interface NotificationChannel {
  id: string;
  name: string;
  importance: number;
}
interface ChannelManager {
  setNotificationChannelAsync(id: string, input: { name: string; importance: number }): Promise<NotificationChannel>;
}
// AndroidImportance из expo-notifications 57, две нужные ступени
const AndroidImportance = { DEFAULT: 5, HIGH: 6 };
const { AppRegistry, Text } = ReactNative;
AppRegistry.registerComponent("main", () => () => <Text>Отдых</Text>);

async function afterUpdate() {
  bootPhone("android");
  launchApp();
  const Channels = requireNativeModule<ChannelManager>("ExpoNotificationChannelManager");
  // версия 1.0 создала канал с обычной важностью
  await Channels.setNotificationChannelAsync("rest", { name: "Отдых", importance: AndroidImportance.DEFAULT });
  // версия 1.1 на том же телефоне: конец отдыха должен всплывать поверх экрана
  const rest = await Channels.setNotificationChannelAsync("rest", { name: "Конец отдыха", importance: AndroidImportance.HIGH });
  console.log("канал rest:", rest.name, "| важность", rest.importance);
  leaveApp();
  await scheduleNotificationAsync({
    content: { title: "Отдых окончен" },
    trigger: { type: "timeInterval", seconds: 90, channelId: "rest" },
  });
  // канал stretch приложение так и не создало
  await scheduleNotificationAsync({
    content: { title: "Пора растянуться" },
    trigger: { type: "timeInterval", seconds: 95, channelId: "stretch" },
  });
  await passTime(95);
}
afterUpdate();

declare function bootPhone(platform: "ios" | "android"): void;
declare function launchApp(): void;
declare function leaveApp(): void;
declare function killApp(): void;
declare function passTime(seconds: number): Promise<void>;
declare function tapNotification(): void;
declare function requireNativeModule<T>(name: string): T;
declare function scheduleNotificationAsync(request: { content: object; trigger: object | null }): Promise<string>;
// стек из статьи «Собираем стек экранов с историей»
declare function useStack(first: string): [{ url: string }[], { push(url: string): void }];
type NotificationResponse = { notification: { request: { identifier: string; content: { data: { url: string } } } } };
type ResponseListener = (response: NotificationResponse) => void;
interface EmitterModule {
  addListener(event: "onDidReceiveNotificationResponse", listener: ResponseListener): { remove(): void };
}
const { AppRegistry, Text } = ReactNative;

function Root() {
  const [stack, nav] = useStack("/");
  React.useEffect(() => {
    const Emitter = requireNativeModule<EmitterModule>("ExpoNotificationsEmitter");
    // push кладёт запись функцией-обновителем, поэтому nav первого рендера годится
    const sub = Emitter.addListener("onDidReceiveNotificationResponse", (response) => {
      nav.push(response.notification.request.content.data.url);
    });
    return () => sub.remove();
  }, []);
  console.log("в стеке:", stack.map((e) => e.url).join(" › "));
  return <Text>{stack[stack.length - 1]!.url}</Text>;
}
AppRegistry.registerComponent("main", () => Root);

const rest = {
  content: { title: "Отдых окончен", data: { url: "/workout/w1" } },
  trigger: { type: "timeInterval", seconds: 90 },
};
async function day() {
  bootPhone("ios");
  launchApp();
  await scheduleNotificationAsync(rest);
  leaveApp();
  await passTime(90);
  tapNotification();
  await passTime(10);
  // следующий отдых: телефон заблокирован, и система выгрузила процесс
  await scheduleNotificationAsync(rest);
  killApp();
  await passTime(90);
  tapNotification();
  await passTime(1);
}
day();

declare function bootPhone(platform: "ios" | "android"): void;
declare function launchApp(): void;
declare function leaveApp(): void;
declare function killApp(): void;
declare function passTime(seconds: number): Promise<void>;
declare function tapNotification(): void;
declare function requireNativeModule<T>(name: string): T;
declare function scheduleNotificationAsync(request: { content: object; trigger: object | null }): Promise<string>;
// стек из статьи «Собираем стек экранов с историей»
declare function useStack(first: string): [{ url: string }[], { push(url: string): void }];
type NotificationResponse = { notification: { request: { identifier: string; content: { data: { url: string } } } } };
type ResponseListener = (response: NotificationResponse) => void;
interface EmitterModule {
  addListener(event: "onDidReceiveNotificationResponse", listener: ResponseListener): { remove(): void };
  getLastNotificationResponse(): NotificationResponse | null;
}
const { AppRegistry, Text } = ReactNative;

function Root() {
  const [stack, nav] = useStack("/");
  // одно нажатие может прийти дважды: из getLastNotificationResponse и подпиской
  const handled = React.useRef<string | null>(null);
  React.useEffect(() => {
    const Emitter = requireNativeModule<EmitterModule>("ExpoNotificationsEmitter");
    const open = (response: NotificationResponse | null) => {
      if (!response || response.notification.request.identifier === handled.current) return;
      handled.current = response.notification.request.identifier;
      nav.push(response.notification.request.content.data.url);
    };
    // холодный старт: нажатие случилось до подписки, и его помнит только натив
    open(Emitter.getLastNotificationResponse());
    const sub = Emitter.addListener("onDidReceiveNotificationResponse", open);
    return () => sub.remove();
  }, []);
  console.log("в стеке:", stack.map((e) => e.url).join(" › "));
  return <Text>{stack[stack.length - 1]!.url}</Text>;
}
AppRegistry.registerComponent("main", () => Root);

async function evening() {
  bootPhone("ios");
  launchApp();
  await scheduleNotificationAsync({
    content: { title: "Отдых окончен", data: { url: "/workout/w1" } },
    trigger: { type: "timeInterval", seconds: 90 },
  });
  leaveApp();
  await passTime(60);
  killApp();
  await passTime(30);
  tapNotification();
  await passTime(1);
}
evening();

// features/rest/rest-notifications.ts
import { Platform } from "react-native";
import * as Notifications from "expo-notifications";

// один identifier на все отдыхи: новый отдых заменяет запланированный, а не добавляется к нему
const REST_ID = "rest-end";
const REST_CHANNEL = "rest-end";
type OpenUrl = (url: string) => void;

// зовётся один раз при старте: обработчик у приложения один, новый вызов заменяет прежний
export function configureRestNotifications(): void {
  Notifications.setNotificationHandler({
    handleNotification: async () => ({
      shouldShowBanner: true,
      shouldShowList: true,
      shouldPlaySound: true,
      shouldSetBadge: false,
    }),
  });
  if (Platform.OS === "android") {
    // важность задаётся при создании: обновлением приложения её не поднять, только новым каналом
    void Notifications.setNotificationChannelAsync(REST_CHANNEL, {
      name: "Конец отдыха",
      importance: Notifications.AndroidImportance.HIGH,
    });
  }
}

export function scheduleRestEnd(seconds: number, workoutId: string): Promise<string> {
  return Notifications.scheduleNotificationAsync({
    identifier: REST_ID,
    content: { title: "Отдых окончен", body: "Пора к следующему подходу", data: { url: "/workout/" + workoutId } },
    trigger: { type: Notifications.SchedulableTriggerInputTypes.TIME_INTERVAL, seconds, channelId: REST_CHANNEL },
  });
}

export function cancelRestEnd(): Promise<void> {
  return Notifications.cancelScheduledNotificationAsync(REST_ID);
}

// нажатие: и то, что запустило приложение с холодного старта, и то, что пришло в живой процесс
export function onRestTap(open: OpenUrl): () => void {
  const handle = (response: Notifications.NotificationResponse | null) => {
    const url = response?.notification.request.content.data?.url;
    if (typeof url !== "string") return;
    // разобранное нажатие стираем: иначе следующий монтаж раскладки откроет экран снова
    Notifications.clearLastNotificationResponse();
    open(url);
  };
  handle(Notifications.getLastNotificationResponse());
  const subscription = Notifications.addNotificationResponseReceivedListener(handle);
  return () => subscription.remove();
}

// app/_layout.tsx
import { useEffect } from "react";
import { Stack, router } from "expo-router";
import { configureRestNotifications, onRestTap } from "@/features/rest/rest-notifications";

configureRestNotifications();

export default function RootLayout() {
  // эффект корня выполняется после первого рендера, когда Stack уже смонтирован
  useEffect(() => onRestTap((url) => router.push(url)), []);
  return <Stack />;
}

// features/rest/rest-notifications.web.ts
// веб-версия «Подхода»: планировщика у expo-notifications в браузере нет, и
// scheduleNotificationAsync там отклоняется с UnavailabilityError. Напоминания на вебе просто нет
type OpenUrl = (url: string) => void;

export function configureRestNotifications(): void {}

export async function scheduleRestEnd(_seconds: number, _workoutId: string): Promise<string> {
  return "";
}

export async function cancelRestEnd(): Promise<void> {}

export function onRestTap(_open: OpenUrl): () => void {
  return () => {};
}

// app.config.js приложения автора, фрагмент plugins; кавычки двойные, комментарии сокращены
[
  "expo-notifications",
  {
    // значок и цвет — только для Android: система рисует уведомление своим шаблоном
    icon: "./public/icon-192.png",
    color: "#171717",
    // канал для пушей без channelId: FCM берёт его из манифеста, а приложение
    // создаёт канал с тем же id на старте
    defaultChannel: "default",
  },
],