import React, { createContext, useCallback, useContext, useEffect, useRef, useState, } from "react"; import * as Notifications from "expo-notifications"; import { registerForPushNotificationsAsync } from "./notif-register"; import { useRouter } from "expo-router"; import { NotificationToast } from "../toaster"; import { NOTIF_PERMISSION_DENIED } from "common-ui/src/lib/const-strs"; import type { ReactParentComponent } from '@packages/shared'; import { useStaffAuth } from "@/components/context/staff-auth-context"; import { setPendingHref } from "./pending-navigation"; const DASHBOARD_HREF = "/(drawer)/dashboard"; const COMPLAINTS_HREF = "/(drawer)/dashboard/complaints"; const orderDetailsHref = (orderId: string) => `/(drawer)/dashboard/manage-orders/order-details/${orderId}`; /** Push payload ids are numeric; ignore anything else. */ function toNumericId(value: unknown): string | null { if (value === null || value === undefined) return null; const id = String(value); return /^\d+$/.test(id) ? id : null; } interface NotificationContextType { expoPushToken: string | null; notification: Notifications.Notification | null; error: Error | null; notifPermission: 'pending' | 'granted' | 'denied' } export const NotificationContext = createContext< NotificationContextType | undefined >(undefined); export const useNotification = () => { const context = useContext(NotificationContext); if (context === undefined) { throw new Error( "useNotification must be used within a NotificationProvider" ); } return context; }; export const NotificationProvider: React.FC = ({ children, }) => { const [expoPushToken, setExpoPushToken] = useState(null); const [notification, setNotification] = useState(null); const [error, setError] = useState(null); const [notifPermission, setNotifPermission] = React.useState("pending"); const notificationListener = useRef(null); const responseListener = useRef(null); const router = useRouter(); // Auth state is read through a ref so the response listener (registered once) // always sees the current session, and a tap that arrives while the session is // being restored is not mistaken for a signed-out tap. const { isLoading, isLoggedIn } = useStaffAuth(); const isLoggedInRef = useRef(isLoggedIn); const handledResponses = useRef>(new Set()); /** * Response that launched the app. `getLastNotificationResponseAsync` resolves * before the auth provider finishes restoring the session, so it is held here * until `isLoading` turns false. */ const [launchResponse, setLaunchResponse] = useState(null); useEffect(() => { isLoggedInRef.current = isLoggedIn; }, [isLoggedIn]); const openFromNotification = useCallback( (response: Notifications.NotificationResponse) => { // The launch response and the live listener can deliver the same tap. const responseId = response.notification.request.identifier; if (responseId) { if (handledResponses.current.has(responseId)) return; handledResponses.current.add(responseId); } const data = response.notification.request.content.data; const orderId = toNumericId(data?.orderId); const complaintId = toNumericId(data?.complaintId); // An order-specific push opens that order; a general complaint opens the // complaints list. const target = orderId ? orderDetailsHref(orderId) : complaintId ? COMPLAINTS_HREF : null; if (!target) { if (isLoggedInRef.current) { router.push(DASHBOARD_HREF as any); } return; } if (isLoggedInRef.current) { router.push(target as any); return; } // Signed out: remember the destination so login can land on it. setPendingHref(target); }, [router] ); useEffect(() => { registerForPushNotificationsAsync() .then((token) => { setExpoPushToken(token); setNotifPermission("granted"); }) .catch((errorRaw) => { const err = String(errorRaw).slice(7); // strip leading "Error: " if (err === NOTIF_PERMISSION_DENIED) { setNotifPermission("denied"); } }); }, []); useEffect(() => { notificationListener.current = Notifications.addNotificationReceivedListener((notification) => { setNotification(notification); const content = notification.request?.content; if (content) { NotificationToast( content.title || "Notification", content.body || "", content.data || {} ); } }); responseListener.current = Notifications.addNotificationResponseReceivedListener( openFromNotification ); return () => { if (notificationListener.current) { Notifications.removeNotificationSubscription( notificationListener.current ); } if (responseListener.current) { Notifications.removeNotificationSubscription(responseListener.current); } }; }, [openFromNotification]); // Tapping a push while the app is terminated never reaches the listener // above; Expo replays it through the "last response" API instead. useEffect(() => { let cancelled = false; Notifications.getLastNotificationResponseAsync() .then((response) => { if (cancelled || !response) return; setLaunchResponse(response); return Notifications.clearLastNotificationResponseAsync(); }) .catch(() => undefined); return () => { cancelled = true; }; }, []); // Open the launch response only once the session is known, so the tap is not // treated as signed out while the provider is still restoring it. useEffect(() => { if (isLoading || !launchResponse) return; setLaunchResponse(null); openFromNotification(launchResponse); }, [isLoading, launchResponse, openFromNotification]); return ( {children} ); };