Ligações por Stream

curl -X POST https://api.d-api.cloud/api/v1/calls/stream \
  -H "Authorization: SUA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "sessionId": "minha-sessao", "phone": "5551999998888" }'

{
  "success": true,
  "sessionId": "minha-sessao",
  "callId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "wsUrl": "wss://api.d-api.cloud/voip/stream?callId=a1b2c3d4-...&token=...",
  "token": "..."
}

// backend do seu app — Node.js
app.post("/api/iniciar-chamada", async (req, res) => {
  const r = await fetch("https://api.d-api.cloud/api/v1/calls/stream", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: process.env.DAPI_API_KEY, // fica só no servidor
    },
    body: JSON.stringify({ sessionId: req.body.sessionId, phone: req.body.phone }),
  });
  const data = await r.json();
  res.json({ callId: data.callId, wsUrl: data.wsUrl }); // só isso vai ao navegador
});

const ws = new WebSocket(wsUrl);
ws.binaryType = "arraybuffer";

ws.onmessage = (e) => {
  if (typeof e.data === "string") {
    handleEvent(JSON.parse(e.data)); // evento do ciclo de vida (Passo 4)
  } else {
    playDownlink(e.data); // áudio binário do outro lado (Passo 3)
  }
};

// voip-worklet.js — converte Float32 (navegador) ⇄ Int16 (rede) e amortece jitter
const FRAME = 320;      // 20 ms @ 16 kHz
const PREBUFFER = 1600; // ~100 ms de buffer para o áudio recebido

class VoipIO extends AudioWorkletProcessor {
  constructor() {
    super();
    this.ring = new Float32Array(16000 * 2); // ~2 s de buffer de recepção
    this.wr = 0;
    this.rd = 0;
    this.filled = 0;
    this.primed = false;
    this.outAccum = new Float32Array(FRAME);
    this.outLen = 0;

    // Áudio recebido (Int16 -> Float32) entra no ring buffer.
    this.port.onmessage = (e) => {
      if (e.data?.kind !== "in") return;
      const i16 = new Int16Array(e.data.pcm);
      for (let i = 0; i < i16.length; i++) {
        this.ring[this.wr] = i16[i] / 32768;
        this.wr = (this.wr + 1) % this.ring.length;
        this.filled = Math.min(this.filled + 1, this.ring.length);
      }
    };
  }

  process(inputs, outputs) {
    // Uplink: microfone -> frames Int16 de 320 amostras.
    const mic = inputs[0]?.[0];
    if (mic) {
      for (let i = 0; i < mic.length; i++) {
        this.outAccum[this.outLen++] = mic[i];
        if (this.outLen === FRAME) {
          const i16 = new Int16Array(FRAME);
          for (let k = 0; k < FRAME; k++) {
            let v = this.outAccum[k];
            v = v > 1 ? 1 : v < -1 ? -1 : v;
            i16[k] = v * 32767;
          }
          this.port.postMessage({ kind: "out", pcm: i16.buffer }, [i16.buffer]);
          this.outLen = 0;
        }
      }
    }

    // Downlink: ring buffer -> alto-falante, com pré-buffer e silêncio se faltar.
    const out = outputs[0][0];
    if (!this.primed && this.filled >= PREBUFFER) this.primed = true;
    for (let i = 0; i < out.length; i++) {
      if (this.primed && this.filled > 0) {
        out[i] = this.ring[this.rd];
        this.rd = (this.rd + 1) % this.ring.length;
        this.filled--;
      } else {
        out[i] = 0;
        if (this.primed && this.filled === 0) this.primed = false; // re-buffer
      }
    }
    return true;
  }
}

registerProcessor("voip-io", VoipIO);

const ctx = new AudioContext({ sampleRate: 16000 });
await ctx.audioWorklet.addModule("/voip-worklet.js");

const mic = await navigator.mediaDevices.getUserMedia({
  audio: {
    channelCount: 1,
    echoCancellation: true,
    noiseSuppression: true,
    autoGainControl: true,
  },
});

const node = new AudioWorkletNode(ctx, "voip-io", {
  numberOfInputs: 1,
  numberOfOutputs: 1,
  outputChannelCount: [1],
});
ctx.createMediaStreamSource(mic).connect(node);
node.connect(ctx.destination); // voz do outro lado -> alto-falante

let canSendUplink = false; // liberado só quando o outro lado atende (Passo 4)

// Uplink: frames do worklet -> WebSocket
node.port.onmessage = (ev) => {
  if (ev.data?.kind === "out" && canSendUplink && ws.readyState === WebSocket.OPEN) {
    ws.send(ev.data.pcm);
  }
};

// Downlink: áudio binário do WebSocket -> worklet
function playDownlink(buffer) {
  node.port.postMessage({ kind: "in", pcm: buffer }, [buffer]);
}

function handleEvent(msg) {
  switch (msg.type) {
    case "calling":
    case "ringing":
      setStatus("tocando");
      break;
    case "accepted":
    case "connected":
      canSendUplink = true; // agora pode enviar o microfone
      setStatus("conectado");
      break;
    case "recording":
      saveRecording(msg.url, msg.files);
      break;
    case "ended":
      setStatus(`encerrada: ${msg.reason}`);
      cleanup();
      break;
    case "error":
      setStatus(`erro: ${msg.msg || msg.code}`);
      cleanup();
      break;
  }
}

{
  "type": "recording",
  "files": { "full": "https://...", "sender": "https://...", "recipient": "https://..." },
  "url": "https://..."
}

async function iniciarChamada({ sessionId, phone }) {
  // 1. Inicie pelo seu backend — a API Key não vai ao navegador.
  const { wsUrl } = await fetch("/api/iniciar-chamada", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ sessionId, phone }),
  }).then((r) => r.json());

  // 2. Áudio.
  const ctx = new AudioContext({ sampleRate: 16000 });
  await ctx.audioWorklet.addModule("/voip-worklet.js");
  const mic = await navigator.mediaDevices.getUserMedia({
    audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true, autoGainControl: true },
  });
  const node = new AudioWorkletNode(ctx, "voip-io", {
    numberOfInputs: 1, numberOfOutputs: 1, outputChannelCount: [1],
  });
  ctx.createMediaStreamSource(mic).connect(node);
  node.connect(ctx.destination);

  // 3. WebSocket.
  let canSendUplink = false;
  const ws = new WebSocket(wsUrl);
  ws.binaryType = "arraybuffer";

  node.port.onmessage = (ev) => {
    if (ev.data?.kind === "out" && canSendUplink && ws.readyState === WebSocket.OPEN) {
      ws.send(ev.data.pcm);
    }
  };

  ws.onmessage = (e) => {
    if (typeof e.data !== "string") {
      node.port.postMessage({ kind: "in", pcm: e.data }, [e.data]);
      return;
    }
    const msg = JSON.parse(e.data);
    if (msg.type === "accepted" || msg.type === "connected") canSendUplink = true;
    if (msg.type === "ended" || msg.type === "error") cleanup();
    console.log("evento", msg);
  };
  ws.onclose = () => cleanup();

  function cleanup() {
    mic.getTracks().forEach((t) => t.stop());
    if (ctx.state !== "closed") ctx.close();
  }

  return {
    mutar: (m) => mic.getAudioTracks().forEach((t) => (t.enabled = !m)),
    desligar: () => ws.close(),
  };
}