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>

components/call-watcher.tsx

@@ -0,0 +1,100 @@
+import { router } from "expo-router";
+import { useEffect, useRef } from "react";
+
+import { fetchAPI } from "@/lib/fetch";
+import type { CallRecord, ChatActiveRide } from "@/types/type";
+
+// Listens for an incoming WebRTC call (a 'ringing' call row this user did not
+// place) and routes the user to the call screen — regardless of which tab is
+// open. Rendered once at the root layout level; emits no UI.
+//
+// It only polls while an active ride exists (the only window in which a call
+// can happen). To avoid re-navigating on every poll, it remembers the call id
+// it already handed off to the call screen and resets once that call goes
+// terminal.
+
+const ACTIVE_POLL_MS = 5000;
+const CALL_POLL_MS = 3000;
+
+const CallWatcher = () => {
+  // The ride we're watching for an incoming call on.
+  const rideIdRef = useRef<number | null>(null);
+  // The call id we've already navigated to, so we don't re-push the screen.
+  const handledCallIdRef = useRef<number | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    // Refresh which ride (if any) is active for this user, then poll its call
+    // row. Both run on intervals; the call poll no-ops until a rideId is known.
+    const activeTimer = setInterval(async () => {
+      try {
+        const res = await fetchAPI("/(api)/chat/active");
+        const active = (res.data ?? null) as ChatActiveRide | null;
+        if (cancelled) return;
+        rideIdRef.current = active?.ride_id ?? null;
+      } catch (err) {
+        console.log("[CALL_WATCHER_ACTIVE]: ", err);
+      }
+    }, ACTIVE_POLL_MS);
+
+    const callTimer = setInterval(async () => {
+      const rideId = rideIdRef.current;
+      if (rideId === null) return;
+      try {
+        const res = await fetchAPI(`/(api)/ride/${rideId}/call`);
+        const call = (res.data ?? null) as CallRecord | null;
+        if (cancelled || !call) return;
+
+        // A terminal call clears the handled marker so the next incoming call
+        // can navigate again.
+        if (
+          call.status === "ended" ||
+          call.status === "declined" ||
+          call.status === "missed"
+        ) {
+          if (handledCallIdRef.current === call.id) {
+            handledCallIdRef.current = null;
+          }
+          return;
+        }
+
+        // An incoming ringing call we didn't place: hand off to the call
+        // screen, once per call id.
+        if (call.status === "ringing" && !call.is_caller) {
+          if (handledCallIdRef.current === call.id) return;
+          handledCallIdRef.current = call.id;
+          router.push({
+            pathname: "/(root)/call",
+            params: { rideId: String(rideId), mode: "incoming" },
+          });
+        }
+      } catch (err) {
+        console.log("[CALL_WATCHER_CALL]: ", err);
+      }
+    }, CALL_POLL_MS);
+
+    // Kick the active poll immediately so an incoming call on a freshly
+    // matched ride is noticed without waiting for the first interval.
+    void (async () => {
+      try {
+        const res = await fetchAPI("/(api)/chat/active");
+        if (cancelled) return;
+        rideIdRef.current =
+          ((res.data ?? null) as ChatActiveRide | null)?.ride_id ?? null;
+      } catch {
+        // ignore — the interval will retry
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+      clearInterval(activeTimer);
+      clearInterval(callTimer);
+    };
+  }, []);
+
+  return null;
+};
+
+export default CallWatcher;