Skip to content

The free and privacy-friendly screen recorder with no limits 🎥

12.3 KB
Raw Blame
import { getContextRefs } from "../context/CameraContext";
import { setPipMode } from "./uiState";
import { getUserMediaWithFallback } from "../../utils/mediaDeviceFallback";

export const getCameraStream = async (
  constraints,
  streamRef,
  videoRef,
  offScreenCanvasRef,
  offScreenCanvasContextRef,
  { onStart = () => {}, onFinish = () => {} } = {},
) => {
  const { setWidth, setHeight, recordingTypeRef } = getContextRefs();

  onStart();

  if (!streamRef) {
    console.warn("⚠️ streamRef is undefined. Creating a new reference.");
    streamRef = { current: new MediaStream() };
  }

  if (!videoRef) {
    console.warn("⚠️ videoRef is undefined. Creating a new reference.");
    videoRef = { current: null };
  }

  if (!offScreenCanvasRef) {
    console.warn(
      "⚠️ offScreenCanvasRef is undefined. Creating a new reference.",
    );
    offScreenCanvasRef = { current: null };
  }

  if (!offScreenCanvasContextRef) {
    console.warn(
      "⚠️ offScreenCanvasContextRef is undefined. Creating a new reference.",
    );
    offScreenCanvasContextRef = { current: null };
  }

  try {
    const desiredVideoId = constraints?.video?.deviceId?.exact || null;
    let desiredVideoLabel = "";

    if (desiredVideoId) {
      const { defaultVideoInputLabel, videoinput, videoInput } =
        await chrome.storage.local.get([
          "defaultVideoInputLabel",
          "videoinput",
          "videoInput",
        ]);
      const storedDevices = Array.isArray(videoinput)
        ? videoinput
        : Array.isArray(videoInput)
        ? videoInput
        : [];
      desiredVideoLabel =
        defaultVideoInputLabel ||
        storedDevices.find((device) => device.deviceId === desiredVideoId)
          ?.label ||
        "";
    }

    const stream = await getUserMediaWithFallback({
      constraints,
      fallbacks:
        desiredVideoId && desiredVideoLabel
          ? [
              {
                kind: "videoinput",
                desiredDeviceId: desiredVideoId,
                desiredLabel: desiredVideoLabel,
                onResolved: (resolvedId) => {
                  chrome.storage.local.set({
                    defaultVideoInput: resolvedId,
                    defaultVideoInputLabel: desiredVideoLabel,
                  });
                },
              },
            ]
          : [],
    });

    streamRef.current = stream;

    const videoTrack = stream.getVideoTracks()[0];
    const { width, height, deviceId, frameRate } = videoTrack.getSettings();

    // Camera track ends mid-recording (unplug, virtual cam crash, OS revoke).
    // Stop the stream and surface via camera-bubble-unavailable; don't tear
    // down the wrapping recording.
    try {
      videoTrack.addEventListener("ended", () => {
        try {
          chrome.runtime.sendMessage({
            type: "diag-forward",
            event: "camera-bubble-track-ended",
            data: {
              trackLabel: String(videoTrack?.label || "").slice(0, 80),
              readyState: videoTrack?.readyState || null,
            },
          });
        } catch {}
        try {
          stopCameraStream(streamRef, videoRef);
        } catch {}
        try {
          chrome.runtime.sendMessage({
            type: "camera-bubble-unavailable",
            error: "camera-track-ended",
            why: "camera disconnected during recording",
          });
        } catch {}
      });
    } catch {}

    if (setWidth && setHeight) {
      const isCamera = recordingTypeRef?.current === "camera";
      const w = isCamera || width / height < 1 ? "100%" : "auto";
      const h = isCamera || width / height < 1 ? "auto" : "100%";
      setWidth(w);
      setHeight(h);
    } else {
      console.warn("⚠️ setWidth or setHeight not available from context.");
    }

    if (!videoRef.current) {
      console.warn("⏳ videoRef not ready yet. Will poll every 100ms.");
      const maxWaitTime = 5000;
      const startTime = Date.now();

      const intervalId = setInterval(() => {
        if (videoRef.current) {
          videoRef.current.srcObject = stream;
          clearInterval(intervalId);
        } else if (Date.now() - startTime > maxWaitTime) {
          console.warn("⚠️ Timed out waiting for videoRef.current");
          clearInterval(intervalId);
        }
      }, 100);
      return;
    }

    const video = videoRef.current;
    video.srcObject = stream;

    // Virtual cams (OBS, mmhmm, Snap, etc.) break the naive
    // `onloadedmetadata = ...` pattern three ways: loadedmetadata can
    // fire synchronously on srcObject assign, the track can start
    // muted (fires `unmute` before metadata), and some virtual cams
    // never fire loadedmetadata until first frame. Check readyState
    // up front, listen via addEventListener on both metadata and
    // unmute, cap at 12s so paused source apps don't hang the spinner.
    const VIRTUAL_CAM_LOADED_TIMEOUT_MS = 12000;
    await new Promise((resolve) => {
      let settled = false;
      const finish = async () => {
        if (settled) return;
        settled = true;
        cleanup();
        await video.play().catch((err) => {
          console.error("❌ Error during video.play():", err);
        });
        await new Promise((r) => setTimeout(r, 100));
        const canvas = offScreenCanvasRef?.current;
        if (!canvas) {
          console.warn("⚠️ offScreenCanvasRef.current is null.");
          return resolve();
        }
        canvas.width = video.videoWidth || 1280;
        canvas.height = video.videoHeight || 720;
        const context = canvas.getContext("2d");
        if (!context) {
          console.error("❌ Failed to get 2D context from canvas.");
          return resolve();
        }
        offScreenCanvasContextRef.current = context;
        resolve();
      };

      const onMetadata = () => {
        finish();
      };
      const onUnmute = () => {
        // Track unmuted but readyState may still be 0; re-check in case
        // HAVE_METADATA was already reached.
        if (video.readyState >= 1) finish();
      };
      const cleanup = () => {
        try {
          video.removeEventListener("loadedmetadata", onMetadata);
          video.removeEventListener("loadeddata", onMetadata);
        } catch {}
        try {
          videoTrack?.removeEventListener?.("unmute", onUnmute);
        } catch {}
        if (timeoutId) clearTimeout(timeoutId);
      };

      // Sync race: already past metadata.
      if (video.readyState >= 1 && video.videoWidth > 0) {
        finish();
        return;
      }

      video.addEventListener("loadedmetadata", onMetadata, { once: true });
      video.addEventListener("loadeddata", onMetadata, { once: true });
      try {
        videoTrack?.addEventListener?.("unmute", onUnmute);
      } catch {}

      // Bounded fallback for virtual cams that never deliver metadata.
      // Proceed with default 1280x720; real frames are picked up later.
      const timeoutId = setTimeout(() => {
        if (settled) return;
        console.warn(
          "[Screenity] Camera loadedmetadata timeout (likely virtual camera); proceeding with defaults",
          {
            readyState: video.readyState,
            videoWidth: video.videoWidth,
            trackMuted: videoTrack?.muted,
            trackLabel: videoTrack?.label,
          },
        );
        try {
          chrome.runtime.sendMessage({
            type: "diag-forward",
            event: "recorder-camera-metadata-timeout",
            data: {
              readyState: video.readyState,
              videoWidth: video.videoWidth,
              videoHeight: video.videoHeight,
              trackMuted: !!videoTrack?.muted,
              trackLabel: String(videoTrack?.label || "").slice(0, 80),
            },
          });
        } catch {}
        finish();
      }, VIRTUAL_CAM_LOADED_TIMEOUT_MS);
    });

    onFinish();
  } catch (err) {
    console.error("❌ Failed to get camera stream:", err);
    onFinish();
    // Surface to BG only during setup (pendingRecording=true):
    // 1. screen+camera with camera denied during setup; BG must clear
    //    pendingRecording or the next record stalls.
    // 2. tab+camera with bubble failure mid-recording: stay silent;
    //    propagating a recording-error tears down the live recording.
    try {
      const { recording, pendingRecording, recordingType } =
        await chrome.storage.local.get([
          "recording",
          "pendingRecording",
          "recordingType",
        ]);
      const isPermissionDenial =
        err?.name === "NotAllowedError" ||
        err?.name === "PermissionDeniedError";
      // For camera-only recordings the webcam is the recording, so a
      // setup failure is fatal. For screen/tab/region it's just a PIP
      // bubble; its failure must not tear down the recording.
      const isCameraOnlyRecording = recordingType === "camera";
      // Diag fires regardless of fatality; "clicked record and got nothing"
      // reports need to distinguish permission denials from device-not-found
      // and getUserMedia hangs.
      try {
        chrome.runtime.sendMessage({
          type: "diag-forward",
          event: "recorder-camera-acquire-failed",
          data: {
            errorName: err?.name || null,
            isPermissionDenial,
            duringSetup: pendingRecording === true && recording !== true,
            recordingActive: recording === true,
            cameraOnly: isCameraOnlyRecording,
            message: String(err?.message || err).slice(0, 200),
          },
        });
      } catch {}
      if (
        isCameraOnlyRecording &&
        pendingRecording === true &&
        recording !== true
      ) {
        // Camera-only setup failure: fatal. BG must clear pendingRecording.
        chrome.runtime.sendMessage({
          type: "recording-error",
          error: isPermissionDenial
            ? "camera-permission-denied"
            : "camera-stream-error",
          why: String(err?.message || err),
        });
      } else if (recording === true || pendingRecording === true) {
        // Screen/tab/region recording: the webcam is just a PIP bubble.
        // Don't tear down the recording; surface a non-fatal toast.
        chrome.runtime.sendMessage({
          type: "camera-bubble-unavailable",
          error: isPermissionDenial
            ? "camera-permission-denied"
            : "camera-stream-error",
          why: String(err?.message || err),
        });
      }
    } catch {
      // BG context might be gone (SW asleep).
    }
  }
};

export const stopCameraStream = (streamRef, videoRef) => {
  if (!streamRef?.current) {
    console.warn("⚠️ No active stream to stop.");
    return;
  }

  const stream = streamRef.current;

  stream.getTracks().forEach((track) => track.stop());

  if (videoRef && videoRef.current) {
    videoRef.current.srcObject = null;
  }
};

// The copy inside the floating window never opens a video PiP of its own.
export const IS_WINDOW_COPY =
  typeof window !== "undefined" &&
  new URLSearchParams(window.location.search).get("pip") === "1";

// The floating window is opened inside the click that starts the recording.
// Entering the browser's video PiP on its own replaces the bubble with a black
// "Picture in picture mode" card, so only the bubble's own button may.
export const surfaceHandler = async (request) => {
  if (process.env.NODE_ENV !== "production") {
    console.debug("[Screenity][pip] bubble surface", request?.surface);
  }
};

let _cameraToggleReacquireTimer = null;
export const cameraToggledToolbar = async (request) => {
  if (request.active) {
    // Cancel any pending re-acquire so rapid toolbar toggles don't stack
    // up multiple getCameraStream calls fighting for the same device.
    if (_cameraToggleReacquireTimer) {
      clearTimeout(_cameraToggleReacquireTimer);
    }
    _cameraToggleReacquireTimer = setTimeout(() => {
      _cameraToggleReacquireTimer = null;
      // Pass refs so the prior camera stream actually stops; calling
      // stopCameraStream() with no args is a silent no-op (early return).
      const refs = getContextRefs();
      stopCameraStream(refs.streamRef, refs.videoRef);
      getCameraStream(
        {
          video: {
            deviceId: { exact: request.id },
          },
        },
        refs.streamRef,
        refs.videoRef,
        refs.offScreenCanvasRef,
        refs.offScreenCanvasContextRef,
      );
    }, 2000);
    setPipMode(false);
  }
};