Blog

Chiamate vocali e stanze audio in un’app web: come funzionano

· Andrij Tkachenko · 8 min di lettura

Due finestre del browser unite da una linea tratteggiata con onde sonore, accanto a una sala rotonda di posti dove due persone parlano al microfono e le altre ascoltano

Una chiamata vocale in un’app web è una chiamata WebRTC con una traccia del microfono e nessuna fotocamera: la stessa connessione di una videochiamata, che porta qualche decina di kilobit al secondo invece di centinaia. Una stanza audio è una chiamata di gruppo dove poche persone parlano e tutti gli altri ascoltano, e per questo servono un media server e una regola sul tuo server che dica chi può parlare.

Entrambe sono chiamate tra gli utenti della tua app, per i loro account, via internet. Non ci sono numeri di telefono né rete telefonica. Questo articolo mostra cosa invia una chiamata vocale, misurato in Chromium, il codice del browser che le serve, in cosa una stanza audio differisce da una chiamata tra due, e come un’app aggiunge entrambe senza costruire la parte dei media.

Una chiamata vocale è una videochiamata senza fotocamera

Ogni browser che parla WebRTC deve supportare due codec audio: Opus, e G.711 come PCMA e PCMU per i sistemi telefonici più vecchi (RFC 7874). Dove entrambi i lati possono, Opus viene prima. Opus copre tutto, da 6 kbit/s per la voce a banda stretta fino a 510 kbit/s per la musica stereo, e la sua stessa specifica indica da 16 a 20 kbit/s come il punto ideale per la voce a banda larga (RFC 6716).

Abbiamo avviato una chiamata solo audio tra due connessioni in Chromium 156, con il suo microfono finto, e letto cosa riportava chi inviava:

Cosa abbiamo letto Vocale Video
Codec Opus, 48 kHz, mono VP8
Suono o immagine circa 21 kbit/s quasi 480 kbit/s
Header RTP circa 12 kbit/s

La chiamata vocale inviava 50 pacchetti al secondo, uno ogni 20 millisecondi di suono, e gli header di quei pacchetti arrivavano a più della metà del suono che contenevano. IP e UDP aggiungono altro sulla rete. La videochiamata, un’immagine 640 per 480 dalla fotocamera finta, era vicina a 480 kbit/s dopo 20 secondi e saliva ancora man mano che il browser trovava più spazio, quindi il suo valore dice più sull’inizio di una chiamata che sulla sua fine.

Una chiamata vocale porta quindi molti meno bit di una videochiamata, ed è per questo che regge su una rete mobile debole dove il video scatta. Tutto il resto è uguale: un’offerta e una risposta, gli indirizzi dei due lati, e un relay per le reti che bloccano un percorso diretto.

Il codice del browser

Una chiamata vocale chiede soltanto il microfono, e riproduce ciò che torna in un elemento <audio>:

JavaScript
// call.js: il microfono, con la cancellazione dell’eco, del rumore e il controllo del livello del browser
const stream = await navigator.mediaDevices.getUserMedia({
  audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true },
});

const pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.example.com:3478' }] });
pc.addTrack(stream.getAudioTracks()[0], stream);

pc.ontrack = ({ streams }) => {
  const audio = document.getElementById('them');
  audio.srcObject = streams[0];
  // Un browser riproduce il suono solo dopo che la persona ha cliccato o scritto sulla pagina.
  audio.play().catch(() => showTurnSoundOn());
};

// Muto: la traccia continua, e l’altro lato sente silenzio.
document.getElementById('mute').onclick = () => {
  const track = stream.getAudioTracks()[0];
  track.enabled = !track.enabled;
};
HTML
<audio id="them" autoplay></audio>
<button id="mute">Mute</button>

L’offerta, la risposta e i candidati passano per un server di signaling, esattamente come per il video: come WebRTC collega due browser contiene quel relay, poche righe di Node.js, e la pagina intorno. Tre cose contano più in una chiamata vocale che in una video:

  1. L’eco. Senza cuffie, l’altoparlante di un portatile riproduce l’altra persona nel suo stesso microfono. RFC 7874 chiede a ogni endpoint WebRTC di cancellare quell’eco, e Chromium aveva tutte e tre le opzioni qui sopra attive di default quando abbiamo letto track.getSettings() su un semplice { audio: true }. Chiedile comunque, e lasciale attive a meno che l’app non riproduca musica.
  2. Il suono che non parte. I browser trattengono il suono finché la persona non ha usato la pagina. Una chiamata a cui si risponde con un clic va bene. Una chiamata aperta da un link in una nuova scheda può collegarsi in silenzio, quindi dai alla pagina un pulsante che avvia il suono quando play() rifiuta.
  3. Muto senza riagganciare. Spegnere track.enabled invia silenzio e mantiene la connessione, così riaccenderlo è immediato e non chiede nulla. Fermare la traccia vorrebbe dire chiedere di nuovo il microfono.

Se il problema è il microfono stesso, il test del microfono trova quale parte non funziona, nel browser, prima di qualsiasi chiamata.

Una stanza audio è una chiamata di gruppo con ascoltatori

Una chiamata tra due persone va da un browser all’altro. Una stanza di venti non può funzionare così: in una mesh, ogni persona che parla invia una copia della sua voce a ogni altra persona, quindi l’upload cresce con ognuno che entra. Le chiamate di gruppo inviano ogni voce una sola volta a un media server, che la passa a tutti gli altri (come funzionano le videochiamate di gruppo).

Una stanza audio ci aggiunge dei ruoli:

Tra due Stanza audio
Chi parla entrambi i relatori, pochi
Dove va il suono da browser a browser via un media server
Chi decide loro due l’host e il tuo server

Gli ascoltatori non inviano proprio nulla. Ricevono le voci dei relatori, ognuna inoltrata dal server, e i loro microfoni restano chiusi. Un ascoltatore alza la mano, l’host lo fa parlare, e più tardi lo rende di nuovo ascoltatore.

Quest’ultima parte va decisa su un server. Un pulsante che nasconde soltanto il microfono nella pagina non è una regola: chiunque può aprire la console del browser e inviare suono comunque. Il media server deve rifiutare ciò che invia un ascoltatore, e toglierlo a chi smette di essere relatore, su una prova che solo il tuo server può dare.

Cosa vale ancora

Fare a meno della fotocamera fa risparmiare banda e nient’altro. Una chiamata vocale ha ancora bisogno di:

  • STUN e TURN. Alcune reti bloccano un percorso diretto tra due dispositivi, per la voce come per il video. Un relay sulla porta 443 fa passare quelle chiamate (i server STUN e TURN, spiegati).
  • Lo squillo. La persona chiamata deve sentirlo in qualunque scheda o dispositivo abbia aperto, e smettere di sentirlo negli altri appena risponde.
  • Una connessione che sopravvive a un cambio di rete. Un telefono che passa dal Wi-Fi ai dati mobili perde il percorso su cui era la chiamata, quindi la chiamata deve trovarne uno nuovo senza riagganciare.

Chiamate vocali e stanze audio con WordPlus Cloud

Con il pacchetto @wordplus/realtime, una chiamata vocale è una videochiamata con type: 'audio'. La tua app decide chi può chiamare chi in una sua route, che risponde con un token per la chiamata. In Express:

JavaScript
// server.mjs: GET /call-token?to=34&type=audio, che il pulsante chiede quando viene premuto.
app.get('/call-token', async (req, res) => {
  // Qui va il tuo controllo: chi può chiamare chi.
  const me = req.session.userId;
  if (!me) return res.sendStatus(401);
  res.json({ token: await realtime.callToken(me, req.query.to, { type: req.query.type }) });
});
JavaScript
await rt.callScreen(); // lo squillo e la finestra di chiamata, su ogni pagina dove una chiamata può squillare
HTML
<call-button to="34" token-url="/call-token" type="audio" name="Ann">Call Ann</call-button>

La chiamata squilla in ogni scheda e su ogni dispositivo che Ann ha aperto. Va direttamente tra i due browser quando le loro reti lo consentono, attraverso i nostri relay sulle porte 443 e 80 quando non lo consentono, e attraverso i nostri media server quando nemmeno i relay arrivano, passando dall’uno all’altro senza riagganciare. Le chiamate tra due persone sono cifrate end-to-end su ogni percorso, e non consumano crediti su nessuno di essi.

Una stanza audio è una chiamata di gruppo i cui token dicono type: 'audio', con publish: false per gli ascoltatori. Qui l’host della stanza 7 parla e la gestisce, e gli altri ascoltano finché non vengono fatti parlare:

JavaScript
// GET /room-token?id=7, che <group-call-button call="room:7" token-url="/room-token?id=7" type="audio"> chiede.
app.get('/room-token', async (req, res) => {
  const me = req.session.userId;
  if (!me) return res.sendStatus(401);
  const host = await isHostOf(req.query.id, me); // tua, dai tuoi dati
  res.json({
    token: await realtime.groupCallToken(me, `room:${req.query.id}`, {
      type: 'audio',
      admin: host,
      publish: host || (await maySpeak(req.query.id, me)),
    }),
  });
});

// L’host fa parlare qualcuno, o lo rende di nuovo ascoltatore, mentre la stanza è in corso.
await realtime.call('room:7').permit(34, { publish: true });

La schermata di chiamata dà all’host Promote to Speaker e Demote to Viewer su ogni persona, e i media server rifiutano il suono di chiunque il tuo token o permit() abbiano reso ascoltatore. Una chiamata di gruppo è cifrata end-to-end quando i suoi token dicono encrypt: true. Nelle chiamate di gruppo, un certo numero di persone in video allo stesso tempo non consuma crediti con il tuo piano, una persona in audio contando la metà, e ognuna oltre quel numero consuma un credito al minuto, in audio la metà (limiti). A quanto arriva un mese di chiamate: come stimare il costo delle videochiamate.

Lezioni, webinar e stanze audio mostra le mani alzate e un tuo pulsante Let speak in Node, PHP e Python, e la pagina sulle chiamate della guida Express il resto: chi può chiamare, un’interfaccia di chiamata tutta tua, e le chiamate in una chat.

Chiamate vocali per la tua app

WordPlus Cloud for Apps ha un prezzo in base alle connessioni simultanee, a partire da 1.000, con fatturazione mensile o annuale, e le chiamate tra due persone non consumano crediti su nessun percorso. Scopri videochiamate e chiamate di gruppo per le app, oppure i prezzi per le app. Domande sulla tua integrazione? Scrivici.