Device Features

// src/session/store.ts
import * as SecureStore from "expo-secure-store";
import type { Session } from "../domain/session";

const KEY = "fieldlog.session";

export async function saveSession(session: Session): Promise<void> {
  // Tokens only. Large values can be rejected by the platform, and iOS
  // has historically refused values above roughly 2048 bytes.
  await SecureStore.setItemAsync(KEY, JSON.stringify(session));
}

export async function loadSession(): Promise<Session | null> {
  const raw = await SecureStore.getItemAsync(KEY);
  // The ternary is the longhand of raw && JSON.parse(raw), with the
  // difference that this one returns null rather than an empty string.
  return raw ? (JSON.parse(raw) as Session) : null;
}

export async function clearSession(): Promise<void> {
  // Sign-out must also clear the query cache, or the next user to sign in
  // on this device sees the previous user's feed from disk.
  await SecureStore.deleteItemAsync(KEY);
}

// src/notifications/register.ts
import Constants from "expo-constants";
import * as Notifications from "expo-notifications";
import { Platform } from "react-native";

// What happens to a notification that arrives while the app is open.
// shouldShowBanner and shouldShowList are the two fields that replaced
// the single shouldShowAlert older code returns.
Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowBanner: true,
    shouldShowList: true,
    shouldPlaySound: false,
    shouldSetBadge: false,
  }),
});

export async function registerForPush(): Promise<string | null> {
  if (Platform.OS === "android") {
    // Android needs a channel before anything can be delivered to it.
    await Notifications.setNotificationChannelAsync("default", {
      name: "default",
      importance: Notifications.AndroidImportance.DEFAULT,
    });
  }

  const current = await Notifications.getPermissionsAsync();
  const settled = current.granted
    ? current
    : await Notifications.requestPermissionsAsync();
  if (!settled.granted) return null; // a refusal is a state, not an error

  const projectId = Constants.expoConfig?.extra?.eas?.projectId as string | undefined;
  if (!projectId) return null;
  const token = await Notifications.getExpoPushTokenAsync({ projectId });
  return token.data;
}

// src/notifications/useNotificationRouting.ts
import * as Notifications from "expo-notifications";
import { useRouter } from "expo-router";
import { useEffect } from "react";
import { isPushData } from "../domain/push";

// Called once from the root layout. It covers both cases: a tap while the
// app is running, and a tap that launched the app from cold.
export function useNotificationRouting() {
  const router = useRouter();
  // undefined while it is still being read, null when the app was not
  // opened from a notification.
  const last = Notifications.useLastNotificationResponse();

  useEffect(() => {
    const data = last?.notification.request.content.data;
    if (isPushData(data)) {
      router.push(`/entry/${data.entryId}`);
    }
  }, [last, router]);
}