npx expo install expo-notifications expo-device

import * as Notifications from 'expo-notifications';
import * as Device from 'expo-device';

async function requestNotificationPermission(): Promise<boolean> {
  // Дозволи працюють лише на фізичному пристрої
  if (!Device.isDevice) {
    console.warn('Сповіщення недоступні на симуляторі');
    return false;
  }

  const { status: existing } = await Notifications.getPermissionsAsync();

  if (existing === 'granted') return true;

  const { status } = await Notifications.requestPermissionsAsync({
    ios: {
      allowAlert: true,    // показувати банер/повний екран
      allowBadge: true,    // цифра на іконці
      allowSound: true,    // звук
      allowAnnouncements: false, // Siri Announce
    },
  });

  return status === 'granted';
}

import * as Notifications from 'expo-notifications';

async function setupNotificationChannels() {
  if (Platform.OS !== 'android') return; // канали тільки для Android

  // Канал для нагадувань
  await Notifications.setNotificationChannelAsync('reminders', {
    name: 'Нагадування',
    description: 'Нагадування про заплановані події та завдання',
    importance: Notifications.AndroidImportance.HIGH,
    sound: 'default',
    vibrationPattern: [0, 250, 250, 250],
    lightColor: '#3B82F6',
    lockscreenVisibility: Notifications.AndroidNotificationVisibility.PUBLIC,
    bypassDnd: false,
    enableLights: true,
    enableVibrate: true,
    showBadge: true,
  });

  // Канал для тихих оновлень
  await Notifications.setNotificationChannelAsync('updates', {
    name: 'Оновлення',
    description: 'Новини та оновлення застосунку',
    importance: Notifications.AndroidImportance.LOW,
    sound: undefined, // без звуку
    enableVibrate: false,
  });
}

await Notifications.scheduleNotificationAsync({
  content: {
    title: '👋 Привіт!',
    body: 'Це негайне сповіщення',
    data: { screen: 'home' },
  },
  trigger: null, // null = показати негайно
});

await Notifications.scheduleNotificationAsync({
  content: {
    title: '⏰ Нагадування',
    body: 'Час перевірити список справ',
    data: { screen: 'tasks', taskId: '123' },
    sound: true,
  },
  trigger: {
    seconds: 10,      // через 10 секунд
    repeats: false,   // не повторювати
  },
});

const reminderDate = new Date();
reminderDate.setHours(9, 0, 0, 0); // сьогодні о 9:00
reminderDate.setDate(reminderDate.getDate() + 1); // завтра

await Notifications.scheduleNotificationAsync({
  content: {
    title: '🏔 Нагадування про поїздку',
    body: 'Карпати — завтра! Не забудь упакувати рюкзак.',
    data: { screen: 'trip', tripId: 'kyiv-lviv-2024' },
  },
  trigger: {
    date: reminderDate,
  },
});

await Notifications.scheduleNotificationAsync({
  content: {
    title: '📝 Щоденний підсумок',
    body: 'Час записати події дня',
  },
  trigger: {
    hour: 21,
    minute: 0,
    repeats: true, // щодня
  },
});

await Notifications.scheduleNotificationAsync({
  content: { title: '📅 Початок тижня', body: 'Плануйте нові подорожі!' },
  trigger: {
    weekday: 2,     // 1=Нд, 2=Пн, 3=Вт ... 7=Сб
    hour: 10,
    minute: 0,
    repeats: true,
  },
});

import * as Notifications from 'expo-notifications';

// Налаштовуємо одразу при запуску (до будь-яких компонентів):
Notifications.setNotificationHandler({
  handleNotification: async (notification) => ({
    shouldShowAlert: true,   // показати банер
    shouldPlaySound: true,   // відтворити звук
    shouldSetBadge: false,   // не чіпати badge
    priority: Notifications.AndroidNotificationPriority.HIGH,
  }),
});

Notifications.setNotificationHandler({
  handleNotification: async (notification) => {
    const { data } = notification.request.content;

    // Сповіщення від поточного чату — не показуємо (вже бачимо)
    if (data?.chatId === currentOpenChatId) {
      return {
        shouldShowAlert: false,
        shouldPlaySound: false,
        shouldSetBadge: true,
      };
    }

    return {
      shouldShowAlert: true,
      shouldPlaySound: true,
      shouldSetBadge: true,
    };
  },
});

useEffect(() => {
  const subscription = Notifications.addNotificationReceivedListener((notification) => {
    console.log('Сповіщення отримано:', notification.request.content);
    // Наприклад: оновити лічильник непрочитаних у стейті
    setUnreadCount((c) => c + 1);
  });

  return () => subscription.remove();
}, []);

useEffect(() => {
  const subscription = Notifications.addNotificationResponseReceivedListener((response) => {
    const { data } = response.notification.request.content;

    // Навігація на потрібний екран:
    if (data?.screen === 'trip') {
      router.push(`/trips/${data.tripId}`);
    } else if (data?.screen === 'tasks') {
      router.push('/tasks');
    }
  });

  return () => subscription.remove();
}, []);

// Перевіряємо початкове сповіщення при запуску застосунку:
useEffect(() => {
  Notifications.getLastNotificationResponseAsync().then((response) => {
    if (!response) return;

    const { data } = response.notification.request.content;
    // Обробляємо так само, як у listener
    handleNotificationNavigation(data);
  });
}, []); // виконується один раз при монтуванні

// app/_layout.tsx
import { useEffect, useRef } from 'react';
import { useRouter } from 'expo-router';
import * as Notifications from 'expo-notifications';
import { Platform } from 'react-native';

// Конфігуруємо foreground поведінку одразу (поза компонентом):
Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowAlert: true,
    shouldPlaySound: true,
    shouldSetBadge: true,
  }),
});

export default function RootLayout() {
  const router = useRouter();
  const notificationListener = useRef<Notifications.Subscription>();
  const responseListener = useRef<Notifications.Subscription>();

  // Функція навігації за даними сповіщення
  const handleNotificationData = (data: Record<string, unknown> | undefined) => {
    if (!data) return;

    switch (data.screen) {
      case 'trip':
        router.push(`/trips/${data.tripId}`);
        break;
      case 'reminder':
        router.push('/reminders');
        break;
      case 'chat':
        router.push(`/chats/${data.chatId}`);
        break;
    }
  };

  useEffect(() => {
    // Створюємо канали для Android
    if (Platform.OS === 'android') {
      Notifications.setNotificationChannelAsync('reminders', {
        name: 'Нагадування',
        importance: Notifications.AndroidImportance.HIGH,
        sound: 'default',
        vibrationPattern: [0, 250, 250, 250],
      });
    }

    // Обробка сповіщення при запуску із closed стану:
    Notifications.getLastNotificationResponseAsync().then((response) => {
      if (response?.notification.request.content.data) {
        // Невелика затримка — чекаємо поки навігатор ініціалізується
        setTimeout(() => {
          handleNotificationData(response.notification.request.content.data);
        }, 500);
      }
    });

    // Listener: отримано сповіщення у foreground
    notificationListener.current = Notifications.addNotificationReceivedListener(
      (notification) => {
        console.log('Received:', notification.request.identifier);
      }
    );

    // Listener: тап по сповіщенню
    responseListener.current = Notifications.addNotificationResponseReceivedListener(
      (response) => {
        handleNotificationData(response.notification.request.content.data);
      }
    );

    return () => {
      notificationListener.current?.remove();
      responseListener.current?.remove();
    };
  }, []);

  return (
    // ... решта layout
  );
}

// Реєструємо категорію з кнопками (iOS):
await Notifications.setNotificationCategoryAsync('reminder', [
  {
    identifier: 'snooze',
    buttonTitle: 'Відкласти на 5 хв',
    options: { opensAppToForeground: false }, // без відкриття застосунку
  },
  {
    identifier: 'done',
    buttonTitle: '✅ Виконано',
    options: { opensAppToForeground: false, isDestructive: false },
  },
  {
    identifier: 'open',
    buttonTitle: 'Відкрити',
    options: { opensAppToForeground: true },
  },
]);

// Планування сповіщення з категорією:
await Notifications.scheduleNotificationAsync({
  content: {
    title: '⏰ Нагадування',
    body: 'Час упакувати рюкзак для Карпат',
    categoryIdentifier: 'reminder', // ← прив'язуємо категорію
    data: { type: 'reminder', id: '42' },
  },
  trigger: { seconds: 10 },
});

Notifications.addNotificationResponseReceivedListener((response) => {
  const actionId = response.actionIdentifier;
  // actionId === 'snooze', 'done', 'open' або
  // Notifications.DEFAULT_ACTION_IDENTIFIER (тап на само сповіщення)

  if (actionId === 'snooze') {
    // Плануємо ще одне сповіщення через 5 хвилин
    scheduleReminder(response.notification.request.content.data.id, 300);
  } else if (actionId === 'done') {
    // Позначаємо як виконане без відкриття застосунку
    markAsDone(response.notification.request.content.data.id);
  }
});

// Всі заплановані сповіщення:
const scheduled = await Notifications.getAllScheduledNotificationsAsync();
scheduled.forEach((n) => {
  console.log(n.identifier, n.content.title, n.trigger);
});

// Скасувати конкретне (за identifier):
await Notifications.cancelScheduledNotificationAsync(notificationId);

// Скасувати всі заплановані:
await Notifications.cancelAllScheduledNotificationsAsync();

// Відхилити показане сповіщення (прибрати з tray):
await Notifications.dismissNotificationAsync(notificationId);

// Відхилити всі показані:
await Notifications.dismissAllNotificationsAsync();

// Встановити badge:
await Notifications.setBadgeCountAsync(5);

// Скинути badge:
await Notifications.setBadgeCountAsync(0);

// Прочитати поточний badge:
const count = await Notifications.getBadgeCountAsync();

// hooks/useNotifications.ts
import { useState, useEffect, useCallback } from 'react';
import * as Notifications from 'expo-notifications';
import * as Device from 'expo-device';
import { Platform } from 'react-native';

interface UseNotificationsReturn {
  permissionGranted: boolean;
  requestPermission: () => Promise<boolean>;
  scheduleReminder: (title: string, body: string, seconds: number, data?: object) => Promise<string>;
  cancelReminder: (id: string) => Promise<void>;
  cancelAll: () => Promise<void>;
  scheduledCount: number;
  refreshScheduled: () => Promise<void>;
}

export function useNotifications(): UseNotificationsReturn {
  const [permissionGranted, setPermissionGranted] = useState(false);
  const [scheduledCount, setScheduledCount] = useState(0);

  useEffect(() => {
    // Перевірка дозволу при монтуванні
    Notifications.getPermissionsAsync().then(({ status }) => {
      setPermissionGranted(status === 'granted');
    });

    // Рахуємо заплановані
    refreshScheduled();
  }, []);

  const refreshScheduled = useCallback(async () => {
    const list = await Notifications.getAllScheduledNotificationsAsync();
    setScheduledCount(list.length);
  }, []);

  const requestPermission = useCallback(async () => {
    if (!Device.isDevice) return false;

    const { status } = await Notifications.requestPermissionsAsync({
      ios: { allowAlert: true, allowBadge: true, allowSound: true },
    });
    const granted = status === 'granted';
    setPermissionGranted(granted);
    return granted;
  }, []);

  const scheduleReminder = useCallback(async (
    title: string,
    body: string,
    seconds: number,
    data: object = {}
  ): Promise<string> => {
    const id = await Notifications.scheduleNotificationAsync({
      content: { title, body, data, sound: true },
      trigger: {
        seconds,
        channelId: Platform.OS === 'android' ? 'reminders' : undefined,
      } as any,
    });
    await refreshScheduled();
    return id;
  }, [refreshScheduled]);

  const cancelReminder = useCallback(async (id: string) => {
    await Notifications.cancelScheduledNotificationAsync(id);
    await refreshScheduled();
  }, [refreshScheduled]);

  const cancelAll = useCallback(async () => {
    await Notifications.cancelAllScheduledNotificationsAsync();
    setScheduledCount(0);
  }, []);

  return {
    permissionGranted,
    requestPermission,
    scheduleReminder,
    cancelReminder,
    cancelAll,
    scheduledCount,
    refreshScheduled,
  };
}

// Отримати push token (тільки на фізичному пристрої):
import Constants from 'expo-constants';

async function getExpoPushToken(): Promise<string | null> {
  if (!Device.isDevice) return null;

  const { status } = await Notifications.getPermissionsAsync();
  if (status !== 'granted') return null;

  const token = await Notifications.getExpoPushTokenAsync({
    projectId: Constants.expoConfig?.extra?.eas?.projectId,
  });

  return token.data; // "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxxxxxx]"
}

// Типові помилки у відповіді:
// { status: 'error', message: 'DeviceNotRegistered' }
// { status: 'error', message: 'InvalidCredentials' }
// { status: 'ok', id: 'xxxxx' }

// app/(tabs)/reminders.tsx
import { useState, useEffect, useCallback } from 'react';
import {
  View, Text, TextInput, Pressable, FlatList,
  SafeAreaView, StyleSheet, Platform, Alert,
} from 'react-native';
import * as Notifications from 'expo-notifications';
import { useNotifications } from '@/hooks/useNotifications';
import { PermissionPrompt } from '@/components/reminders/PermissionPrompt';

interface Reminder {
  id: string;
  title: string;
  scheduledAt: Date;
}

const DELAYS = [
  { label: '10 с', seconds: 10 },
  { label: '1 хв', seconds: 60 },
  { label: '5 хв', seconds: 300 },
  { label: '30 хв', seconds: 1800 },
  { label: '1 год', seconds: 3600 },
];

export default function RemindersScreen() {
  const [text, setText] = useState('');
  const [delayIndex, setDelayIndex] = useState(0);
  const [reminders, setReminders] = useState<Reminder[]>([]);

  const {
    permissionGranted,
    requestPermission,
    scheduleReminder,
    cancelReminder,
    refreshScheduled,
  } = useNotifications();

  // Завантажуємо вже заплановані сповіщення при відкритті
  useEffect(() => {
    loadScheduled();
  }, []);

  const loadScheduled = async () => {
    const scheduled = await Notifications.getAllScheduledNotificationsAsync();
    setReminders(
      scheduled.map((n) => ({
        id: n.identifier,
        title: n.content.title ?? 'Нагадування',
        scheduledAt: new Date(), // спрощено; в реальності зберігайте в AsyncStorage
      }))
    );
  };

  const handleSchedule = async () => {
    if (!text.trim()) return;

    const delay = DELAYS[delayIndex];
    const id = await scheduleReminder(
      '⏰ Нагадування',
      text.trim(),
      delay.seconds,
      { screen: 'reminders' }
    );

    setReminders((prev) => [
      { id, title: text.trim(), scheduledAt: new Date() },
      ...prev,
    ]);
    setText('');

    // Оновлюємо badge
    await Notifications.setBadgeCountAsync(reminders.length + 1);
  };

  const handleCancel = async (id: string) => {
    await cancelReminder(id);
    setReminders((prev) => prev.filter((r) => r.id !== id));
    await Notifications.setBadgeCountAsync(Math.max(0, reminders.length - 1));
  };

  if (!permissionGranted) {
    return <PermissionPrompt onRequest={requestPermission} />;
  }

  return (
    <SafeAreaView style={styles.container}>
      {/* Форма */}
      <View style={styles.form}>
        <TextInput
          style={styles.input}
          value={text}
          onChangeText={setText}
          placeholder="Текст нагадування..."
          placeholderTextColor="#94A3B8"
        />
        <View style={styles.delays}>
          {DELAYS.map((d, i) => (
            <Pressable
              key={d.label}
              onPress={() => setDelayIndex(i)}
              style={[styles.chip, i === delayIndex && styles.chipActive]}
            >
              <Text style={[styles.chipText, i === delayIndex && styles.chipTextActive]}>
                {d.label}
              </Text>
            </Pressable>
          ))}
        </View>
        <Pressable
          style={[styles.btn, !text.trim() && styles.btnDisabled]}
          onPress={handleSchedule}
          disabled={!text.trim()}
        >
          <Text style={styles.btnText}>
            Нагадати через {DELAYS[delayIndex].label}
          </Text>
        </Pressable>
      </View>

      {/* Список */}
      <FlatList
        data={reminders}
        keyExtractor={(item) => item.id}
        renderItem={({ item }) => (
          <View style={styles.row}>
            <View style={styles.rowContent}>
              <Text style={styles.rowTitle}>{item.title}</Text>
            </View>
            <Pressable onPress={() => handleCancel(item.id)} style={styles.cancelBtn}>
              <Text style={styles.cancelText}>Скасувати</Text>
            </Pressable>
          </View>
        )}
        ListEmptyComponent={
          <Text style={styles.empty}>Немає активних нагадувань</Text>
        }
      />
    </SafeAreaView>
  );
}

# iOS симулятор: симулювати push (потребує Xcode CLI tools)
xcrun simctl push booted com.yourapp.bundleid push_payload.json

{
  "aps": {
    "alert": {
      "title": "Тест",
      "body": "Сповіщення з симулятора"
    },
    "badge": 1,
    "sound": "default"
  }
}

// Отримати всі заплановані:
const list = await Notifications.getAllScheduledNotificationsAsync();
console.log(`Запланованих: ${list.length}`);
list.forEach(n => console.log(n.identifier, n.content.title));

// Отримати поточні показані:
const presented = await Notifications.getPresentedNotificationsAsync();
console.log(`Показаних: ${presented.length}`);