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).
182 lines
6.1 KiB
TypeScript
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 }
|
|
}
|