Blog

Videollamadas en JavaScript: cómo conecta WebRTC dos navegadores

· Andrij Tkachenko · 9 min de lectura

Dos ventanas de navegador, cada una con una cámara web y una persona en vídeo, unidas por una línea discontinua que pasa por un pequeño servidor marcado con llaves de código

Una videollamada en JavaScript necesita tres cosas: getUserMedia() para la cámara y el micrófono, una RTCPeerConnection que lleva la imagen y el sonido entre los dos navegadores, y un canal de señalización propio, casi siempre un websocket, por el que se pasan sus ofertas y sus direcciones de red. El navegador se encarga del audio y el vídeo, y todo lo que lo rodea, desde encontrar a la otra persona hasta atravesar un cortafuegos, lo construyes tú.

Este artículo muestra un videochat completo con WebRTC en menos de cien líneas de JavaScript puro, probado en dos pestañas del navegador, explica cada parte y después repasa lo que añade una app real antes de que la gente pueda confiar en él.

Las tres partes de una llamada WebRTC

Parte Qué hace
getUserMedia() Abre la cámara y el micrófono, después de que el navegador pregunte
RTCPeerConnection Conecta los dos navegadores y lleva el audio y el vídeo, cifrados
Señalización Pasa ofertas, respuestas y direcciones entre ellos, a través de tu servidor

Las dos primeras vienen en todos los navegadores modernos. La tercera no, y es a propósito. El JavaScript Session Establishment Protocol, que describe cómo funciona la API del navegador, deja en manos de la app la forma en que dos navegadores se encuentran. Tienen que intercambiar dos tipos de mensaje antes de que llegue ninguna imagen:

  • Una descripción, una oferta de un lado y una respuesta del otro, con el audio y el vídeo que enviará cada uno y cómo se cifran.
  • Candidatos, las direcciones en las que se puede encontrar a cada navegador: la suya en la red local, la pública que ve un servidor STUN y un relé en un servidor TURN, si tiene uno. Los navegadores las prueban por parejas hasta que una funciona (los servidores STUN y TURN, explicados).

Un videochat en JavaScript puro

Dos personas abren la misma página, y cada una ve a la otra. La página necesita dos elementos de vídeo:

HTML
<video id="me" autoplay playsinline muted></video>
<video id="them" autoplay playsinline></video>
<script type="module" src="/call.js"></script>

Tu propio vídeo lleva muted, para que no te oigas a ti mismo, y eso además deja que el navegador lo reproduzca antes de que nadie haga clic. playsinline lo mantiene dentro de la página en un iPhone.

El servidor de señalización

El servidor de señalización más pequeño pasa cada mensaje de un navegador al otro. En Node.js, con el paquete ws:

server.mjs
import { WebSocketServer, WebSocket } from 'ws';

const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', (socket) => {
  socket.on('message', (data) => {
    // Pásalo a todos los demás conectados: aquí, a la otra persona.
    for (const other of wss.clients) {
      if (other !== socket && other.readyState === WebSocket.OPEN) {
        other.send(data.toString());
      }
    }
  });
});

No sabe nada de llamadas. Solo reenvía texto, que es todo lo que es la señalización. El mismo relé en unas pocas líneas de Python, y un programa de Python que entra él mismo en la llamada, están en WebRTC en Python. Node.js también puede entrar en una llamada, con un paquete de npm que trae consigo la API del navegador, como muestra WebRTC en Node.js.

La página

Los dos navegadores ejecutan el mismo código. Cada uno abre su cámara, avisa de que está ahí y añade la cámara a la conexión cuando la otra persona también ha avisado, para que la primera oferta llegue a alguien. La parte que responde a los mensajes sigue el patrón de negociación perfecta de MDN, que deja empezar a cualquiera de los dos lados, incluso a los dos a la vez:

call.js
const local = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
document.getElementById('me').srcObject = local;

const signaler = new WebSocket('ws://localhost:8080');
await new Promise((resolve) => signaler.addEventListener('open', resolve, { once: true }));
const send = (message) => signaler.send(JSON.stringify(message));

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

// Añade la cámara cuando la otra persona esté ahí.
let started = false;
const start = () => {
  if (started) return;
  started = true;
  for (const track of local.getTracks()) pc.addTrack(track, local);
};

// Un lado cede cuando los dos ofrecen en el mismo momento.
const polite = location.hash === '#polite';
let makingOffer = false;
let ignoreOffer = false;
let isSettingRemoteAnswerPending = false;

pc.onnegotiationneeded = async () => {
  try {
    makingOffer = true;
    await pc.setLocalDescription();
    send({ description: pc.localDescription });
  } finally {
    makingOffer = false;
  }
};
pc.onicecandidate = ({ candidate }) => send({ candidate });
pc.ontrack = ({ streams }) => {
  document.getElementById('them').srcObject = streams[0];
};

signaler.onmessage = async ({ data }) => {
  const { here, description, candidate } = JSON.parse(data);
  if (here) {
    if (!started) send({ here: true }); // para que el otro lado también empiece
    start();
  } else if (description) {
    const readyForOffer = !makingOffer
      && (pc.signalingState === 'stable' || isSettingRemoteAnswerPending);
    const offerCollision = description.type === 'offer' && !readyForOffer;
    ignoreOffer = !polite && offerCollision;
    if (ignoreOffer) return;

    isSettingRemoteAnswerPending = description.type === 'answer';
    await pc.setRemoteDescription(description);
    isSettingRemoteAnswerPending = false;
    if (description.type === 'offer') {
      await pc.setLocalDescription();
      send({ description: pc.localDescription });
    }
  } else if (candidate) {
    try {
      await pc.addIceCandidate(candidate);
    } catch (error) {
      if (!ignoreOffer) throw error;
    }
  }
};

send({ here: true });

Arranca el servidor, sirve la página desde localhost y ábrela en una pestaña, y como /#polite en otra, en cualquier orden. Cada pestaña pide la cámara, y después cada una muestra a la otra. En un servidor tuyo, la página está en HTTPS, así que la dirección del websocket pasa a ser wss:// con un certificado, y stun.example.com representa un servidor STUN que tengas derecho a usar.

Lo que pasa, en orden:

  1. Se abre la cámara. getUserMedia() pregunta antes a la persona. MDN señala que solo funciona en un contexto seguro, una página en HTTPS o localhost, y que una negativa se rechaza con NotAllowedError. Cuando una cámara se queda en negro, nuestra guía para una cámara que no funciona repasa cada causa.
  2. Los dos se encuentran. Cada página dice here al conectarse. La primera no oye a nadie, y cuando llega la segunda, la primera la oye y responde, así que las dos saben que la otra está ahí.
  3. Añadir las pistas pide una negociación. La conexión lanza negotiationneeded, y setLocalDescription() sin argumentos crea una oferta, que sale por el websocket.
  4. El otro lado responde. Pone la oferta como su descripción remota, crea una respuesta de la misma forma y la devuelve.
  5. Los dos reúnen candidatos y envían cada uno en cuanto lo encuentran. Los navegadores prueban parejas de direcciones entre sí y se quedan con una que funcione, primero las directas.
  6. Fluyen el audio y el vídeo. ontrack se lanza en cada lado, y aparece la otra persona. Van cifrados por el camino, siempre: WebRTC lo exige (RFC 8827). Pide solo { audio: true } y el mismo código hace una llamada de voz, que llamadas de voz y salas de audio mide y explica.

Como las dos pestañas añaden su cámara más o menos en el mismo momento, puede que las dos ofrezcan. Esa es la colisión que resuelve el patrón: el lado educado descarta su propia oferta y responde a la otra, y el lado no educado ignora la oferta que se cruzó con la suya.

Sin el paso 2, la primera pestaña ofrecería mientras está sola, el servidor pasaría esa oferta a nadie y la llamada nunca empezaría. Una oferta que nadie oye es una razón frecuente por la que una primera demo de WebRTC muestra dos recuadros negros.

Lo que la demo deja fuera

La demo funciona entre dos pestañas en una misma red. Una app necesita más antes de que sus usuarios puedan contar con ella.

  • Quién puede llamar a quién. El servidor de arriba pasa cualquier mensaje a cualquiera. Uno real comprueba quién ha iniciado sesión, y si puede llamar a esa persona, antes de hacer sonar a nadie.
  • El timbre. La persona a la que se llama tiene que oírlo en la página en la que esté, en cada pestaña, y dejar de oírlo en todas en cuanto conteste en una. Eso necesita una conexión abierta para cada usuario, todo el tiempo que esté en el sitio (los websockets más allá de un servidor muestra lo que supone en cuanto tienes más de uno).
  • Los relés. Un servidor STUN encuentra direcciones públicas, y eso no basta detrás de muchos cortafuegos de oficina y redes móviles. Esas llamadas necesitan un servidor TURN, con credenciales que caducan, en puertos que esas redes dejan abiertos (los puertos que necesita una llamada).
  • Reconectar. Un teléfono que pasa de la Wi-Fi a los datos móviles pierde su camino. Vigila connectionState, y llama a pc.restartIce() cuando falle, para que los navegadores busquen una nueva pareja de direcciones sin colgar.
  • Más de dos personas. En este montaje, cada persona envía su vídeo a cada una de las demás. Eso aguanta con tres o cuatro, y luego las subidas no dan más de sí, y por eso las llamadas en grupo funcionan a través de servidores multimedia (cómo funcionan las videollamadas en grupo).
  • Los errores que ve la gente. Una cámara rechazada, un micrófono que falta, una llamada que nadie contesta. Por qué falla una conexión WebRTC repasa qué comprobar en los dos lados.

Cada una de estas cosas se puede construir sobre la misma API, y ese es el trabajo que hay detrás de la mayoría de los productos de videochat. La otra opción es dejar las conexiones, el timbre y los relés a un servicio, y quedarte en tu servidor con la única parte que de verdad es de tu app: quién puede llamar a quién. Cómo elegir una API de videollamadas enumera las preguntas que hacerle a una.

La misma llamada con WordPlus Cloud

Con el SDK de WordPlus Cloud, una página de JavaScript puro hace llamadas sin servidor de señalización, relé ni pantalla de llamada que escribir. Tu servidor declara quién puede llamar, como una regla para cada llamada cuyo nombre encaje con un patrón. Aquí, una llamada de soporte como support:34:42 es para las dos personas de su nombre:

JavaScript
// server.mjs, con realtime de createRealtime() de @wordplus/realtime/server
realtime.calls('support:{a}:{b}', async (user, withUser, { a, b }) => {
  const pair = [a, b];
  return pair.includes(String(user)) && pair.includes(String(withUser));
});

La página se conecta con los ajustes que tu servidor escribió en ella, inicia la pantalla de llamada y pone un botón allí desde donde la gente llama:

JavaScript
import { connect } from '@wordplus/realtime';

const rt = await connect(JSON.parse(document.getElementById('realtime').textContent));
await rt.callScreen(); // el timbre y la ventana de la llamada, en esta página
HTML
<call-button to="34" call="support:{pair}" type="video" name="Ann">Call Ann</call-button>

La llamada suena en cada pestaña y en cada dispositivo que Ann tenga abierto. Va directamente entre los dos navegadores cuando sus redes lo permiten, a través de nuestros relés en los puertos 443 y 80 cuando no, y a través de nuestros servidores multimedia cuando ni siquiera los relés llegan, pasando de uno a otro sin colgar. Las llamadas entre dos personas están cifradas de extremo a extremo sea cual sea el camino. Para una pantalla propia, rt.calls() te da las mismas llamadas sin piezas ya hechas, calls.start() para hacer una y un evento incoming para contestar.

Las llamadas en nuestra documentación muestran todas las formas de hacer una, desde un botón hasta tu propia interfaz, y la guía de videollamadas en Next.js las integra en una app completa.

Videollamadas para tu app

WordPlus Cloud for Apps tiene un precio según las conexiones simultáneas, a partir de 1.000, con facturación mensual o anual, y las llamadas entre dos personas no gastan créditos por ningún camino. Consulta las videollamadas y las llamadas en grupo para apps, o los precios para apps. ¿Preguntas sobre tu integración? Escríbenos.