Transfer saved songs directly between paired devices with resumable OPFS writes
This commit is contained in:
Jonathan Sykes
@@ -4754,6 +4754,8 @@ const Remote = (() => {
|
||||
const hostSend = (m) => { if (host.ws && host.ws.readyState === 1) host.ws.send(JSON.stringify(m)); };
|
||||
|
||||
function onHostMessage(m) {
|
||||
DirectMedia.attach('remote-host', { send: hostSend, peers: () => host.remotes.map(r => ({ id: r.rid, name: r.name })) });
|
||||
if (m.type === 'direct') { DirectMedia.handle('remote-host', m); return; }
|
||||
if (m.type === 'hello') {
|
||||
host.code = m.code; host.codeExpires = m.codeExpires; host.remotes = m.remotes || [];
|
||||
host.lastState = ''; host.lastQueue = '';
|
||||
@@ -5061,6 +5063,8 @@ const Remote = (() => {
|
||||
}
|
||||
|
||||
function onRemoteMessage(m) {
|
||||
DirectMedia.attach('remote-client', { send: rcSend, peers: () => [{ id: 'host', name: 'Paired screen' }] });
|
||||
if (m.type === 'direct') { DirectMedia.handle('remote-client', m); return; }
|
||||
if (m.type === 'hello') {
|
||||
rc.online = true;
|
||||
$('rvHostName').textContent = m.hostName || 'Screen';
|
||||
@@ -7452,6 +7456,8 @@ const Party = (() => {
|
||||
}
|
||||
|
||||
function onMessage(m) {
|
||||
DirectMedia.attach('party', { send, peers: () => st.members.filter(m => m.pid !== pid).map(m => ({ id: m.pid, name: m.name })) });
|
||||
if (m.type === 'direct') { DirectMedia.handle('party', m); return; }
|
||||
if (m.type === 'hello') {
|
||||
st.code = m.code;
|
||||
if (m.secret) { st.secret = m.secret; ls.set(HOST_KEY, JSON.stringify({ code: m.code, secret: m.secret })); }
|
||||
@@ -12527,6 +12533,10 @@ async function boot() {
|
||||
Party.boot();
|
||||
PartyDJ.register(() => $('navPartyBtn').click());
|
||||
SetlistImport.configure({ library: async () => { let uploads = []; try { const j = await webFetch('/api/uploads?limit=200'); uploads = j.uploads || []; } catch {} return [...data.history, ...data.playlists.flatMap(p => p.videos || []), ...uploads]; }, search: async q => (await API.search(q)).results || [], modal: showModal, close: closeModal, create: (name, videos) => { const pl = { id: uid(), name, videos: videos.map(v => ({ ...slim(v), tags: v.tags, key: v.key, chordPro: v.chordPro })) }; data.playlists.push(pl); persist(); view = { type: 'playlist', id: pl.id }; render(); toast(`Imported ${videos.length} songs`); } });
|
||||
DirectMedia.configure({ settings: () => data.settings, persist, current: () => current?.meta, notify: toast,
|
||||
saved: async file => { cachedIds.add(file.id); await DeviceDB.putFile({ videoId: file.id, cid: file.cid, size: file.size, savedAt: Date.now(), state: 'unverified' }); if (!data.history.some(v => v.id === file.id)) data.history.unshift({ ...file, thumbnail: '' }); persist(); renderSidebar(); },
|
||||
fallback: file => { const body = document.createElement('p'); body.textContent = 'The devices could not finish a direct connection. Keep both screens open and send again to resume, or choose the existing server download.'; showModal('Direct transfer unavailable', body, [{ label: 'Keep partial copy', onClick: closeModal }, { label: 'Use server copy', onClick: () => { closeModal(); preload(file, { retry: true, directFallback: true }); } }]); },
|
||||
});
|
||||
Remote.boot();
|
||||
LyricsDisplay.register();
|
||||
LowerThird.register(() => $('remoteChip').click());
|
||||
|
||||
6
frontend/direct-media.css
Normal file
6
frontend/direct-media.css
Normal file
@@ -0,0 +1,6 @@
|
||||
.direct-transfer-dialog{max-width:min(420px,calc(100vw - 32px));padding:24px;border:1px solid var(--border);border-radius:var(--radius,16px);background:var(--surface,#202026);color:var(--text,#fff)}
|
||||
.direct-transfer-dialog::backdrop{background:rgba(0,0,0,.65)}
|
||||
.direct-transfer-dialog p{line-height:1.6;color:var(--text-2);overflow-wrap:anywhere}
|
||||
.direct-transfer-dialog button,#settings-section-direct-transfer button{min-height:44px;padding:10px 16px;margin:4px;border:1px solid var(--border);border-radius:10px;background:var(--surface-2,#303039);color:var(--text,#fff)}
|
||||
.direct-transfer-dialog button:focus-visible,#settings-section-direct-transfer button:focus-visible{outline:2px solid var(--accent);outline-offset:3px}
|
||||
#settings-section-direct-transfer label{display:flex;align-items:center;gap:12px;min-height:44px}
|
||||
134
frontend/direct-media.js
Normal file
134
frontend/direct-media.js
Normal file
@@ -0,0 +1,134 @@
|
||||
/* 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));
|
||||
38
frontend/direct-recv-worker.js
Normal file
38
frontend/direct-recv-worker.js
Normal file
@@ -0,0 +1,38 @@
|
||||
'use strict';
|
||||
importScripts('/sha256.js');
|
||||
let dir, handle, access, hash, pos = 0, claim, name;
|
||||
let chain = Promise.resolve();
|
||||
self.onmessage = e => { chain = chain.then(() => run(e.data)); };
|
||||
async function close() { if (access) { access.flush(); access.close(); access = null; } }
|
||||
async function run(m) {
|
||||
try {
|
||||
if (m.op === 'open') {
|
||||
claim = m.file;
|
||||
if (!/^[A-Za-z0-9_-]{1,128}$/.test(claim.id) || !/^[a-f0-9]{64}$/.test(claim.cid)) throw Error('Invalid file identity');
|
||||
dir = await (await navigator.storage.getDirectory()).getDirectoryHandle('videos', { create: true });
|
||||
name = `${claim.id}.${claim.cid}.direct.part`;
|
||||
handle = await dir.getFileHandle(name, { create: true });
|
||||
access = await handle.createSyncAccessHandle();
|
||||
pos = access.getSize(); if (pos > claim.size) { access.truncate(0); pos = 0; }
|
||||
hash = self.Sha256.create();
|
||||
for (let at = 0; at < pos; at += 1024 * 1024) { const b = new Uint8Array(Math.min(1024 * 1024, pos - at)); access.read(b, { at }); hash.update(b); }
|
||||
self.postMessage({ op: 'opened', offset: pos });
|
||||
} else if (m.op === 'chunk') {
|
||||
const b = new Uint8Array(m.buf);
|
||||
if (!access || b.length > 65536 || pos + b.length > claim.size) throw Error('Invalid file chunk');
|
||||
if (access.write(b, { at: pos }) !== b.length) throw Error('Incomplete OPFS write');
|
||||
hash.update(b); pos += b.length; access.flush();
|
||||
self.postMessage({ op: 'progress', received: pos });
|
||||
} else if (m.op === 'abort') { await close(); self.postMessage({ op: 'closed' }); }
|
||||
else if (m.op === 'finish') {
|
||||
await close();
|
||||
if (pos !== claim.size || hash.hex() !== claim.cid) { await dir.removeEntry(name); throw Error('File verification failed; retry starts from zero'); }
|
||||
const final = `${claim.id}.mp4`;
|
||||
// Copy only after verification; existing saved playback remains intact until then.
|
||||
const out = await (await dir.getFileHandle(final, { create: true })).createSyncAccessHandle();
|
||||
try { const f = await handle.getFile(); for (let at = 0; at < f.size; at += 1024 * 1024) out.write(new Uint8Array(await f.slice(at, at + 1024 * 1024).arrayBuffer()), { at }); out.truncate(f.size); out.flush(); } finally { out.close(); }
|
||||
await dir.removeEntry(name);
|
||||
self.postMessage({ op: 'done', file: claim });
|
||||
}
|
||||
} catch (e) { await close(); self.postMessage({ op: 'error', error: e.message }); }
|
||||
}
|
||||
@@ -28,6 +28,7 @@
|
||||
<link rel="stylesheet" href="theme-classic.css" />
|
||||
<link rel="stylesheet" href="recommendations.css" />
|
||||
<link rel="stylesheet" href="settings-sections.css" />
|
||||
<link rel="stylesheet" href="direct-media.css" />
|
||||
<link rel="stylesheet" href="lower-third.css" />
|
||||
<link rel="stylesheet" href="car-mode.css" />
|
||||
<link rel="stylesheet" href="offline-pages.css" />
|
||||
@@ -660,6 +661,8 @@
|
||||
<script src="async-guard.js"></script>
|
||||
<script src="sw-update.js"></script>
|
||||
<script src="settings-sections.js"></script>
|
||||
<script src="direct-protocol.js"></script>
|
||||
<script src="direct-media.js"></script>
|
||||
<script src="download-errors.js"></script>
|
||||
<script src="downloads.js"></script>
|
||||
<script src="downloads-page.js"></script>
|
||||
|
||||
@@ -285,7 +285,7 @@
|
||||
// and only for the exact cid this device holds.
|
||||
let restoring = false;
|
||||
onMessage('upload-request', async (m) => {
|
||||
if (restoring || hooks.getSettings().p2pShare === false) return;
|
||||
if (restoring || hooks.getSettings().p2pShare === false || hooks.getSettings().directTransfer !== false) return;
|
||||
const rec = window.DeviceDB ? await window.DeviceDB.getFile(m.videoId) : null;
|
||||
if (!rec || rec.cid !== m.cid) return;
|
||||
restoring = true;
|
||||
|
||||
@@ -81,6 +81,10 @@ const SHELL = [
|
||||
'/hash-worker.js',
|
||||
'/p2p-client.js',
|
||||
'/p2p-core.js',
|
||||
'/direct-media.css',
|
||||
'/direct-protocol.js',
|
||||
'/direct-media.js',
|
||||
'/direct-recv-worker.js',
|
||||
'/p2p-transfer.js',
|
||||
'/p2p-recv-worker.js',
|
||||
'/settings-sections.js',
|
||||
|
||||
2
playwright.direct.config.js
Normal file
2
playwright.direct.config.js
Normal file
@@ -0,0 +1,2 @@
|
||||
const { defineConfig } = require('@playwright/test');
|
||||
module.exports = defineConfig({ testDir: './tests', testMatch: /direct-transfer\.spec\.js/, timeout: 40000, workers: 1, use: { browserName: 'chromium', baseURL: 'http://localhost:8095', serviceWorkers: 'block' }, webServer: { command: 'bun tests/fixtures/direct-server.js', port: 8095, reuseExistingServer: false } });
|
||||
28
tests/direct-transfer.spec.js
Normal file
28
tests/direct-transfer.spec.js
Normal file
@@ -0,0 +1,28 @@
|
||||
const { test, expect } = require('@playwright/test');
|
||||
test('paired pages save verified bytes directly over WebRTC with metadata-only server logs', async ({ browser, request }) => {
|
||||
const a = await browser.newContext(), b = await browser.newContext();
|
||||
const sender = await a.newPage(), receiver = await b.newPage();
|
||||
await sender.goto('/?id=sender'); await receiver.goto('/?id=receiver');
|
||||
await sender.waitForFunction(() => window.ready); await receiver.waitForFunction(() => window.ready);
|
||||
await receiver.evaluate(async () => {
|
||||
const bytes = Uint8Array.from({ length: 2000000 }, (_, i) => i % 251), h = Sha256.create(); h.update(bytes);
|
||||
const dir = await (await navigator.storage.getDirectory()).getDirectoryHandle('videos', { create: true });
|
||||
const w = await (await dir.getFileHandle(`testvideo.${h.hex()}.direct.part`, { create: true })).createWritable();
|
||||
await w.write(bytes.slice(0, 12345)); await w.close();
|
||||
});
|
||||
await sender.locator('#send').click();
|
||||
await expect(receiver.getByRole('dialog')).toBeVisible();
|
||||
expect(await receiver.evaluate(() => !!window.received)).toBe(false);
|
||||
await receiver.getByRole('button', { name: 'Accept & save' }).click();
|
||||
await receiver.waitForFunction(() => !!window.received);
|
||||
const result = await receiver.evaluate(async () => {
|
||||
const d = await (await navigator.storage.getDirectory()).getDirectoryHandle('videos');
|
||||
const f = await (await d.getFileHandle('testvideo.mp4')).getFile();
|
||||
const hash = Sha256.create(); hash.update(new Uint8Array(await f.arrayBuffer())); return { size: f.size, cid: hash.hex(), expected: window.received.cid };
|
||||
});
|
||||
expect(await receiver.evaluate(() => window.resumeOffsets)).toEqual([12345]);
|
||||
expect(result.size).toBe(2000000); expect(result.cid).toBe(result.expected);
|
||||
const logs = await (await request.get('/audit')).json();
|
||||
expect(logs.every(x => !x.http && ['invite','accept','signal','complete'].includes(x.signalling))).toBe(true);
|
||||
await a.close(); await b.close();
|
||||
});
|
||||
27
tests/fixtures/direct-server.js
vendored
Normal file
27
tests/fixtures/direct-server.js
vendored
Normal file
@@ -0,0 +1,27 @@
|
||||
import { createDirectRelay } from '../../server/direct-relay.js';
|
||||
const relay = createDirectRelay(), peers = new Map(), log = [];
|
||||
Bun.serve({ port: 8095,
|
||||
async fetch(req, server) {
|
||||
const url = new URL(req.url);
|
||||
if (url.pathname === '/ws') { const id = url.searchParams.get('id'); if (!['sender', 'receiver'].includes(id)) return new Response('test member required', { status: 403 }); server.upgrade(req, { data: { id } }); return; }
|
||||
if (url.pathname === '/audit') return Response.json(log);
|
||||
if (url.pathname.startsWith('/api/')) { log.push({ http: url.pathname }); return new Response('Media forbidden in direct fixture', { status: 500 }); }
|
||||
if (url.pathname === '/') return new Response(`<!doctype html><button id="send">Send</button><div id="status"></div><script src="/sha256-wasm.js"></script><script src="/sha256.js"></script><script src="/direct-protocol.js"></script><script src="/settings-sections.js"></script><script src="/direct-media.js"></script><script>
|
||||
const id = new URL(location.href).searchParams.get('id');
|
||||
const ws = new WebSocket('ws://localhost:8095/ws?id=' + id);
|
||||
window.resumeOffsets = []; const NativeWorker = window.Worker; window.Worker = class extends NativeWorker { constructor(...args) { super(...args); this.addEventListener('message', e => { if(e.data.op === 'opened') window.resumeOffsets.push(e.data.offset); }); } };
|
||||
const meta = { id: 'testvideo', title: 'Direct test', channel: 'Fixture', duration: 1 };
|
||||
window.OPFS = { getFileObject: async () => new File([Uint8Array.from({length: 2000000}, (_,i)=>i%251)], 'test.mp4') };
|
||||
DirectMedia.configure({ current: () => meta, notify: text => document.getElementById('status').textContent = text, saved: file => window.received = file, fallback: () => window.failed = true });
|
||||
ws.onopen = () => { DirectMedia.attach('test', { send: m => ws.send(JSON.stringify(m)), peers: () => [{id: id === 'sender' ? 'receiver' : 'sender', name: 'Other'}] }); window.ready = true; };
|
||||
ws.onmessage = e => DirectMedia.handle('test', JSON.parse(e.data));
|
||||
document.getElementById('send').onclick = () => DirectMedia.offer('test','receiver',meta);
|
||||
</script>`, { headers: { 'Content-Type': 'text/html' } });
|
||||
const path = url.pathname.slice(1); if (!/^[a-z0-9-]+\.js$/.test(path)) return new Response('not found', { status: 404 });
|
||||
return new Response(Bun.file(`frontend/${path}`));
|
||||
}, websocket: {
|
||||
open(ws) { peers.set(ws.data.id, ws); },
|
||||
message(ws, message) { log.push({ signalling: typeof message === 'string' ? JSON.parse(message).action : 'BINARY' }); relay.handle(ws.data.id, typeof message === 'string' ? message : null, peers, (target,m) => target.send(JSON.stringify(m))); },
|
||||
close(ws) { peers.delete(ws.data.id); },
|
||||
}
|
||||
});
|
||||
Reference in New Issue
Block a user