Files
app/frontend/src/components/Dashboard/useLiveView.ts
T
Melvin Strobl 72c1d73e96 Camera permission and review fixes (openpanel C3, C4)
C4: a device's `viewers` (superusers by default, or members) covers the
image and video messages its ports publish. Anyone else gets none of their
values on the socket, in the catalogue or a flow's state, 403 for their
history, for the frames they hold (the last 8 included) and for TURN
credentials, no bytes when asking for them, and `bye: forbidden` for a live
view. A device credential stays bounded by its dashboards. The device page
sets it in its Camera section, and a tile the viewer may not see says
"No access to this camera" and asks the camera for nothing.

C3:
- A volatile upload is held to MAX_FRAME_BYTES (4 MiB, 413 above it, read
  without extra copies), and so is a frame on a device's socket.
- A frame the engine holds in memory is written to the ring directory
  before a local worker is handed it, so load_artifact finds it.
- A socket the bus dropped events for catches up with a snapshot, demand
  included, and a device's credential is checked again per frame, cached by
  the flow store revision and its nonce, so a lost event never keeps an
  unpaired device's frames coming.
- A report is at most 64 KB once its named config_schemas are put in place.
- A device away for 60 s has its true bool messages set to false.
- Refused frames are logged by fixed keys, a frame is named after its
  message, `fluksio serve` waits 5 s for open connections, a tile with a
  stream URL creates no demand, the 8-name cap keeps the newest names.
- Every container's log rotates (json-file, 3 x 10 MB).
2026-10-17 09:20:04 +02:00

182 lines
6.1 KiB
TypeScript

import { useQuery } from "@tanstack/react-query"
import { useCallback, useEffect, useRef, useState } from "react"
import {
cameraMessages,
LIVE_PORT,
reportedPorts,
} from "@/components/Devices/ports"
import { devicesQueryOptions } from "@/components/Devices/queries"
import {
type LiveSignal,
listenLive,
sendLive,
} from "@/components/Flow/useFlowSocket"
import useAuth from "@/hooks/useAuth"
import { appRoute } from "@/lib/portal"
/** How long a live view gets from the tap to its first frame. */
const FIRST_FRAME_MS = 10_000
/** How long the note after a fallback stays. */
const NOTE_MS = 4000
const BUSY = "Live view busy, showing frames"
const FAILED = "Live view unavailable, showing frames"
export type LivePhase = "off" | "connecting" | "playing"
/**
* The device whose camera publishes `message` and can stream it live, or "".
*
* A device offers it by reporting a `live` port, and only while it is online.
* Read off the device list, which a wall panel's credential cannot read, so a
* panel never offers it.
*/
export function useLiveDevice(message: string): string {
const enabled = Boolean(message) && !appRoute().startsWith("/panel")
const { data } = useQuery({ ...devicesQueryOptions(), enabled })
if (!enabled) return ""
const device = data?.data?.find(
(one) =>
one.online &&
(one.bindings ?? []).some(
(binding) =>
binding.port === "camera" &&
binding.direction === "in" &&
binding.message === message,
) &&
(reportedPorts(one) ?? []).some((port) => port.port === LIVE_PORT),
)
return device?.id ?? ""
}
/**
* Whether this viewer may not see the camera publishing `message`: a
* device's image or video while its `viewers` are superusers, for anyone
* else. The server holds the frames back too, this only says why the tile
* stays empty.
*
* A wall panel shows what its dashboards carry, which a superuser assigned,
* and cannot read the device list anyway.
*/
export function useCameraHidden(message: string): boolean {
const { user } = useAuth()
const enabled =
Boolean(message) &&
!appRoute().startsWith("/panel") &&
user?.is_superuser === false
const { data } = useQuery({ ...devicesQueryOptions(), enabled })
if (!enabled) return false
return (data?.data ?? []).some(
(device) =>
device.viewers !== "members" && cameraMessages(device).includes(message),
)
}
/**
* A live view of one device's camera: the browser's own `RTCPeerConnection`
* answering the device's offer, signalled over the page's socket.
*
* Busy, a failure or no first frame within ten seconds ends it with a short
* note, and the tile goes on showing frames. Leaving says `bye`.
*/
export function useLiveView(device: string) {
const [phase, setPhase] = useState<LivePhase>("off")
const [stream, setStream] = useState<MediaStream | null>(null)
const [note, setNote] = useState("")
const running = useRef<{ stop: () => void; played: () => void } | null>(null)
const stop = useCallback(() => running.current?.stop(), [])
const played = useCallback(() => running.current?.played(), [])
const start = useCallback(() => {
if (!device || running.current) return
// Not `randomUUID`, which a page on plain HTTP on a LAN does not have.
const session = Array.from(
crypto.getRandomValues(new Uint8Array(12)),
(byte) => byte.toString(16).padStart(2, "0"),
).join("")
let pc: RTCPeerConnection | null = null
let over = false
// The device's candidates that came before its offer was applied.
const early: string[] = []
const end = (why: string, tell: boolean) => {
if (over) return
over = true
clearTimeout(timer)
unlisten()
if (tell) sendLive({ device, session, action: "bye" })
pc?.close()
running.current = null
setStream(null)
setPhase("off")
setNote(why)
}
const add = (candidate: string) =>
pc
?.addIceCandidate({ candidate, sdpMLineIndex: 0 })
.catch(() => undefined)
const answer = async (offer: LiveSignal) => {
const peer = new RTCPeerConnection({
iceServers: offer.ice_servers ?? [],
})
pc = peer
peer.ontrack = (event) =>
setStream(event.streams[0] ?? new MediaStream([event.track]))
peer.onicecandidate = (event) => {
// The bare `candidate:` line, which is what the device reads.
const candidate = event.candidate?.candidate
if (candidate)
sendLive({ device, session, action: "candidate", candidate })
}
peer.onconnectionstatechange = () => {
if (peer.connectionState === "failed") end(FAILED, true)
}
await peer.setRemoteDescription({ type: "offer", sdp: offer.sdp })
const reply = await peer.createAnswer()
await peer.setLocalDescription(reply)
sendLive({ device, session, action: "sdp", sdp: reply.sdp })
for (const candidate of early.splice(0)) await add(candidate)
}
const unlisten = listenLive(session, (message) => {
if (over) return
if (message.action === "busy") end(BUSY, false)
else if (message.action === "bye") end(FAILED, false)
else if (message.action === "sdp" && message.sdp && !pc)
answer(message).catch(() => end(FAILED, true))
else if (message.action === "candidate" && message.candidate) {
if (pc?.remoteDescription) add(message.candidate)
else early.push(message.candidate)
}
})
const timer = setTimeout(() => end(FAILED, true), FIRST_FRAME_MS)
running.current = {
stop: () => end("", true),
played: () => {
clearTimeout(timer)
setPhase("playing")
},
}
setNote("")
setPhase("connecting")
if (!sendLive({ device, session, action: "start" })) end(FAILED, false)
}, [device])
// A tile that goes away, or is pointed at another device, ends its view.
useEffect(() => {
if (!device) return
return () => running.current?.stop()
}, [device])
useEffect(() => {
if (!note) return
const timer = setTimeout(() => setNote(""), NOTE_MS)
return () => clearTimeout(timer)
}, [note])
return { phase, stream, note, start, stop, played }
}