import { useEffect, useMemo, useRef, useState } from 'react'; import { useAtomValue } from 'jotai'; import { callEmbedAtom } from '../state/callEmbed'; import { useCallControlState } from '../plugins/call'; import type { LotusCallParticipant } from '../plugins/call/CallEmbed'; import { useSetting } from '../state/hooks/settings'; import { settingsAtom } from '../state/settings'; import { useMatrixClient } from './useMatrixClient'; import { useCallJoined } from './useCallEmbed'; import { invokeTauri, isTauri } from './useTauri'; import { getMemberName } from '../utils/room'; import { buildOverlaySnapshot, inactiveOverlay, OverlaySnapshot, overlaySnapshotKey, } from '../utils/callOverlay'; /** At most this often (ms) while speaking flips; the last state always lands. */ const SEND_INTERVAL_MS = 100; /** * [cinny-desktop #25] Feeds the desktop app's in-game voice overlay: while a * call is joined and Settings → Calls → In-game overlay is on, sends who's in * the call, who's speaking and your own mute / deafen / PTT state to the native * `set_overlay_state` command. The desktop decides when to show it (Lotus not * focused). No-op in the browser. */ export function useTauriOverlay(): void { const mx = useMatrixClient(); const callEmbed = useAtomValue(callEmbedAtom); const joined = useCallJoined(callEmbed); const { microphone, sound } = useCallControlState(callEmbed?.control); const [enabled] = useSetting(settingsAtom, 'callOverlay'); const [corner] = useSetting(settingsAtom, 'callOverlayCorner'); const [pttMode] = useSetting(settingsAtom, 'pttMode'); // Live per-participant state from the fork's io.lotus.call_state, only // tracked while the overlay could show. const [participants, setParticipants] = useState([]); const tracking = isTauri() && enabled && joined && callEmbed !== undefined; useEffect(() => { if (!tracking || !callEmbed) { setParticipants([]); return undefined; } const sync = (): void => setParticipants(callEmbed.getLotusParticipants() ?? []); sync(); return callEmbed.onLotusCallState(sync); }, [tracking, callEmbed]); const snapshot: OverlaySnapshot = useMemo(() => { if (!tracking || !callEmbed) return inactiveOverlay(corner); const { room } = callEmbed; return buildOverlaySnapshot({ enabled, joined, corner, myUserId: mx.getUserId(), participants, nameOf: (userId) => getMemberName(room, userId), muted: !microphone, deafened: !sound, pttMode, }); }, [tracking, callEmbed, enabled, joined, corner, mx, participants, microphone, sound, pttMode]); // Coalesced send: skip unchanged snapshots, send at most every // SEND_INTERVAL_MS, and always deliver the latest one. const key = overlaySnapshotKey(snapshot); const latest = useRef(snapshot); latest.current = snapshot; const sentKey = useRef(null); const lastSentAt = useRef(0); const timer = useRef | undefined>(undefined); useEffect(() => { if (!isTauri() || key === sentKey.current) return; const send = (): void => { timer.current = undefined; const s = latest.current; sentKey.current = overlaySnapshotKey(s); lastSentAt.current = Date.now(); invokeTauri('set_overlay_state', { state: s }); }; if (timer.current !== undefined) return; const wait = SEND_INTERVAL_MS - (Date.now() - lastSentAt.current); if (wait <= 0) send(); else timer.current = setTimeout(send, wait); }, [key]); // Hide the overlay when this unmounts (logout, client teardown). useEffect( () => () => { if (timer.current !== undefined) clearTimeout(timer.current); if (isTauri()) { invokeTauri('set_overlay_state', { state: inactiveOverlay(latest.current.corner) }); } }, [], ); }