@smileid/usesmileid 12.0.0-beta01

package/src/presentation/utils/__tests__/force_max_brightness.test.tsx

@@ -0,0 +1,237 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { create as createRenderer, act } from "react-test-renderer";
+import * as Brightness from "expo-brightness";
+import * as KeepAwake from "expo-keep-awake";
+import { ForceMaxBrightness } from "../force_max_brightness";
+
+/**
+ * Lifecycle tests for the `ForceMaxBrightness` component:
+ *   - On mount: snapshot original brightness, set target (default 1)
+ *   - On unmount: restore the original brightness
+ *   - Activate keep-awake on mount; deactivate on unmount
+ *   - `enabled={false}` is a no-op
+ *
+ * Mocks for `expo-brightness` and `expo-keep-awake` are installed in
+ * `setup_react_native.ts` — tests reset call history per-block.
+ */
+
+const mockedGetBrightness = vi.mocked(Brightness.getBrightnessAsync);
+const mockedSetBrightness = vi.mocked(Brightness.setBrightnessAsync);
+const mockedActivateKeepAwake = vi.mocked(KeepAwake.activateKeepAwakeAsync);
+const mockedDeactivateKeepAwake = vi.mocked(KeepAwake.deactivateKeepAwake);
+
+async function flushPromises(): Promise<void> {
+  // The mount closure chains `await getBrightnessAsync() → await
+  // setBrightnessAsync() → await activateKeepAwakeAsync()`. Flushing a few
+  // microtask cycles drains all three awaits before assertions.
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+describe("ForceMaxBrightness", () => {
+  beforeEach(async () => {
+    // Drain any cleanup microtask a prior test's unmount queued (the
+    // sequenced restore runs after `mountPromise` settles) so its calls land
+    // before — not after — we reset the spies below.
+    await flushPromises();
+    mockedGetBrightness.mockReset();
+    mockedGetBrightness.mockResolvedValue(0.42);
+    mockedSetBrightness.mockReset();
+    mockedSetBrightness.mockResolvedValue(undefined);
+    mockedActivateKeepAwake.mockReset();
+    mockedActivateKeepAwake.mockResolvedValue(undefined);
+    mockedDeactivateKeepAwake.mockReset();
+  });
+
+  it("is a no-op when enabled is false", async () => {
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness enabled={false} />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+
+    expect(mockedGetBrightness).not.toHaveBeenCalled();
+    expect(mockedSetBrightness).not.toHaveBeenCalled();
+    expect(mockedActivateKeepAwake).not.toHaveBeenCalled();
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+  });
+
+  it("snapshots original brightness then writes the default target on mount", async () => {
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+
+    expect(mockedGetBrightness).toHaveBeenCalledTimes(1);
+    expect(mockedSetBrightness).toHaveBeenCalledTimes(1);
+    // Default target is 1 (max).
+    expect(mockedSetBrightness).toHaveBeenCalledWith(1);
+    expect(mockedActivateKeepAwake).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+  });
+
+  it("clamps an over-1 target down to 1.0", async () => {
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness brightness={2} />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+
+    expect(mockedSetBrightness).toHaveBeenCalledWith(1);
+    tree.unmount();
+  });
+
+  it("clamps a negative or NaN target up to 0", async () => {
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness brightness={-0.4} />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+    expect(mockedSetBrightness).toHaveBeenCalledWith(0);
+
+    tree.unmount();
+
+    mockedSetBrightness.mockClear();
+    mockedGetBrightness.mockResolvedValue(0.42);
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness brightness={Number.NaN} />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+    expect(mockedSetBrightness).toHaveBeenCalledWith(0);
+
+    tree.unmount();
+  });
+
+  it("restores the original brightness on unmount", async () => {
+    mockedGetBrightness.mockResolvedValue(0.37);
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+
+    // Set target was 1; clear the mock so we can assert the restore call.
+    mockedSetBrightness.mockClear();
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+
+    expect(mockedSetBrightness).toHaveBeenCalledTimes(1);
+    expect(mockedSetBrightness).toHaveBeenCalledWith(0.37);
+  });
+
+  it("deactivates keep-awake on unmount with the same tag used on activate", async () => {
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+
+    const activateTag = mockedActivateKeepAwake.mock.calls[0]?.[0];
+    expect(typeof activateTag).toBe("string");
+
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+
+    expect(mockedDeactivateKeepAwake).toHaveBeenCalledTimes(1);
+    expect(mockedDeactivateKeepAwake).toHaveBeenCalledWith(activateTag);
+  });
+
+  it("does not throw or call setBrightness when getBrightnessAsync rejects", async () => {
+    mockedGetBrightness.mockRejectedValueOnce(new Error("simulator denied"));
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness />);
+    });
+    await act(async () => {
+      await flushPromises();
+    });
+
+    // Even when the read fails, the component still attempts the write
+    // (degraded UX > flow-breaking failure).
+    expect(mockedSetBrightness).toHaveBeenCalledWith(1);
+
+    // Restore is skipped because the original was never captured.
+    mockedSetBrightness.mockClear();
+    await act(async () => {
+      tree.unmount();
+      await flushPromises();
+    });
+    expect(mockedSetBrightness).not.toHaveBeenCalled();
+  });
+
+  it("sequences the cleanup restore after the in-flight mount read settles", async () => {
+    // Concrete scenario: a fast unmount (within ~16 ms) while the
+    // mount's `getBrightnessAsync()` is still in flight. The race
+    // fix has two contracts:
+    //
+    //   1. Mount writes are skipped post-cancel (we don't pin
+    //      brightness at the target when the user already left).
+    //   2. The cleanup-restore waits for `originalBrightness` to be
+    //      captured. Without sequencing, the cleanup-then closure
+    //      would observe `originalBrightness === null` and skip
+    //      the restore — leaving brightness at whatever value the
+    //      mount wrote (or unchanged), instead of the user's
+    //      original level.
+    let resolveMountRead!: (value: number) => void;
+    mockedGetBrightness.mockReturnValueOnce(
+      new Promise<number>((resolve) => {
+        resolveMountRead = resolve;
+      }),
+    );
+
+    let tree!: ReturnType<typeof createRenderer>;
+    act(() => {
+      tree = createRenderer(<ForceMaxBrightness />);
+    });
+
+    // Unmount before the mount-time read settles. The cleanup is
+    // queued behind the mount promise.
+    await act(async () => {
+      tree.unmount();
+    });
+    expect(mockedSetBrightness).not.toHaveBeenCalled();
+
+    // Resolve the read. The mount chain captures original = 0.21,
+    // sees `cancelled = true` and bails before the target write.
+    // Then mountPromise resolves and the cleanup-then closure
+    // restores the captured original.
+    await act(async () => {
+      resolveMountRead(0.21);
+      await flushPromises();
+    });
+
+    const calls = mockedSetBrightness.mock.calls.map((c) => c[0]);
+    // Exactly one call: the cleanup-side restore. Target write was
+    // correctly skipped after cancel.
+    expect(calls).toEqual([0.21]);
+  });
+});

package/src/presentation/utils/__tests__/locale_utils.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+
+import { getDefaultConsentState, isDeviceLocaleInEU } from "../locale_utils";
+
+describe("locale_utils", () => {
+  it("EU locale (de-DE) is recognised as EU and default consent is false", () => {
+    expect(isDeviceLocaleInEU("de-DE")).toBe(true);
+    expect(getDefaultConsentState("de-DE")).toBe(false);
+  });
+
+  it("non-EU locale (en-US) is not EU and default consent is true", () => {
+    expect(isDeviceLocaleInEU("en-US")).toBe(false);
+    expect(getDefaultConsentState("en-US")).toBe(true);
+  });
+
+  it("EU locale (fr-FR) is recognised as EU and default consent is false", () => {
+    expect(isDeviceLocaleInEU("fr-FR")).toBe(true);
+    expect(getDefaultConsentState("fr-FR")).toBe(false);
+  });
+
+  it("non-EU locale (en-NG) is not EU and default consent is true", () => {
+    expect(isDeviceLocaleInEU("en-NG")).toBe(false);
+    expect(getDefaultConsentState("en-NG")).toBe(true);
+  });
+
+  it("bare language tag with no region falls back to non-EU", () => {
+    // `"fr"` has no region segment — the BCP-47 split returns
+    // undefined for the country, which never matches the EU set.
+    expect(isDeviceLocaleInEU("fr")).toBe(false);
+    expect(getDefaultConsentState("fr")).toBe(true);
+  });
+
+  it("empty locale string falls back to non-EU", () => {
+    expect(isDeviceLocaleInEU("")).toBe(false);
+    expect(getDefaultConsentState("")).toBe(true);
+  });
+});

package/src/presentation/utils/force_max_brightness.tsx

@@ -0,0 +1,113 @@
+import { useEffect } from "react";
+import { getBrightnessAsync, setBrightnessAsync } from "expo-brightness";
+import { activateKeepAwakeAsync, deactivateKeepAwake } from "expo-keep-awake";
+
+export interface ForceMaxBrightnessProps {
+  /** Target brightness in the range 0.0–1.0. Defaults to 1.0 (max). */
+  readonly brightness?: number;
+  /**
+   * When false the component is a no-op. Defaults to true. Selfie capture uses
+   * the front camera with the screen as fill light, so callers enable it for
+   * the selfie path only; document capture uses the rear camera, where screen
+   * brightness does not help.
+   */
+  readonly enabled?: boolean;
+}
+
+/**
+ * Forces the device screen brightness to a target value (default 1.0) for as
+ * long as this component is mounted, restoring the user's original brightness
+ * when it unmounts. Also keeps the screen awake so a long capture session
+ * doesn't slip into auto-lock mid-flow.
+ *
+ * Rendered for its lifecycle side effect only (returns `null`), matching the
+ * Android `ForceMaxBrightness` composable and Flutter `ForceMaxBrightness`
+ * widget.
+ *
+ * Why brightness control is part of the capture surface: the ML pipeline tunes
+ * its luminance thresholds (`LOW_LIGHT` overlay state, exposure scoring) for a
+ * screen running at full brightness. A user who walks into the flow with
+ * brightness at 20 % triggers spurious low-light feedback even when the ambient
+ * lighting is adequate. Lifting brightness on the capture screen keeps the
+ * model's input distribution aligned with the calibration set.
+ *
+ * Implementation:
+ *   - `expo-brightness` provides `getBrightnessAsync` / `setBrightnessAsync`.
+ *     The original value is captured on mount and the target is applied
+ *     immediately. On cleanup we restore the original.
+ *   - `expo-keep-awake`'s `activateKeepAwakeAsync` / `deactivateKeepAwake` keep
+ *     the screen on.
+ *   - Errors are swallowed silently because the consequence of a brightness
+ *     call failing is degraded UX (slightly dimmer preview), not a
+ *     flow-breaking bug. Routing them through Sentry would spam partners on
+ *     simulators where the API isn't available.
+ *   - The cleanup-side restore is sequenced *after* the in-flight mount write
+ *     completes. Concrete scenario this guards: a fast unmount (within ~16 ms —
+ *     partner navigates away during a transient state) where the cleanup's
+ *     restore would otherwise race the late mount write, leaving brightness
+ *     pinned at `target` instead of the user's original level.
+ */
+export function ForceMaxBrightness({
+  brightness = 1,
+  enabled = true,
+}: ForceMaxBrightnessProps): null {
+  useEffect(() => {
+    if (!enabled) return;
+    const target = clamp01(brightness);
+    let cancelled = false;
+    let originalBrightness: number | null = null;
+    let keepAwakeActivated = false;
+    const keepAwakeTag = "usesmileid-capture";
+
+    const mountPromise: Promise<void> = (async () => {
+      try {
+        originalBrightness = await getBrightnessAsync();
+      } catch {
+        // Read failed (e.g. iOS simulator) — proceed with the
+        // write so the capture preview still gets a brighter
+        // surface, accepting that we can't restore on unmount.
+        originalBrightness = null;
+      }
+      if (cancelled) return;
+      try {
+        await setBrightnessAsync(target);
+      } catch {
+        // Write failed — degraded UX but not flow-breaking.
+      }
+      if (cancelled) return;
+      try {
+        await activateKeepAwakeAsync(keepAwakeTag);
+        if (!cancelled) keepAwakeActivated = true;
+      } catch {
+        // Same rationale as brightness write.
+      }
+    })();
+
+    return () => {
+      cancelled = true;
+      void mountPromise.then(() => {
+        if (originalBrightness !== null) {
+          void setBrightnessAsync(clamp01(originalBrightness)).catch(() => {
+            /* restore-on-cleanup is best-effort */
+          });
+        }
+        if (keepAwakeActivated) {
+          try {
+            deactivateKeepAwake(keepAwakeTag);
+          } catch {
+            /* deactivate is best-effort */
+          }
+        }
+      });
+    };
+  }, [brightness, enabled]);
+
+  return null;
+}
+
+function clamp01(value: number): number {
+  if (Number.isNaN(value)) return 0;
+  if (value < 0) return 0;
+  if (value > 1) return 1;
+  return value;
+}

package/src/presentation/utils/locale_utils.ts

@@ -0,0 +1,71 @@
+const EU_COUNTRY_CODES: ReadonlySet<string> = new Set([
+  "AT",
+  "BE",
+  "BG",
+  "HR",
+  "CY",
+  "CZ",
+  "DK",
+  "EE",
+  "FI",
+  "FR",
+  "DE",
+  "GR",
+  "HU",
+  "IE",
+  "IT",
+  "LV",
+  "LT",
+  "LU",
+  "MT",
+  "NL",
+  "PL",
+  "PT",
+  "RO",
+  "SK",
+  "SI",
+  "ES",
+  "SE",
+]);
+
+/**
+ * Returns the device's resolved BCP-47 locale tag (e.g. `"en-US"`).
+ *
+ * Uses the JS engine's `Intl` resolved options, which on Hermes
+ * (Expo SDK 51+, with `enableHermesLocaleAPI` enabled by default) and
+ * JSC reflects the system locale. Returns an empty string if `Intl`
+ * is unavailable — callers then treat the locale as non-EU.
+ */
+export function getDeviceLocale(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale;
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Returns `true` if the device's locale country is an EU member state.
+ *
+ * Accepts a BCP-47 tag (`"en-US"`, `"fr-FR"`, or bare `"fr"`). Bare
+ * language tags with no region resolve to non-EU because the country
+ * cannot be determined.
+ */
+export function isDeviceLocaleInEU(
+  locale: string = getDeviceLocale(),
+): boolean {
+  const country = locale.split("-")[1]?.toUpperCase();
+  return country !== undefined && EU_COUNTRY_CODES.has(country);
+}
+
+/**
+ * Returns the default consent checkbox state based on the device locale.
+ *
+ * - EU locales: unticked (`false`) to comply with GDPR opt-in.
+ * - Non-EU locales: ticked (`true`).
+ */
+export function getDefaultConsentState(
+  locale: string = getDeviceLocale(),
+): boolean {
+  return !isDeviceLocaleInEU(locale);
+}

package/src/presentation/utils/use_reduced_motion.ts

@@ -0,0 +1,26 @@
+import { useEffect, useState } from "react";
+import { AccessibilityInfo } from "react-native";
+
+/** System reduced-motion preference — initial value plus later changes. */
+export function useReducedMotion(): boolean {
+  const [reducedMotion, setReducedMotion] = useState(false);
+  useEffect(() => {
+    let cancelled = false;
+    AccessibilityInfo.isReduceMotionEnabled()
+      .then((enabled) => {
+        if (!cancelled) setReducedMotion(enabled);
+      })
+      // Platform query failed — keep the motion-on default rather than
+      // surfacing an unhandled rejection.
+      .catch(() => undefined);
+    const subscription = AccessibilityInfo.addEventListener(
+      "reduceMotionChanged",
+      (enabled) => setReducedMotion(enabled),
+    );
+    return () => {
+      cancelled = true;
+      subscription.remove();
+    };
+  }, []);
+  return reducedMotion;
+}