@smileid/usesmileid 12.0.1 → 12.0.2

package/src/presentation/screen/use_smile_id_capture_screen.tsx

@@ -227,6 +227,8 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
   // branch idempotent without latching the one-shot delivery gate.
   const [captureTimedOut, setCaptureTimedOut] = useState(false);
   const timedOutRef = useRef(false);
+  // Set when streaming produced no analyzed frame at all, which the analyzer's own timeout cannot report.
+  const [captureStalled, setCaptureStalled] = useState(false);
   // True while a manual/gallery delivery is in flight — disables the controls.
   const [deliveringDocument, setDeliveringDocument] = useState(false);
   // Transient gallery-import error; overrides the live chip, self-clears so the user can re-pick.
@@ -282,8 +284,28 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
     setSessionEpoch((epoch) => epoch + 1);
     // A new session must not compare against the old session's last state.
     previousScanStateRef.current = null;
-    setStreaming(true);
-  }, [streaming, onStartCapture]);
+    // Clear the terminal latches so a retry after a timeout or a stall is a fresh session.
+    const wasTerminal = timedOutRef.current;
+    timedOutRef.current = false;
+    setCaptureTimedOut(false);
+    setCaptureStalled(false);
+    setScanState({ type: UseSmileIDScanStateType.Initial });
+    setHasAnalyzedFrame(false);
+    // Frames banked before the abandoned session must not pad this one.
+    capturedEventsRef.current = [];
+    if (wasTerminal) {
+      // A timed-out native session is terminal — stream only after it resets,
+      // or the first retry frame re-reports Timeout and re-latches the error.
+      void props.analyzer
+        .reset()
+        .catch((error) => UseSmileIDCrashReporting.captureException(error))
+        .finally(() => {
+          if (!completedRef.current) setStreaming(true);
+        });
+    } else {
+      setStreaming(true);
+    }
+  }, [streaming, onStartCapture, props.analyzer]);
 
   const analyzer = props.analyzer;
   const onCaptureComplete = props.onCaptureComplete;
@@ -523,7 +545,8 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
       // Terminal states: finished → flush + complete; timeout → failure
       // without flushing (no captured artifacts to wait on).
       if (result.state.type === UseSmileIDScanStateType.Finished) {
-        if (completedRef.current) return;
+        // `timedOutRef` too: stopping the stream is async, so a frame queued before the timeout can still land here.
+        if (completedRef.current || timedOutRef.current) return;
         completedRef.current = true;
         setStreaming(false);
         // flush() waits for every emitted JPG to land on disk before we
@@ -542,15 +565,9 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
       } else if (result.state.type === UseSmileIDScanStateType.Timeout) {
         if (completedRef.current || timedOutRef.current) return;
         setStreaming(false);
-        if (isDocumentCapture) {
-          // Document capture has no Start button, so a timeout must leave a way
-          // forward: reveal the manual shutter and keep the delivery gate open
-          // so the tap can still produce a capture.
-          timedOutRef.current = true;
-          setCaptureTimedOut(true);
-        } else {
-          completedRef.current = true;
-        }
+        // The terminal state rides on `timedOutRef`, not the one-shot delivery gate, so the shutter and Start button stay usable.
+        timedOutRef.current = true;
+        setCaptureTimedOut(true);
         onCaptureTimeout?.(result.state);
       }
     },
@@ -573,6 +590,9 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
   );
   const isInstructionState =
     scanState.type === UseSmileIDScanStateType.Initial && !streaming;
+  // A selfie timeout leaves `scanState` on Timeout, so the instruction predicate alone would hide the only way to retry.
+  const showStartButton =
+    (isInstructionState || captureTimedOut) && !isDocumentCapture;
   const canStart = !streaming && !completedRef.current;
 
   const previewReady = hasPermission && device != null;
@@ -587,6 +607,28 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
     [analyzer.frameProcessorPluginName],
   );
 
+  // Every terminal signal arrives inside a frame result, so a camera that delivers no frame at all would sit on the initial state forever.
+  // Latest-ref, not a dep: an inline `onCaptureTimeout` prop is a fresh identity every render, which would restart the wall clock.
+  const onCaptureTimeoutRef = useRef(onCaptureTimeout);
+  onCaptureTimeoutRef.current = onCaptureTimeout;
+  useEffect(() => {
+    if (!streaming || hasAnalyzedFrame) return;
+    const timer = setTimeout(() => {
+      if (completedRef.current || timedOutRef.current) return;
+      timedOutRef.current = true;
+      setCaptureStalled(true);
+      setCaptureTimedOut(true);
+      setStreaming(false);
+      onCaptureTimeoutRef.current?.({ type: UseSmileIDScanStateType.Timeout });
+    }, CameraDefaults.firstFrameTimeoutMs);
+    return () => clearTimeout(timer);
+  }, [streaming, hasAnalyzedFrame]);
+
+  // A frame disproves the stall; document capture has no Start button to clear it by hand.
+  useEffect(() => {
+    if (hasAnalyzedFrame) setCaptureStalled(false);
+  }, [hasAnalyzedFrame]);
+
   // A missing plugin means no frame ever produces a result — report once
   // on capture start rather than sitting silently on the initial state.
   const pluginErrorReportedRef = useRef(false);
@@ -732,10 +774,12 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
       enableEnhancedLiveness,
       animationDirection: uiState.animationDirection,
       poseMatched: uiState.poseMatched,
-      // A transient gallery-import error preempts the live feedback chip.
-      feedbackKey: galleryErrorKey ?? settledFeedbackKey,
+      // A stalled camera, then a transient gallery-import error, preempt the live feedback chip.
+      feedbackKey: captureStalled
+        ? "si_capture_camera_unavailable"
+        : (galleryErrorKey ?? settledFeedbackKey),
       // Documents auto-start (no Start button); selfie keeps its.
-      showCaptureButton: isInstructionState && !isDocumentCapture,
+      showCaptureButton: showStartButton,
       showManualShutter: manualShutterAvailable,
       showGalleryUpload: galleryAvailable,
       isBackSide: documentSide === DocumentSide.Back,
@@ -754,7 +798,8 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
       uiState.poseMatched,
       settledFeedbackKey,
       galleryErrorKey,
-      isInstructionState,
+      captureStalled,
+      showStartButton,
       isDocumentCapture,
       manualShutterAvailable,
       galleryAvailable,
@@ -834,8 +879,14 @@ export function UseSmileIDCaptureScreen(props: UseSmileIDCaptureScreenProps) {
     <UseSmileIDThemeProvider value={theme}>
       {/* Translucent status bar → full-bleed window so the oval's reference
           frame is the full screen (no-op on iOS). On-device-pending: residual
-          inset also depends on the host SafeAreaProvider config. */}
-      <StatusBar translucent backgroundColor="transparent" />
+          inset also depends on the host SafeAreaProvider config.
+          `dark-content` because the capture overlay draws a near-opaque white
+          scrim behind the status bar, whatever the host app's own bar style. */}
+      <StatusBar
+        translucent
+        backgroundColor="transparent"
+        barStyle="dark-content"
+      />
       <UseSmileIDCaptureContent
         state={contentState}
         captureProgress={uiState.captureProgress}

package/src/presentation/theme/__tests__/use_use_smile_id_fonts.test.tsx

@@ -0,0 +1,166 @@
+import {
+  describe,
+  it,
+  expect,
+  vi,
+  beforeAll,
+  beforeEach,
+  afterEach,
+} from "vitest";
+import * as React from "react";
+import { create as createRenderer, act } from "react-test-renderer";
+import Module from "node:module";
+import { DM_SANS_FONT_NAMES } from "../theme";
+
+/**
+ * The hook `require()`s the bundled `.ttf` assets — Metro resolves those to
+ * numeric asset ids, Node does not. Register a CommonJS handler that mimics
+ * Metro's numeric id so the font map can be asserted without a bundler.
+ */
+const nodeExtensions = (
+  Module as unknown as {
+    _extensions: Record<
+      string,
+      (mod: { exports: unknown }, filename: string) => void
+    >;
+  }
+)._extensions;
+
+let nextAssetId = 0;
+
+beforeAll(() => {
+  nodeExtensions[".ttf"] = (mod) => {
+    nextAssetId += 1;
+    mod.exports = nextAssetId;
+  };
+});
+
+type FontsModule = typeof import("../use_use_smile_id_fonts");
+type ExpoFontModule = { loadAsync: ReturnType<typeof vi.fn> };
+
+/** Fresh copy of the module so its one-shot `loadPromise` latch is reset. */
+async function freshModules(): Promise<{
+  fonts: FontsModule;
+  expoFont: ExpoFontModule;
+}> {
+  vi.resetModules();
+  const expoFont = (await import("expo-font")) as unknown as ExpoFontModule;
+  // The shared setup's `expo-font` mock survives `resetModules`, so its spy
+  // carries calls across tests unless cleared here.
+  expoFont.loadAsync.mockClear();
+  const fonts = (await import("../use_use_smile_id_fonts")) as FontsModule;
+  return { fonts, expoFont };
+}
+
+let warn: ReturnType<typeof vi.spyOn>;
+
+beforeEach(() => {
+  warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+});
+
+afterEach(() => {
+  warn.mockRestore();
+});
+
+describe("loadUseSmileIDFonts", () => {
+  it("registers every bundled DM Sans weight under its typography face name", async () => {
+    const { fonts, expoFont } = await freshModules();
+
+    await fonts.loadUseSmileIDFonts();
+
+    expect(expoFont.loadAsync).toHaveBeenCalledTimes(1);
+    const [map] = expoFont.loadAsync.mock.calls[0] as [Record<string, number>];
+    expect(Object.keys(map).sort()).toEqual(
+      Object.values(DM_SANS_FONT_NAMES).sort(),
+    );
+    for (const face of Object.values(DM_SANS_FONT_NAMES)) {
+      expect(typeof map[face]).toBe("number");
+    }
+  });
+
+  it("shares one in-flight load across concurrent flows", async () => {
+    const { fonts, expoFont } = await freshModules();
+
+    const [first, second] = [
+      fonts.loadUseSmileIDFonts(),
+      fonts.loadUseSmileIDFonts(),
+    ];
+    await Promise.all([first, second]);
+    await fonts.loadUseSmileIDFonts();
+
+    expect(first).toBe(second);
+    expect(expoFont.loadAsync).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("useUseSmileIDFonts", () => {
+  function renderHook(useHook: () => boolean) {
+    const seen: boolean[] = [];
+    function Probe() {
+      seen.push(useHook());
+      return null;
+    }
+    let renderer!: ReturnType<typeof createRenderer>;
+    act(() => {
+      renderer = createRenderer(<Probe />);
+    });
+    return { seen, renderer };
+  }
+
+  async function settle() {
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    });
+  }
+
+  it("renders before the faces are registered, then flips to loaded", async () => {
+    const { fonts } = await freshModules();
+
+    const { seen } = renderHook(fonts.useUseSmileIDFonts);
+    expect(seen[0]).toBe(false);
+
+    await settle();
+
+    expect(seen.at(-1)).toBe(true);
+  });
+
+  it("never blocks the flow when font registration fails — warns and falls back", async () => {
+    const { fonts, expoFont } = await freshModules();
+    expoFont.loadAsync.mockRejectedValueOnce(new Error("asset registry down"));
+
+    const { seen } = renderHook(fonts.useUseSmileIDFonts);
+    await settle();
+
+    expect(seen.at(-1)).toBe(false);
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("asset registry down"),
+    );
+  });
+
+  it("reports a non-Error rejection without crashing on `.message`", async () => {
+    const { fonts, expoFont } = await freshModules();
+    expoFont.loadAsync.mockRejectedValueOnce("native module missing");
+
+    renderHook(fonts.useUseSmileIDFonts);
+    await settle();
+
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("native module missing"),
+    );
+  });
+
+  it("stops tracking the load after unmount", async () => {
+    const { fonts } = await freshModules();
+
+    const { renderer, seen } = renderHook(fonts.useUseSmileIDFonts);
+    expect(seen).toEqual([false]);
+    act(() => {
+      renderer.unmount();
+    });
+    await settle();
+
+    // The load resolves after the screen is gone; the cleanup latch keeps it
+    // from re-rendering the unmounted tree.
+    expect(seen).toEqual([false]);
+  });
+});