RTCSctpTransport.maxMessageSize — Eigenschaft · JavaScript-Referenz

Signatur

RTCSctpTransport.maxMessageSize

Beschreibung

Die schreibgeschützte Eigenschaft maxMessageSize des RTCSctpTransport-Interfaces gibt an, wie groß eine einzelne Nachricht höchstens sein darf, die mit RTCDataChannel.send() über die SCTP-Verbindung einer RTCPeerConnection gesendet wird. Der Wert ist eine Zahl in Bytes und ergibt sich aus der Aushandlung zwischen beiden Peers. Dabei zählt das Attribut a=max-message-size im SDP-Angebot bzw. in der SDP-Antwort und außerdem die Grenze, die die eigene Implementierung setzt.

Wichtig ist die Eigenschaft vor allem bei Dateiübertragungen und großen JSON-Nutzdaten über Datenkanäle. Ist eine Nachricht größer als maxMessageSize, wirft send() einen TypeError. Größere Daten muss man deshalb vorher in Stücke (Chunks) zerlegen, die höchstens so groß sind wie dieser Wert.

Man erreicht das Objekt über peerConnection.sctp. Diese Eigenschaft ist null, solange noch kein SCTP-Transport ausgehandelt wurde. Verlässlich ist der Wert erst, nachdem die Remote-Beschreibung gesetzt wurde. In der Praxis liest man ihn deshalb im open-Ereignis eines Datenkanals aus.

Ein Wert von Infinity bedeutet, dass beide Seiten keine Grenze angegeben haben. Das ist allerdings selten.

Rückgabewert

Typ

number

Beschreibung

Die maximale Nachrichtengröße in Bytes (unrestricted double). Kann Infinity sein, wenn keine Begrenzung ausgehandelt wurde.

Beispiele

Maximale Nachrichtengröße nach dem Öffnen des Kanals auslesen

const pc = new RTCPeerConnection();
const channel = pc.createDataChannel('chat');

channel.addEventListener('open', () => {
  // pc.sctp ist erst nach der Aushandlung verfügbar
  const max = pc.sctp?.maxMessageSize ?? 16 * 1024;
  console.log(`Maximale Nachrichtengröße: ${max} Bytes`);
});

// ... Signalisierung (createOffer, setLocalDescription, setRemoteDescription) ...

Maximale Nachrichtengröße: 262144 Bytes

Datei in passende Stücke zerlegt senden

const sendFile = async (pc, channel, file) => {
  // Sicherheitsobergrenze: nicht mehr als 64 KiB pro Chunk, auch wenn mehr erlaubt ist
  const limit = pc.sctp?.maxMessageSize ?? 16 * 1024;
  const chunkSize = Math.min(limit, 64 * 1024);
  const buffer = await file.arrayBuffer();

  channel.bufferedAmountLowThreshold = chunkSize * 4;

  for (let offset = 0; offset < buffer.byteLength; offset += chunkSize) {
    // Puffer nicht überlaufen lassen
    if (channel.bufferedAmount > chunkSize * 16) {
      await new Promise((resolve) =>
        channel.addEventListener('bufferedamountlow', resolve, { once: true })
      );
    }
    channel.send(buffer.slice(offset, offset + chunkSize));
  }
  channel.send(JSON.stringify({ type: 'eof', name: file.name }));
  console.log(`Gesendet in Stücken zu ${chunkSize} Bytes`);
};

Gesendet in Stücken zu 65536 Bytes

Nachrichtengröße vor dem Senden prüfen

const safeSend = (pc, channel, payload) => {
  const data = typeof payload === 'string' ? payload : JSON.stringify(payload);
  const size = new TextEncoder().encode(data).byteLength;
  const max = pc.sctp?.maxMessageSize ?? 16 * 1024;

  if (size > max) {
    console.warn(`Nachricht zu groß: ${size} > ${max} Bytes`);
    return false;
  }
  channel.send(data);
  return true;
};

Nachricht zu groß: 300000 > 262144 Bytes

// Wichtig · Fallstricke

pc.sctp kann null sein: Vor der SDP-Aushandlung oder wenn kein Datenkanal ausgehandelt wurde, gibt es kein RTCSctpTransport. Deshalb immer mit optionaler Verkettung (?.) und einem Ersatzwert (z. B. 16 KiB) arbeiten.
TypeError bei Überschreitung: Ist eine Nachricht größer als maxMessageSize, wirft send() einen TypeError. Bei Zeichenketten zählt die Größe in UTF-8-Bytes, nicht die Anzahl der Zeichen. Mit TextEncoder lässt sich die tatsächliche Größe messen.
Browserübergreifend: Ältere Browser konnten sehr große Nachrichten nicht zuverlässig mit anderen Browsern austauschen. Auch wenn der Wert größer ist, sind Stücke von 16–64 KiB in der Praxis am robustesten.
Performance: Sehr große Einzelnachrichten verstopfen die SCTP-Verbindung (Head-of-Line-Blocking). Deshalb Datenfluss über bufferedAmount und das Ereignis bufferedamountlow steuern.
Kompatibilität: RTCSctpTransport wird in Chrome/Edge 76+, Firefox 60+ und Safari 15.4+ unterstützt. Ältere Browser haben kein pc.sctp.

Siehe auch

RTCSctpTransport RTCSctpTransport.maxChannels RTCPeerConnection.sctp RTCDataChannel.send() RTCDataChannel.bufferedAmount MediaTrackSupportedConstraints.sampleSize