Salt la conținutul principal
Română— Alege o limbă
Meniu

Integrarea în browser și bune practici

Lecția 14 din 14 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Implementarea TTS într-o aplicație web
  2. Suportul pentru codec-uri în browser
  3. Problema AudioContext în Safari
  4. URL-uri Blob și scurgeri de memorie
  5. Bune practici pentru producție
  6. Puncte cheie
  7. Verificați-vă cunoștințele

Actualizat la 3 noiembrie 2026, pe baza paginii xAI Text to Speech: validarea lato-server utilizează limita curentă de 60.000 de caractere per cerere. Sursă: Text to Speech.

Implementarea TTS într-o aplicație web

Integrarea TTS într-un browser prezintă provocări specifice: suportul pentru codec-uri, gestionarea memoriei, particularitățile Safari și performanța. Această ultimă lecție vă oferă tot ce aveți nevoie pentru o integrare robustă în producție.

Suportul pentru codec-uri în browser

Nu fiecare browser suportă fiecare format audio. Alegeți codec-ul potrivit pentru publicul dumneavoastră:

CodecChromeFirefoxSafariEdgeRecomandat
MP3DaDaDaDaDa
WAVDaDaDaDaDa
Raw PCMNuNuNuNuNu
mulaw/alawNuNuNuNuNu

Regula simplă: utilizați MP3 sau WAV în browser. PCM, mulaw și alaw sunt destinate aplicațiilor server și telefoniei, nu redării web.

// Solicitați MP3 de la API (prin backend-ul dumneavoastră)
const response = await fetch("/api/tts", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "Hello from the browser.",
    voice_id: "eve",
    language: "en"
    // Nu este nevoie să setați output_format: MP3 este implicit
  })
});

Problema AudioContext în Safari

Safari impune o restricție de securitate: un AudioContext poate fi creat doar în interiorul unui gestionar de evenimente declanșat de utilizator (clic, apăsare de tastă, atingere). Dacă încercați să creați un AudioContext la încărcarea paginii, Safari îl blochează în tăcere.

Abordarea greșită

// NU funcționează în Safari
const audioContext = new AudioContext(); // Blocat!

async function playTTS() {
  const audio = await fetchTTS("Hello");
  // audioContext este suspendat în Safari...
}

Abordarea corectă

let audioContext = null;

// Creați AudioContext la primul clic al utilizatorului
document.getElementById("play-btn").addEventListener("click", async () => {
  if (!audioContext) {
    audioContext = new AudioContext();
  }

  // Reluați dacă este suspendat
  if (audioContext.state === "suspended") {
    await audioContext.resume();
  }

  const response = await fetch("/api/tts", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      text: "Hello from Safari.",
      voice_id: "eve",
      language: "en"
    })
  });

  const arrayBuffer = await response.arrayBuffer();
  const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);

  const source = audioContext.createBufferSource();
  source.buffer = audioBuffer;
  source.connect(audioContext.destination);
  source.start(0);
});

Această abordare funcționează în fiecare browser, nu doar în Safari. Este o bună practică universală.

URL-uri Blob și scurgeri de memorie

Atunci când creați URL-uri Blob pentru a reda audio, fiecare URL utilizează memorie până când îl eliberați explicit. Fără curățare, aplicația dumneavoastră va avea scurgeri de memorie.

Problema

// Fiecare apel creează un URL Blob care nu este niciodată eliberat
async function playTTS(text) {
  const response = await fetch("/api/tts", { ... });
  const blob = await response.blob();
  const url = URL.createObjectURL(blob); // Scurgere de memorie!
  const audio = new Audio(url);
  audio.play();
}

Soluția

async function playTTS(text) {
  const response = await fetch("/api/tts", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text, voice_id: "eve", language: "en" })
  });

  const blob = await response.blob();
  const url = URL.createObjectURL(blob);
  const audio = new Audio(url);

  // Eliberați memoria când redarea se termină
  audio.addEventListener("ended", () => {
    URL.revokeObjectURL(url);
  });

  // Eliberați memoria și în caz de eroare
  audio.addEventListener("error", () => {
    URL.revokeObjectURL(url);
  });

  audio.play();
}

Pentru aplicațiile care generează mult audio, mențineți o listă a URL-urilor active și curățați-le periodic:

class AudioManager {
  constructor() {
    this.activeUrls = new Set();
  }

  async play(text) {
    const response = await fetch("/api/tts", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ text, voice_id: "eve", language: "en" })
    });

    const blob = await response.blob();
    const url = URL.createObjectURL(blob);
    this.activeUrls.add(url);

    const audio = new Audio(url);
    audio.addEventListener("ended", () => this.release(url));
    audio.addEventListener("error", () => this.release(url));
    audio.play();
    return audio;
  }

  release(url) {
    URL.revokeObjectURL(url);
    this.activeUrls.delete(url);
  }

  cleanup() {
    // Eliberează fiecare URL activ
    for (const url of this.activeUrls) {
      URL.revokeObjectURL(url);
    }
    this.activeUrls.clear();
  }
}

Bune practici pentru producție

Limitarea ratei la backend

Protejați-vă backend-ul de abuzuri prin limitarea cererilor per utilizator:

const rateLimit = require("express-rate-limit");

const ttsLimiter = rateLimit({
  windowMs: 60 * 1000, // 1 minut
  max: 10, // 10 cereri pe minut per IP
  message: { error: "Prea multe cereri TTS" }
});

app.post("/api/tts", ttsLimiter, async (req, res) => {
  // ... proxy către API-ul xAI
});

Validarea textului

Validați și curățați textul înainte de a-l trimite la API:

function validateTTSInput(text) {
  if (!text || typeof text !== "string") {
    throw new Error("Textul este obligatoriu");
  }
  if (text.length > 60000) {
    throw new Error("Text prea lung (maxim 60.000 de caractere)");
  }
  // Elimină caracterele de control
  return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
}

Cache-ul audio

Pentru texte repetitive (saluturi, instrucțiuni standard), stocați în cache audio-ul generat:

const audioCache = new Map();

async function getTTS(text, voice, language) {
  const cacheKey = `${text}:${voice}:${language}`;

  if (audioCache.has(cacheKey)) {
    return audioCache.get(cacheKey);
  }

  const audio = await fetchTTSFromAPI(text, voice, language);
  audioCache.set(cacheKey, audio);
  return audio;
}

Pre-generare

Pentru conținutul pe care îl cunoașteți în avans (e-learning, IVR), pre-generați fișierele audio la momentul build-ului, nu din mers.

Puncte cheie

  • Utilizați MP3 sau WAV în browser, niciodată PCM/mulaw/alaw
  • În Safari, creați AudioContext în interiorul unui gestionar de evenimente declanșat de utilizator
  • Eliberați întotdeauna URL-urile Blob cu URL.revokeObjectURL() după utilizare
  • Adăugați limitarea ratei la proxy-ul dumneavoastră de backend
  • Validați și curățați textul înainte de a-l trimite la API
  • Stocați în cache audio-ul pentru texte repetitive pentru a economisi apeluri API
  • Pre-generați audio pentru conținutul pe care îl cunoașteți în avans

Verificați-vă cunoștințele

Sinteza vocală xAI: de la primul apel la pipeline-ul de streaming.

1. Cum funcționează apelul TTS de bază?

Răspuns: Un POST către /v1/tts cu textul, vocea aleasă (pe care o puteți lista prin API) și parametrii. Răspunsul este audio-ul, facturat în funcție de volumul sintetizat.

2. Ce vă permit să faceți tag-urile expresive?

Răspuns: Să controlați vorbirea direct din text: tag-uri inline și de învelire pentru intonație, pauze și accentuare, pe care le puteți combina pentru lecturi naturale și direcționate.

3. Când ar trebui să treceți la TTS WebSocket?

Răspuns: Pentru timp real: textul pleacă sub formă de flux, iar audio-ul vine continuu. Este fundamentul pipeline-urilor LLM → TTS, unde vocea începe înainte ca generarea să se termine.

4. Cum securizați o integrare în browser?

Răspuns: Nu puneți niciodată cheia API în client: browserul trece prin serverul dumneavoastră sau folosește credențiale cu durată scurtă de viață, iar dumneavoastră gestionați corect erorile HTTP.

5. Cum arată pipeline-ul complet de producție?

Răspuns: Un LLM streaming → segmente de text → TTS WebSocket → redare audio. Fiecare verigă face streaming, astfel încât latența percepută se prăbușește, iar bunele practici din acest curs închid bucla.

Tag-uri pentru expresivitate, WebSocket pentru timp real, serverul dumneavoastră pentru secrete: aplicațiile dumneavoastră sunt gata să vorbească.