winzik/engine/web/jumphp-webrtc.js

284 lines
13 KiB
JavaScript

// WebRTC for PHP in the browser (jumphp/webrtc, extensions/webrtc): the page's RTCPeerConnection driven by bridge messages 'webrtc'.
// Same protocol as the desktop sidecar (extensions/webrtc/doc/sidecar.md): PHP sends {op: 'peer'|'channel'|'offer'|'remote'|'ice'|'send'|'close', id, ...},
// the page answers {ev: 'offer'|'answer'|'ice'|'state'|'open'|'message'|'close'|'error', id, ...}. Nothing runs until PHP makes a peer.
// Media (camera / microphone calls, a video player; doc/index.md "Media"): {op: 'media'} asks the camera / microphone ({ev: 'media', state}),
// {op: 'tracks', id} puts them in a peer (before its offer / answer; ev 'track' when the other side's arrive), 'mute' / 'camera' / 'switch'
// / 'stopmedia', {op: 'tiles', tiles: [{key: 'self'|peer id, x, y, w, h, label}]} lays <video> elements over the canvas (x, y, w, h: 0..1 of
// the canvas), {op: 'play', url, kind: 'video'|'image'} shows a URL in a player over the canvas (ev 'play' {state: 'closed'|'error'}).
export function install(api) {
const peers = new Map(); // id -> {pc, channels: Map(label -> RTCDataChannel), offer: bool}
const out = (ev) => api.send('webrtc', ev);
let local = null; // the camera / microphone (MediaStream)
let facing = 'user';
const remote = new Map(); // peer id -> MediaStream of the other side
const tiles = new Map(); // key -> {box, video, label, rect}
let layer = null, player = null, lastRect = '';
function cover() {
if (!layer) {
layer = document.createElement('div');
layer.style.cssText = 'position:fixed;left:0;top:0;width:0;height:0;z-index:20;pointer-events:none';
document.body.appendChild(layer);
}
return layer;
}
function place(force) {
const r = api.canvas.getBoundingClientRect();
const key = `${r.left},${r.top},${r.width},${r.height}`;
if (!force && key === lastRect) return;
lastRect = key;
for (const t of tiles.values()) {
const [x, y, w, h] = t.rect;
Object.assign(t.box.style, { left: (r.left + x * r.width) + 'px', top: (r.top + y * r.height) + 'px', width: (w * r.width) + 'px', height: (h * r.height) + 'px' });
}
if (player) Object.assign(player.style, { left: r.left + 'px', top: r.top + 'px', width: r.width + 'px', height: r.height + 'px' });
}
api.afterFrame(() => { if (tiles.size || player) place(false); });
function source(key) {
return key === 'self' ? local : (remote.get(key) || null);
}
function attach(key) {
const t = tiles.get(key);
if (!t) return;
const s = source(key);
if (t.video.srcObject !== s) { t.video.srcObject = s; if (s) t.video.play().catch(() => {}); }
t.video.style.transform = key === 'self' && facing === 'user' ? 'scaleX(-1)' : '';
}
function layTiles(list) {
const keep = new Set();
for (const d of list || []) {
const key = String(d.key || '');
if (!key) continue;
keep.add(key);
let t = tiles.get(key);
if (!t) {
const box = document.createElement('div');
box.style.cssText = 'position:fixed;background:#000;border:1px solid #808080;box-sizing:border-box;overflow:hidden';
const video = document.createElement('video');
video.autoplay = true; video.playsInline = true; video.setAttribute('playsinline', '');
video.muted = key === 'self'; // never hear oneself
video.style.cssText = 'width:100%;height:100%;object-fit:cover;display:block';
const label = document.createElement('div');
label.style.cssText = 'position:absolute;left:0;bottom:0;padding:1px 4px;font:12px sans-serif;color:#fff;background:rgba(0,0,0,.55)';
box.append(video, label);
cover().appendChild(box);
t = { box, video, label, rect: [0, 0, 0, 0] };
tiles.set(key, t);
}
t.rect = [+d.x || 0, +d.y || 0, +d.w || 0, +d.h || 0];
t.label.textContent = String(d.label || '');
t.label.style.display = d.label ? '' : 'none';
attach(key);
}
for (const [key, t] of tiles) {
if (!keep.has(key)) { t.video.srcObject = null; t.box.remove(); tiles.delete(key); }
}
place(true);
}
function stopLocal() {
local?.getTracks().forEach((t) => t.stop());
local = null;
}
async function askMedia(m) {
const md = navigator.mediaDevices;
if (!md?.getUserMedia) return out({ ev: 'media', id: '', state: window.isSecureContext === false ? 'insecure' : 'unsupported' });
facing = m.facing === 'environment' ? 'environment' : 'user';
const video = m.video !== false ? { facingMode: facing, width: { ideal: 640 }, height: { ideal: 480 } } : false;
stopLocal();
try {
local = await md.getUserMedia({ audio: m.audio !== false, video });
} catch (e) {
const name = e?.name || '';
if (video && (name === 'NotFoundError' || name === 'OverconstrainedError' || name === 'NotReadableError')) {
try { local = await md.getUserMedia({ audio: true, video: false }); } catch (e2) { local = null; }
}
if (!local) {
const state = name === 'NotAllowedError' || name === 'SecurityError' ? 'denied' : (name === 'NotFoundError' ? 'notfound' : (name === 'NotReadableError' ? 'busy' : 'error'));
return out({ ev: 'media', id: '', state, message: e?.message || String(e) });
}
}
let cameras = 0;
try { cameras = (await md.enumerateDevices()).filter((d) => d.kind === 'videoinput').length; } catch (e) { /* no list */ }
for (const key of tiles.keys()) attach(key);
out({ ev: 'media', id: '', state: 'ready', audio: local.getAudioTracks().length > 0, video: local.getVideoTracks().length > 0, cameras, facing });
}
async function switchCamera() {
const old = local?.getVideoTracks()[0];
if (!old) return;
facing = facing === 'user' ? 'environment' : 'user';
let track;
try {
old.stop();
track = (await navigator.mediaDevices.getUserMedia({ video: { facingMode: facing, width: { ideal: 640 }, height: { ideal: 480 } } })).getVideoTracks()[0];
} catch (e) { return out({ ev: 'media', id: '', state: 'error', message: e?.message || String(e) }); }
track.enabled = old.enabled;
local.removeTrack(old); local.addTrack(track);
for (const p of peers.values()) {
for (const s of p.pc.getSenders()) if (s.track === old) s.replaceTrack(track).catch(() => {});
}
attach('self');
out({ ev: 'media', id: '', state: 'switched', facing });
}
function closePlayer() {
if (!player) return;
const v = player.querySelector('video'); if (v) { v.pause(); v.removeAttribute('src'); v.load(); }
player.remove(); player = null;
}
function play(m) {
closePlayer();
const box = document.createElement('div');
box.style.cssText = 'position:fixed;z-index:30;background:rgba(0,0,0,.92);display:flex;align-items:center;justify-content:center';
const url = String(m.url || '');
if (!/^https?:\/\//.test(url)) return out({ ev: 'play', id: '', state: 'error', message: 'bad url' });
let media;
if (m.kind === 'image') { media = document.createElement('img'); media.alt = ''; } else {
media = document.createElement('video'); media.controls = true; media.autoplay = true; media.playsInline = true; media.setAttribute('playsinline', '');
}
media.style.cssText = 'max-width:100%;max-height:calc(100% - 44px);display:block';
media.onerror = () => out({ ev: 'play', id: '', state: 'error', message: 'cannot play' });
media.src = url;
const close = document.createElement('button');
close.textContent = String(m.close || '\u00d7');
close.style.cssText = 'position:absolute;top:6px;right:6px;min-width:36px;height:28px;font:13px sans-serif;background:#c0c0c0;color:#000;border:2px outset #fff;cursor:pointer';
close.onclick = () => { closePlayer(); out({ ev: 'play', id: '', state: 'closed' }); };
box.append(media, close);
document.body.appendChild(box);
player = box;
lastRect = ''; place(true);
}
function wire(id, peer, ch) {
peer.channels.set(ch.label, ch);
ch.binaryType = 'arraybuffer';
ch.onopen = () => out({ ev: 'open', id, label: ch.label });
ch.onclose = () => out({ ev: 'close', id, label: ch.label });
ch.onmessage = (e) => {
if (typeof e.data === 'string') return out({ ev: 'message', id, label: ch.label, text: e.data });
const bytes = new Uint8Array(e.data); let s = '';
for (let i = 0; i < bytes.length; i += 0x8000) s += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
out({ ev: 'message', id, label: ch.label, b64: btoa(s) });
};
}
const stunUrl = (s) => String(s || '').replace(/^stun:\/\//, 'stun:');
const turnServer = (t) => { // turn://user:pass@host:port
const m = /^turns?:\/\/([^:@]+):([^@]+)@(.+)$/.exec(String(t || ''));
return m ? { urls: (t.startsWith('turns') ? 'turns:' : 'turn:') + m[3], username: decodeURIComponent(m[1]), credential: decodeURIComponent(m[2]) } : null;
};
const iceList = (list) => { // only stun: / turn: / turns: urls with string credentials
if (!Array.isArray(list)) return null;
const out = [];
for (const s of list) {
const urls = (Array.isArray(s?.urls) ? s.urls : [s?.urls]).map(String).filter((u) => /^(stuns?|turns?):/.test(u));
if (!urls.length) continue;
const server = { urls };
if (typeof s.username === 'string') server.username = s.username;
if (typeof s.credential === 'string') server.credential = s.credential;
out.push(server);
}
return out;
};
async function run(m) {
const id = String(m.id || '');
if (m.op === 'peer') {
if (typeof RTCPeerConnection === 'undefined') return out({ ev: 'error', id, message: 'this browser has no WebRTC' });
peers.get(id)?.pc.close();
// m.ice: RTCConfiguration.iceServers as given by PHP ([{urls, username?, credential?}]: a TURN with
// short-lived credentials, several transports); else m.stun / m.turn (one of each)
let iceServers = iceList(m.ice);
if (!iceServers) {
iceServers = [];
if (m.stun) iceServers.push({ urls: stunUrl(m.stun) });
const turn = turnServer(m.turn); if (turn) iceServers.push(turn);
}
const pc = new RTCPeerConnection({ iceServers, bundlePolicy: 'max-bundle' });
const peer = { pc, channels: new Map(), wantOffer: false };
peers.set(id, peer);
pc.onicecandidate = (e) => { if (e.candidate?.candidate) out({ ev: 'ice', id, candidate: e.candidate.candidate, mline: e.candidate.sdpMLineIndex ?? 0 }); };
pc.onconnectionstatechange = () => out({ ev: 'state', id, state: pc.connectionState });
pc.ondatachannel = (e) => wire(id, peer, e.channel);
pc.ontrack = (e) => {
let s = remote.get(id);
if (!s) { s = new MediaStream(); remote.set(id, s); }
if (!s.getTracks().includes(e.track)) s.addTrack(e.track);
attach(id);
out({ ev: 'track', id, kind: e.track.kind });
};
return;
}
switch (m.op) {
case 'media': return askMedia(m);
case 'mute': local?.getAudioTracks().forEach((t) => { t.enabled = !m.on; }); return;
case 'camera': local?.getVideoTracks().forEach((t) => { t.enabled = !!m.on; }); return;
case 'switch': return switchCamera();
case 'stopmedia': stopLocal(); layTiles([]); return;
case 'tiles': return layTiles(m.tiles);
case 'play': return play(m);
case 'stopplay': return closePlayer();
default: break;
}
const peer = peers.get(id);
if (!peer) return out({ ev: 'error', id, message: 'unknown peer ' + id });
const pc = peer.pc;
switch (m.op) {
case 'channel': {
const o = { ordered: m.ordered !== false };
if (m.retransmits !== undefined) o.maxRetransmits = m.retransmits | 0;
wire(id, peer, pc.createDataChannel(String(m.label || 'data'), o));
break;
}
case 'offer': {
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
out({ ev: 'offer', id, sdp: pc.localDescription.sdp });
break;
}
case 'remote':
await pc.setRemoteDescription({ type: m.type === 'offer' ? 'offer' : 'answer', sdp: String(m.sdp || '') });
if (m.type === 'offer') {
await pc.setLocalDescription(await pc.createAnswer());
out({ ev: 'answer', id, sdp: pc.localDescription.sdp });
}
break;
case 'ice':
if (m.candidate) await pc.addIceCandidate({ candidate: String(m.candidate), sdpMLineIndex: m.mline | 0 });
break;
case 'send': {
const ch = peer.channels.get(String(m.label || 'data'));
if (!ch || ch.readyState !== 'open') break;
if (m.b64 !== undefined) ch.send(Uint8Array.from(atob(m.b64), (c) => c.charCodeAt(0)));
else ch.send(String(m.text ?? ''));
break;
}
case 'tracks':
// the camera / microphone in this connection (before the offer or the answer); without them, receive only
for (const kind of ['audio', 'video']) {
const track = local?.getTracks().find((t) => t.kind === kind);
if (track) pc.addTrack(track, local);
else pc.addTransceiver(kind, { direction: 'recvonly' });
}
break;
case 'close':
pc.close(); peers.delete(id); remote.delete(id);
out({ ev: 'state', id, state: 'closed' });
break;
case 'screen':
out({ ev: 'error', id, message: 'screen sharing is a desktop feature (the native sidecar)' });
break;
default:
break;
}
}
// one queue per peer: an ICE candidate must wait for the description before it (setRemoteDescription is asynchronous)
const queues = new Map();
api.on('webrtc', (m) => {
const id = String(m.id || '');
const next = (queues.get(id) || Promise.resolve()).then(() => run(m)).catch((e) => out({ ev: 'error', id, message: e?.message || String(e) }));
queues.set(id, next);
next.then(() => { if (queues.get(id) === next) queues.delete(id); });
});
addEventListener('pagehide', () => { for (const p of peers.values()) p.pc.close(); stopLocal(); });
addEventListener('resize', () => place(true));
return {};
}