135 lines
9.4 KiB
JavaScript
135 lines
9.4 KiB
JavaScript
/* Paired-room transport; signalling only goes to the server. */
|
|
(function (root) {
|
|
'use strict';
|
|
const rooms = new Map(), transfers = new Map(), pending = new Map();
|
|
let hooks = { settings: () => ({}), persist() {}, current: () => null, saved() {}, notify() {}, fallback() {} };
|
|
const enabled = () => hooks.settings().directTransfer !== false && !!root.RTCPeerConnection;
|
|
function attach(key, room) { rooms.set(key, room); }
|
|
function send(key, m) { const r = rooms.get(key); if (!r) throw Error('Paired device disconnected'); r.send(m); }
|
|
function signal(key, token, data) { send(key, { type: 'direct', action: 'signal', token, data }); }
|
|
async function offer(key, to, meta) {
|
|
if (!enabled()) throw Error('Direct device transfer is unavailable or turned off');
|
|
if (!meta?.id) throw Error('Choose a saved song first');
|
|
const file = await root.OPFS.getFileObject(meta.id);
|
|
if (!file) throw Error('Save this song on this device before sending it');
|
|
const hash = root.Sha256.create();
|
|
for (let at = 0; at < file.size; at += 1024 * 1024) hash.update(new Uint8Array(await file.slice(at, at + 1024 * 1024).arrayBuffer()));
|
|
const claim = root.DirectProtocol.file({ ...meta, cid: hash.hex(), size: file.size, title: meta.title || meta.id });
|
|
if (!claim) throw Error('Unsupported file metadata');
|
|
pending.set(`${key}:${to}:${claim.id}`, { file, claim });
|
|
send(key, { type: 'direct', action: 'invite', to, file: claim });
|
|
hooks.notify('Waiting for the receiving device to accept');
|
|
}
|
|
function finish(s, error) {
|
|
if (s.done) return; s.done = true; clearTimeout(s.timer); clearTimeout(s.idle);
|
|
s.pc?.close(); transfers.delete(s.token);
|
|
if (s.worker) { s.worker.postMessage({ op: 'abort' }); setTimeout(() => s.worker.terminate(), 1000); }
|
|
if (error) { hooks.notify(`${error}. Partial copy kept for resume.`); hooks.fallback(s.claim, () => offer(s.key, s.peer, s.claim).catch(e => hooks.notify(e.message))); }
|
|
}
|
|
function connection(s, receiver) {
|
|
const pc = s.pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] });
|
|
s.ice = [];
|
|
pc.onicecandidate = e => { if (e.candidate) signal(s.key, s.token, { kind: 'ice', candidate: e.candidate.toJSON() }); };
|
|
s.timer = setTimeout(() => finish(s, 'Direct connection failed after 10 seconds'), 10000);
|
|
pc.onconnectionstatechange = () => { if (['failed', 'closed'].includes(pc.connectionState)) finish(s, 'Direct connection closed'); };
|
|
const bump = () => { clearTimeout(s.idle); s.idle = setTimeout(() => finish(s, 'Direct transfer stalled'), 30000); };
|
|
const channel = dc => {
|
|
s.dc = dc; dc.binaryType = 'arraybuffer'; dc.bufferedAmountLowThreshold = 1024 * 1024;
|
|
dc.onopen = () => { clearTimeout(s.timer); bump(); if (receiver && s.offset != null) dc.send(JSON.stringify({ t: 'get', offset: s.offset })); };
|
|
dc.onclose = () => { if (!s.done) setTimeout(() => { if (!s.done) finish(s, 'Direct channel closed'); }, 3000); };
|
|
dc.onmessage = async e => {
|
|
bump();
|
|
try {
|
|
if (receiver) {
|
|
if (typeof e.data === 'string') { const m = JSON.parse(e.data); if (m.t === 'end') s.worker.postMessage({ op: 'finish' }); else throw Error('Unexpected file control'); }
|
|
else s.worker.postMessage({ op: 'chunk', buf: e.data }, [e.data]);
|
|
} else {
|
|
if (typeof e.data !== 'string' || s.started) throw Error('Unexpected file request');
|
|
const m = JSON.parse(e.data); if (m.t !== 'get') throw Error('Unexpected file request');
|
|
let pos = root.DirectProtocol.offset(m.offset, s.file.size); s.started = true;
|
|
while (pos < s.file.size && !s.done) {
|
|
if (dc.bufferedAmount > 4 * 1024 * 1024) await new Promise((resolve, reject) => {
|
|
const timeout = setTimeout(() => { cleanup(); reject(Error('Peer stopped receiving')); }, 10000);
|
|
const cleanup = () => { clearTimeout(timeout); dc.removeEventListener('bufferedamountlow', low); dc.removeEventListener('close', closed); };
|
|
const low = () => { cleanup(); resolve(); }, closed = () => { cleanup(); reject(Error('Peer disconnected')); };
|
|
dc.addEventListener('bufferedamountlow', low); dc.addEventListener('close', closed);
|
|
});
|
|
const range = root.DirectProtocol.nextChunk(pos, s.file.size);
|
|
dc.send(await s.file.slice(range.start, range.end).arrayBuffer()); pos = range.end; bump();
|
|
}
|
|
if (!s.done) dc.send(JSON.stringify({ t: 'end' }));
|
|
}
|
|
} catch (err) { finish(s, err.message); }
|
|
};
|
|
};
|
|
if (receiver) channel(pc.createDataChannel('file', { ordered: true })); else pc.ondatachannel = e => channel(e.channel);
|
|
return pc;
|
|
}
|
|
async function accept(key, m) {
|
|
const s = { key, token: m.token, claim: m.file, peer: m.from, receiver: true }; transfers.set(m.token, s);
|
|
connection(s, true);
|
|
s.worker = new Worker('/direct-recv-worker.js');
|
|
s.worker.onmessage = async e => {
|
|
const result = e.data;
|
|
if (result.op === 'opened') {
|
|
s.offset = result.offset;
|
|
send(key, { type: 'direct', action: 'accept', token: m.token });
|
|
const offer = await s.pc.createOffer(); await s.pc.setLocalDescription(offer); signal(key, m.token, { kind: 'offer', sdp: offer.sdp });
|
|
} else if (result.op === 'done') {
|
|
send(key, { type: 'direct', action: 'complete', token: m.token });
|
|
await hooks.saved(result.file); hooks.notify(`Saved ${result.file.title} directly from the other device`); finish(s);
|
|
} else if (result.op === 'error') finish(s, result.error);
|
|
};
|
|
s.worker.postMessage({ op: 'open', file: m.file });
|
|
}
|
|
async function handle(key, m) {
|
|
if (m.type !== 'direct') return;
|
|
try {
|
|
if (m.action === 'invite') {
|
|
if (!enabled() || !root.DirectProtocol.file(m.file)) return send(key, { type: 'direct', action: 'decline', token: m.token });
|
|
confirmReceive(key, m); return;
|
|
}
|
|
if (m.action === 'invited') {
|
|
const p = pending.get(`${key}:${m.to}:${m.file.id}`); if (!p) return;
|
|
pending.delete(`${key}:${m.to}:${m.file.id}`);
|
|
transfers.set(m.token, { key, token: m.token, peer: m.to, claim: p.claim, file: p.file }); return;
|
|
}
|
|
const s = transfers.get(m.token); if (!s || s.key !== key || m.from !== s.peer) return;
|
|
if (m.action === 'accept') connection(s, false);
|
|
else if (m.action === 'decline' || m.action === 'complete') finish(s);
|
|
else if (m.action === 'signal' && s.pc) {
|
|
const d = m.data;
|
|
if (d.kind === 'ice') { if (s.pc.remoteDescription) await s.pc.addIceCandidate(d.candidate); else s.ice.push(d.candidate); }
|
|
else {
|
|
await s.pc.setRemoteDescription({ type: d.kind, sdp: d.sdp });
|
|
for (const c of s.ice.splice(0)) await s.pc.addIceCandidate(c);
|
|
if (d.kind === 'offer') { const a = await s.pc.createAnswer(); await s.pc.setLocalDescription(a); signal(key, m.token, { kind: 'answer', sdp: a.sdp }); }
|
|
}
|
|
}
|
|
} catch (e) { const s = transfers.get(m.token); if (s) finish(s, e.message); else hooks.notify(e.message); }
|
|
}
|
|
function confirmReceive(key, m) {
|
|
const dialog = document.createElement('dialog'); dialog.className = 'direct-transfer-dialog';
|
|
const heading = document.createElement('h2'); heading.textContent = 'Save from your paired device?';
|
|
const text = document.createElement('p'); text.textContent = `${m.file.title} · ${(m.file.size / 1024 ** 2).toFixed(1)} MB. Media travels directly between devices. Keep both screens open. Playback starts after the full copy is verified.`;
|
|
const yes = document.createElement('button'); yes.textContent = 'Accept & save';
|
|
const no = document.createElement('button'); no.textContent = 'Decline';
|
|
const decline = () => { send(key, { type: 'direct', action: 'decline', token: m.token }); dialog.remove(); };
|
|
yes.onclick = () => { dialog.remove(); accept(key, m).catch(e => hooks.notify(e.message)); }; no.onclick = decline; dialog.oncancel = decline;
|
|
dialog.append(heading, text, yes, no); document.body.append(dialog); dialog.showModal();
|
|
}
|
|
function configure(h) {
|
|
hooks = { ...hooks, ...h };
|
|
root.SettingsSections.register({ id: 'direct-transfer', title: 'Direct device transfer', cluster: 'Library & storage', summary: () => enabled() ? 'On · paired devices only' : 'Off or unsupported', icon: '<path d="M4 6h6v12H4zM14 6h6v12h-6M10 10h4m-4 4h4"/>', render(container) {
|
|
const label = document.createElement('label'); const toggle = document.createElement('input'); toggle.type = 'checkbox'; toggle.checked = hooks.settings().directTransfer !== false;
|
|
toggle.onchange = () => { hooks.settings().directTransfer = toggle.checked; hooks.persist(); }; label.append(toggle, ' Direct device transfer (P2P)');
|
|
const help = document.createElement('p'); help.textContent = 'Pair through Remote or join a Watch Party, then send your currently playing saved song. The receiver confirms before saving. Keep both devices open. No TURN relay is used.';
|
|
container.append(label, help);
|
|
for (const [key, r] of rooms) for (const peer of r.peers()) {
|
|
const b = document.createElement('button'); b.textContent = `Send saved song to ${peer.name}`; b.style.minHeight = '44px'; b.onclick = () => offer(key, peer.id, hooks.current()).catch(e => hooks.notify(e.message)); container.append(b);
|
|
}
|
|
} });
|
|
}
|
|
root.DirectMedia = { configure, attach, handle, offer, enabled };
|
|
}(globalThis));
|