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,
  };
}

import * as Notifications from 'expo-notifications';
import * as Device from 'expo-device';
import { Platform } from 'react-native';
import Constants from 'expo-constants';

async function registerForPushNotificationsAsync(): Promise<string | undefined> {
  // Push-токени недоступні на симуляторі/емуляторі
  if (!Device.isDevice) {
    console.warn('Push notifications work only on physical devices');
    return undefined;
  }

  // Перевірка дозволів
  const { status: existingStatus } = await Notifications.getPermissionsAsync();
  let finalStatus = existingStatus;

  if (existingStatus !== 'granted') {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
  }

  if (finalStatus !== 'granted') {
    console.warn('Permission for push notifications was denied');
    return undefined;
  }

  // Отримання Expo Push Token
  const projectId = Constants.expoConfig?.extra?.eas?.projectId;
  
  if (!projectId) {
    throw new Error('Project ID not found. Run `eas init` first.');
  }

  const token = await Notifications.getExpoPushTokenAsync({ projectId });
  
  console.log('Expo Push Token:', token.data);
  
  // Android-specific: налаштування каналу
  if (Platform.OS === 'android') {
    await Notifications.setNotificationChannelAsync('default', {
      name: 'Default',
      importance: Notifications.AndroidImportance.MAX,
      vibrationPattern: [0, 250, 250, 250],
      lightColor: '#FF231F7C',
    });
  }

  return token.data;
}

// services/api.ts
export async function savePushToken(userId: string, token: string) {
  await fetch('https://api.myapp.com/users/push-token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${userAuthToken}`,
    },
    body: JSON.stringify({
      userId,
      expoPushToken: token,
      platform: Platform.OS,
      deviceId: Constants.installationId,
    }),
  });
}

CREATE TABLE push_tokens (
  id SERIAL PRIMARY KEY,
  user_id INTEGER NOT NULL REFERENCES users(id),
  expo_push_token TEXT NOT NULL UNIQUE,
  platform VARCHAR(10) NOT NULL, -- 'ios' або 'android'
  device_id TEXT,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX idx_push_tokens_user ON push_tokens(user_id);
CREATE INDEX idx_push_tokens_token ON push_tokens(expo_push_token);

// hooks/usePushToken.ts
import { useState, useEffect } from 'react';
import * as Notifications from 'expo-notifications';
import * as Device from 'expo-device';
import Constants from 'expo-constants';
import { Platform } from 'react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';

const PUSH_TOKEN_KEY = 'expoPushToken';

export function usePushToken(userId: string | null) {
  const [expoPushToken, setExpoPushToken] = useState<string | null>(null);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    if (!userId) return; // Не реєструємо токен для неавторизованих

    async function registerPushToken() {
      try {
        if (!Device.isDevice) {
          console.warn('[Push] Only works on physical device');
          return;
        }

        // Запит дозволів
        const { status: existingStatus } = await Notifications.getPermissionsAsync();
        let finalStatus = existingStatus;

        if (existingStatus !== 'granted') {
          const { status } = await Notifications.requestPermissionsAsync();
          finalStatus = status;
        }

        if (finalStatus !== 'granted') {
          throw new Error('Push notification permission denied');
        }

        // Отримання токена
        const projectId = Constants.expoConfig?.extra?.eas?.projectId;
        if (!projectId) {
          throw new Error('Project ID missing. Run: eas init');
        }

        const tokenData = await Notifications.getExpoPushTokenAsync({ projectId });
        const token = tokenData.data;

        // Перевірка чи змінився токен
        const storedToken = await AsyncStorage.getItem(PUSH_TOKEN_KEY);

        if (storedToken !== token) {
          // Надсилаємо на сервер
          await fetch('https://api.myapp.com/users/push-token', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
              userId,
              expoPushToken: token,
              platform: Platform.OS,
            }),
          });

          await AsyncStorage.setItem(PUSH_TOKEN_KEY, token);
          console.log('[Push] Token registered:', token);
        }

        setExpoPushToken(token);

        // Android: налаштування каналу
        if (Platform.OS === 'android') {
          await Notifications.setNotificationChannelAsync('default', {
            name: 'Default notifications',
            importance: Notifications.AndroidImportance.MAX,
            vibrationPattern: [0, 250, 250, 250],
            lightColor: '#FF231F7C',
          });
        }
      } catch (err) {
        console.error('[Push] Registration error:', err);
        setError(err as Error);
      }
    }

    registerPushToken();
  }, [userId]);

  return { expoPushToken, error };
}

// app/_layout.tsx або app/(auth)/home.tsx
import { usePushToken } from '@/hooks/usePushToken';
import { useAuth } from '@/context/AuthContext';

export default function HomeScreen() {
  const { user } = useAuth();
  const { expoPushToken, error } = usePushToken(user?.id ?? null);

  useEffect(() => {
    if (expoPushToken) {
      console.log('Device ready for push:', expoPushToken);
    }
  }, [expoPushToken]);

  // ... решта компонента
}

POST https://exp.host/--/api/v2/push/send
Content-Type: application/json

{
  "to": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
  "title": "Нове повідомлення",
  "body": "Олександр надіслав вам повідомлення",
  "data": {
    "screen": "chat",
    "chatId": "123",
    "senderId": "user_456"
  },
  "sound": "default",
  "badge": 1,
  "priority": "high",
  "channelId": "messages"
}

[
  {
    "to": "ExponentPushToken[aaaa]",
    "title": "Перше сповіщення",
    "body": "Текст першого"
  },
  {
    "to": "ExponentPushToken[bbbb]",
    "title": "Друге сповіщення",
    "body": "Текст другого"
  }
]

import * as Clipboard from 'expo-clipboard';
import { Alert, Pressable, Text } from 'react-native';

function CopyTokenButton({ expoPushToken }: { expoPushToken: string | null }) {
  const handleCopy = async () => {
    if (!expoPushToken) {
      Alert.alert('Помилка', 'Push token ще не згенерований');
      return;
    }

    await Clipboard.setStringAsync(expoPushToken);
    Alert.alert('Успіх', 'Token скопійовано в буфер обміну!');
  };

  return (
    <Pressable
      onPress={handleCopy}
      style={{
        backgroundColor: '#3b82f6',
        padding: 12,
        borderRadius: 8,
        alignItems: 'center',
      }}
    >
      <Text style={{ color: 'white', fontWeight: '600' }}>
        📋 Скопіювати Push Token
      </Text>
    </Pressable>
  );
}

useEffect(() => {
  if (expoPushToken) {
    console.log('═══════════════════════════════════════');
    console.log('📱 EXPO PUSH TOKEN:');
    console.log(expoPushToken);
    console.log('═══════════════════════════════════════');
  }
}, [expoPushToken]);

┌─────────────────────────────────────────────────────┐
│ Send a notification                                  │
├─────────────────────────────────────────────────────┤
│ Expo Push Token                                      │
│ [ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]        ] │
│                                                      │
│ Title                                                │
│ [Тестове сповіщення                               ] │
│                                                      │
│ Body                                                 │
│ [Це перевірка push через Expo Tool                ] │
│                                                      │
│ JSON Data (optional)                                 │
│ [{"screen": "home", "testId": "123"}              ] │
│                                                      │
│ ☑ Play sound    Badge: [1]    Priority: [high ▾]   │
│                                                      │
│ [ Send a Notification ]                              │
└─────────────────────────────────────────────────────┘

{
  "screen": "chat",
  "chatId": "chat_456",
  "senderId": "user_789",
  "timestamp": 1704067200,
  "priority": "high",
  "badge": 3
}

{
  "title": "Акція закінчується!",
  "body": "Знижка 50% ще 1 годину",
  "ttl": 3600
}

[
  {
    "name": "Chat Message Test",
    "payload": {
      "to": "ExponentPushToken[YOUR_TOKEN]",
      "title": "Нове повідомлення від Олександра",
      "body": "Привіт! Як справи?",
      "data": { "screen": "chat", "chatId": "chat_123" },
      "sound": "default",
      "priority": "high"
    }
  },
  {
    "name": "Order Confirmation Test",
    "payload": {
      "to": "ExponentPushToken[YOUR_TOKEN]",
      "title": "Замовлення підтверджено ✅",
      "body": "Ваше замовлення #4567 буде доставлено завтра о 14:00",
      "data": { "screen": "orders", "orderId": "4567" },
      "badge": 1,
      "priority": "normal"
    }
  },
  {
    "name": "Silent Background Sync",
    "payload": {
      "to": "ExponentPushToken[YOUR_TOKEN]",
      "data": { "action": "sync", "timestamp": 1704067200 },
      "priority": "normal",
      "sound": null
    }
  }
]

# Надішліть тестове повідомлення з JSON файлу
curl -X POST https://exp.host/--/api/v2/push/send \
  -H "Content-Type: application/json" \
  -d @test-notifications.json[0].payload

POST https://exp.host/--/api/v2/push/send
Content-Type: application/json

{
  "to": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
  "title": "Нове повідомлення",
  "body": "Олександр надіслав вам повідомлення",
  "data": {
    "screen": "chat",
    "chatId": "123",
    "senderId": "user_456"
  },
  "sound": "default",
  "badge": 1,
  "priority": "high",
  "channelId": "messages"
}

[
  {
    "to": "ExponentPushToken[aaaa]",
    "title": "Перше сповіщення",
    "body": "Текст першого"
  },
  {
    "to": "ExponentPushToken[bbbb]",
    "title": "Друге сповіщення",
    "body": "Текст другого"
  }
]

// server/services/pushNotifications.ts
import fetch from 'node-fetch';

interface PushMessage {
  to: string | string[];
  title: string;
  body: string;
  data?: Record<string, unknown>;
  sound?: 'default' | null;
  badge?: number;
  priority?: 'default' | 'normal' | 'high';
  channelId?: string;
}

interface PushTicket {
  status: 'ok' | 'error';
  id?: string;
  message?: string;
  details?: unknown;
}

export async function sendPushNotification(
  message: PushMessage
): Promise<PushTicket> {
  const response = await fetch('https://exp.host/--/api/v2/push/send', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Accept: 'application/json',
      'Accept-Encoding': 'gzip, deflate',
    },
    body: JSON.stringify(message),
  });

  const result = await response.json();

  if (!response.ok) {
    console.error('[Push] Send failed:', result);
    throw new Error(`Push send failed: ${result.message || 'Unknown error'}`);
  }

  // Expo повертає масив тікетів навіть для одного сповіщення
  const ticket = Array.isArray(result.data) ? result.data[0] : result.data;

  if (ticket.status === 'error') {
    console.error('[Push] Ticket error:', ticket);
  }

  return ticket;
}

// server/routes/notifications.ts
import express from 'express';
import { sendPushNotification } from '../services/pushNotifications';
import { getUserPushTokens } from '../db/users';

const router = express.Router();

router.post('/send-chat-message-notification', async (req, res) => {
  const { recipientUserId, senderName, messageText } = req.body;

  try {
    // Отримуємо токени отримувача з бази
    const tokens = await getUserPushTokens(recipientUserId);

    if (tokens.length === 0) {
      return res.status(400).json({ error: 'User has no registered devices' });
    }

    // Надсилаємо на всі пристрої користувача
    const tickets = await Promise.all(
      tokens.map((token) =>
        sendPushNotification({
          to: token.expoPushToken,
          title: `Нове повідомлення від ${senderName}`,
          body: messageText,
          data: {
            screen: 'chat',
            chatId: req.body.chatId,
            senderId: req.body.senderId,
          },
          sound: 'default',
          badge: 1,
          priority: 'high',
          channelId: 'messages',
        })
      )
    );

    res.json({ success: true, tickets });
  } catch (error) {
    console.error('[Push] Send error:', error);
    res.status(500).json({ error: 'Failed to send push notification' });
  }
});

export default router;

// Крок 1: Надсилаємо push, отримуємо ticket ID
const ticket = await sendPushNotification({ ... });
const ticketId = ticket.id; // зберігаємо у базі

// Крок 2: Через 5–10 хвилин перевіряємо receipt
async function checkPushReceipt(ticketId: string) {
  const response = await fetch('https://exp.host/--/api/v2/push/getReceipts', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ ids: [ticketId] }),
  });

  const result = await response.json();
  const receipt = result.data[ticketId];

  if (receipt.status === 'error') {
    console.error('[Push] Delivery failed:', receipt.message, receipt.details);

    // Обробка специфічних помилок
    if (receipt.details?.error === 'DeviceNotRegistered') {
      // Токен недійсний — видаляємо з бази
      await deletePushToken(ticketId);
    } else if (receipt.details?.error === 'MessageTooBig') {
      // Payload перевищує 4 KB
      console.warn('Push payload too large');
    }
  } else {
    console.log('[Push] Delivered successfully');
  }

  return receipt;
}

{
  "expo": {
    "ios": {
      "bundleIdentifier": "com.mycompany.myapp",
      "entitlements": {
        "aps-environment": "production"
      },
      "infoPlist": {
        "UIBackgroundModes": ["remote-notification"]
      }
    }
  }
}

import * as Notifications from 'expo-notifications';
import { Platform } from 'react-native';

async function getAPNsDeviceToken(): Promise<string | null> {
  if (Platform.OS !== 'ios') return null;

  const { status } = await Notifications.getPermissionsAsync();
  if (status !== 'granted') {
    console.warn('Push permissions not granted');
    return null;
  }

  // Отримуємо нативний APNs токен (формат: hex string 64+ символів)
  const devicePushToken = await Notifications.getDevicePushTokenAsync();

  console.log('APNs Device Token:', devicePushToken.data);
  
  // Надсилаємо на ваш backend (не на Expo)
  await saveAPNsToken(devicePushToken.data);

  return devicePushToken.data;
}

// server/services/apnsPush.ts
import apn from 'apn'; // npm install apn

interface APNsConfig {
  keyPath: string; // шлях до .p8 файлу
  keyId: string;   // Key ID з Apple Developer Portal
  teamId: string;  // Team ID з Apple Developer Portal
}

const apnsConfig: APNsConfig = {
  keyPath: process.env.APNS_KEY_PATH || './AuthKey_ABC123XYZ.p8',
  keyId: process.env.APNS_KEY_ID || 'ABC123XYZ',
  teamId: process.env.APNS_TEAM_ID || 'TEAM123456',
};

const apnsProvider = new apn.Provider({
  token: {
    key: apnsConfig.keyPath,
    keyId: apnsConfig.keyId,
    teamId: apnsConfig.teamId,
  },
  production: process.env.NODE_ENV === 'production', // false для sandbox
});

export async function sendAPNsPush(
  deviceToken: string,
  title: string,
  body: string,
  data: Record<string, unknown> = {}
) {
  const notification = new apn.Notification();

  notification.alert = {
    title,
    body,
  };
  notification.sound = 'default';
  notification.badge = 1;
  notification.topic = 'com.mycompany.myapp'; // Bundle Identifier
  notification.payload = data; // custom data
  notification.pushType = 'alert';
  notification.priority = 10; // 10 = high, 5 = normal

  try {
    const result = await apnsProvider.send(notification, deviceToken);

    if (result.failed.length > 0) {
      console.error('[APNs] Failed:', result.failed[0].response);
      
      // Обробка помилок
      if (result.failed[0].status === '410') {
        // Токен більше недійсний — видалити з бази
        await deleteAPNsToken(deviceToken);
      }
    } else {
      console.log('[APNs] Sent successfully');
    }

    return result;
  } catch (error) {
    console.error('[APNs] Send error:', error);
    throw error;
  }
}

// android/build.gradle
buildscript {
  dependencies {
    // Існуючі залежності...
    classpath 'com.google.gms:google-services:4.4.0'
  }
}

// android/app/build.gradle
apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services' // ← додайте цей рядок

android {
  // існуючий код...
}

dependencies {
  // існуючі залежності...
  implementation platform('com.google.firebase:firebase-bom:32.7.0')
  implementation 'com.google.firebase:firebase-messaging'
}

import * as Notifications from 'expo-notifications';
import { Platform } from 'react-native';
import messaging from '@react-native-firebase/messaging'; // npm install @react-native-firebase/app @react-native-firebase/messaging

async function getFCMToken(): Promise<string | null> {
  if (Platform.OS !== 'android') return null;

  // Запит дозволів (Android 13+)
  const authStatus = await messaging().requestPermission();
  const enabled =
    authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
    authStatus === messaging.AuthorizationStatus.PROVISIONAL;

  if (!enabled) {
    console.warn('FCM permission denied');
    return null;
  }

  // Отримання FCM токена
  const fcmToken = await messaging().getToken();
  console.log('FCM Token:', fcmToken);

  // Надсилаємо на backend
  await saveFCMToken(fcmToken);

  return fcmToken;
}

useEffect(() => {
  // FCM токен може змінитися (переінсталяція застосунку, заводське скидання)
  const unsubscribe = messaging().onTokenRefresh(async (newToken) => {
    console.log('FCM token refreshed:', newToken);
    await saveFCMToken(newToken);
  });

  return unsubscribe;
}, []);

// server/services/fcmPush.ts
import admin from 'firebase-admin'; // npm install firebase-admin

// Ініціалізація Firebase Admin SDK (один раз при запуску сервера)
const serviceAccount = require('./firebase-service-account.json'); // завантажте з Firebase Console

admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
});

export async function sendFCMPush(
  fcmToken: string,
  title: string,
  body: string,
  data: Record<string, string> = {} // FCM вимагає string values
) {
  const message: admin.messaging.Message = {
    token: fcmToken,
    notification: {
      title,
      body,
    },
    data, // додаткові дані (всі значення мають бути string!)
    android: {
      priority: 'high',
      notification: {
        sound: 'default',
        channelId: 'default',
        color: '#3B82F6',
      },
    },
  };

  try {
    const response = await admin.messaging().send(message);
    console.log('[FCM] Successfully sent:', response);
    return response;
  } catch (error: any) {
    console.error('[FCM] Send error:', error);

    // Обробка помилок
    if (error.code === 'messaging/registration-token-not-registered') {
      // Токен недійсний — видалити з бази
      await deleteFCMToken(fcmToken);
    } else if (error.code === 'messaging/invalid-argument') {
      console.error('[FCM] Invalid payload:', error.message);
    }

    throw error;
  }
}

// index.js або app/_layout.tsx (до рендерингу компонентів)
import messaging from '@react-native-firebase/messaging';

// Обробник фонових сповіщень (викликається навіть коли застосунок killed)
messaging().setBackgroundMessageHandler(async (remoteMessage) => {
  console.log('[FCM] Background message:', remoteMessage);

  // Можна виконати фонову логіку:
  // - Оновити локальну базу даних (SQLite, MMKV)
  // - Синхронізувати дані з сервером
  // - Показати локальне сповіщення з кастомним payload

  if (remoteMessage.data?.syncRequired === 'true') {
    await syncDataFromServer();
  }
});

# Expo Push Service
curl -X POST https://exp.host/--/api/v2/push/send \
  -H "Content-Type: application/json" \
  -d '{
    "to": "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
    "title": "Test Push",
    "body": "This is a test notification from cURL",
    "data": {"screen": "home"},
    "sound": "default",
    "priority": "high"
  }'

{
  "data": [
    {
      "status": "ok",
      "id": "1a2b3c4d-5e6f-7890-abcd-ef1234567890"
    }
  ]
}

# Встановлення CLI
npm install -g apns2

# Надсилання через APNs
apns2 send \
  --token your_apns_device_token \
  --topic com.mycompany.myapp \
  --key ./AuthKey_ABC123XYZ.p8 \
  --key-id ABC123XYZ \
  --team-id TEAM123456 \
  --production \
  --alert "Test from CLI" \
  --payload '{"data":{"screen":"home"}}'

// app/_layout.tsx
useEffect(() => {
  // Foreground notifications
  const receivedSub = Notifications.addNotificationReceivedListener((notification) => {
    console.log('📩 [Notification Received]', {
      identifier: notification.request.identifier,
      title: notification.request.content.title,
      body: notification.request.content.body,
      data: notification.request.content.data,
      timestamp: new Date().toISOString(),
    });
  });

  // Tap on notification
  const responseSub = Notifications.addNotificationResponseReceivedListener((response) => {
    console.log('👆 [Notification Tapped]', {
      actionIdentifier: response.actionIdentifier,
      data: response.notification.request.content.data,
      timestamp: new Date().toISOString(),
    });
  });

  return () => {
    receivedSub.remove();
    responseSub.remove();
  };
}, []);