Waseel: driver capture, chat/calls, dispatch, and session fixes

Driver onboarding now photographs the licence, ID card and vehicle
registration and reads the credential fields off them, plus a camera-only
profile selfie riders check the arriving driver against. Adds in-app chat
and WebRTC calls, push-backed ride offers, ratings, cancellation and
payment sheets, settlement, and the owner dashboard endpoints behind them.

Camera permission on Android:
  - Declare CAMERA and READ_MEDIA_IMAGES in the manifest. expo-image-picker's
    own plugin never declares CAMERA, and Android denies a request for an
    undeclared permission instantly and silently — no dialog is ever shown,
    which is indistinguishable from the app not asking at all.
  - Handle canAskAgain: once Android stops showing the dialog, repeating why
    we need it is a dead end, so offer Open Settings instead (lib/capture-
    permission.ts), matching what the location flow already did.

Session: a 401 on a request that carried a token now ends the session
instead of being reinterpreted per-screen — driver-home had been reading it
as "this user has no driver profile" and showing an onboarding form to an
already-onboarded driver. Requests without a token are exempt so a failed
sign-in doesn't sign you out, and the notification is latched per token so
concurrent polls tear the session down once. (root) gains the auth guard
that turns that into the sign-in screen; app/index.tsx only guarded the way
in, leaving a session that ended mid-screen with nowhere to go.

Also ignore .uploads/ — it holds driver licence, ID and vehicle scans plus
profile photos, which are personal data and must not be committed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

lib/use-chat.ts

@@ -0,0 +1,124 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import { ApiError, fetchAPI } from "@/lib/fetch";
+import type { Message } from "@/types/type";
+
+// Poll cadence for new messages. Staggered away from the ride-status poll
+// (3s) and the call poll (2s) so the two tabs don't hammer the DB in lockstep.
+const POLL_MS = 2500;
+
+type UseChatResult = {
+  messages: Message[];
+  loading: boolean;
+  sending: boolean;
+  error: string | null;
+  sendMessage: (body: string) => Promise<void>;
+  reload: () => Promise<void>;
+};
+
+// Ride-scoped chat. Fetches the full history once, then polls for messages
+// with id greater than the last one seen. Optimistic on send: the row the
+// server returns is appended immediately, so the bubble appears before the
+// next poll. `role` is the caller's role ("rider" | "driver") and is only
+// used by the screen to align bubbles — the hook itself doesn't need it, but
+// it takes it so the screen has one source of truth for the conversation.
+export const useChat = (
+  rideId: number | null,
+  role: "rider" | "driver" | null,
+): UseChatResult => {
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [sending, setSending] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Last message id we've seen — the polling cursor. Kept in a ref so the
+  // interval closure always reads the latest value without re-arming.
+  const cursorRef = useRef<number>(0);
+
+  const loadInitial = useCallback(async (id: number) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await fetchAPI(`/(api)/ride/${id}/messages`);
+      const rows = (res.data ?? []) as Message[];
+      setMessages(rows);
+      cursorRef.current = rows.length ? rows[rows.length - 1].id : 0;
+    } catch (err) {
+      console.log("[CHAT_LOAD]: ", err);
+      setError("chat.loadError");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const poll = useCallback(async (id: number) => {
+    try {
+      const res = await fetchAPI(
+        `/(api)/ride/${id}/messages?since=${cursorRef.current}`,
+      );
+      const rows = (res.data ?? []) as Message[];
+      if (rows.length) {
+        setMessages((prev) => [...prev, ...rows]);
+        cursorRef.current = rows[rows.length - 1].id;
+      }
+    } catch (err) {
+      // Swallow poll errors — a transient blip shouldn't wipe the list or
+      // flash an error banner; the next tick will retry.
+      console.log("[CHAT_POLL]: ", err);
+    }
+  }, []);
+
+  // Initial load + polling lifecycle. Re-arms when the ride id changes.
+  useEffect(() => {
+    if (rideId === null) {
+      setMessages([]);
+      cursorRef.current = 0;
+      return;
+    }
+    void loadInitial(rideId);
+    const timer = setInterval(() => void poll(rideId), POLL_MS);
+    return () => clearInterval(timer);
+  }, [rideId, loadInitial, poll]);
+
+  const sendMessage = useCallback(
+    async (body: string) => {
+      if (rideId === null) return;
+      const text = body.trim();
+      if (!text || sending) return;
+
+      setSending(true);
+      try {
+        const res = await fetchAPI(`/(api)/ride/${rideId}/messages`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ body: text }),
+        });
+        const message = res.data as Message;
+        setMessages((prev) => [...prev, message]);
+        cursorRef.current = Math.max(cursorRef.current, message.id);
+      } catch (err) {
+        if (err instanceof ApiError && err.status === 409) {
+          // Ride no longer active — surface that specifically so the UI can
+          // disable the input instead of retrying forever.
+          setError("chat.cannotMessage");
+        } else {
+          console.log("[CHAT_SEND]: ", err);
+          setError("chat.sendError");
+        }
+      } finally {
+        setSending(false);
+      }
+    },
+    [rideId, sending],
+  );
+
+  const reload = useCallback(async () => {
+    if (rideId !== null) await loadInitial(rideId);
+  }, [rideId, loadInitial]);
+
+  // `role` is accepted for API symmetry but the hook doesn't read it; keep the
+  // param so the screen's single conversation object carries the caller's role.
+  void role;
+
+  return { messages, loading, sending, error, sendMessage, reload };
+};