KeypadWebRTC/simplesipsdk.js

"use strict";
//
// Na Documentação incluir os sites da simplesip.com.br no Content-Security-Policy
//
const UASimplesIP = (function () {
  function carregandoScriptSimpleSIP(url, callback) {
    var script = document.createElement("script");
    script.src = url;
    script.async = true; // Asynchronous loading
    script.onload = function () {
      if (typeof callback === "function") {
        callback();
      }
      // Clean up after script execution
      script.onload = script.onerror = null;
      document.head.removeChild(script);
    };
    script.onerror = function () {
      // Handle errors
      console.error("Error loading script:", url);
      if (typeof callback === "function") {
        callback(new Error("Error loading script"));
      }
      // Clean up after script execution
      script.onload = script.onerror = null;
      document.head.removeChild(script);
    };
    document.head.appendChild(script);
  }

  carregandoScriptSimpleSIP("simplesiplib.js", (error) => {
    if (!error) {
      console.log("::: Script loaded successfully!");
    } else {
      console.error(":::: Failed to load script:", error);
    }
  });

  class EventEmitter {
    constructor() {
      this.events = {};
    }

    on(eventName, listener) {
      if (!this.events[eventName]) {
        this.events[eventName] = [];
      }
      this.events[eventName].push(listener);
    }

    emit(eventName, ...args) {
      if (this.events[eventName]) {
        this.events[eventName].forEach((listener) => listener(...args));
      }
    }

    off(eventName, listener) {
      if (this.events[eventName]) {
        this.events[eventName] = this.events[eventName].filter(
          (fn) => fn !== listener
        );
      }
    }
  }

  const eventoSip = new EventEmitter();
  //const PROTOCOLO = "ws|wss"

  function passa(nome) {
    console.log(SimpleSIP.settings);
  }

  function Autenticacao(PROTOCOLO, SERVIDOR, PORTA, NOME, RAMAL, SENHA) {
    this.PROTOCOLO = PROTOCOLO;
    this.SERVIDOR = SERVIDOR;
    this.PORTA = PORTA;
    this.NOME = NOME;
    this.RAMAL = RAMAL;
    this.SENHA = SENHA;
  }

  const _Autenticacao = new Autenticacao();
  var localAudio = new window.Audio();
  localAudio.autoplay = true;

  const incomingCallAudio = new window.Audio(
    "https://cdn.pixabay.com/download/audio/2021/08/04/audio_bb630cc098.mp3?filename=short-success-sound-glockenspiel-treasure-video-game-6346.mp3"
  );
  incomingCallAudio.loop = true;
  var remoteAudio = new window.Audio();
  remoteAudio.autoplay = true;

  var phone;
  var session;
  var isIncomingCall = false; // Flag para controlar o estado de chamada recebida

  function iniciandoAutenticacaonoPBX() {
    const configuration = {
      uri: "sip:" + _Autenticacao.RAMAL + "@" + _Autenticacao.SERVIDOR,
      password: _Autenticacao.SENHA,
      sockets: new SimpleSIP.WebSocketInterface(
        _Autenticacao.PROTOCOLO +
          "://" +
          _Autenticacao.SERVIDOR +
          ":" +
          _Autenticacao.PORTA +
          "/ws"
      ),
      display_name:
        _Autenticacao.NOME !== null ? _Autenticacao.NOME : _Autenticacao.RAMAL,
      user_agent: "UASimpleSIP 1.2.0",
      pcConfig: {
        iceServers: [
          {
            urls: "stun:stun.l.google.com:19302",
          },
          {
            urls: "stun:stun1.l.google.com:19302",
          },
          {
            urls: "stun:stun2.l.google.com:19302",
          },
        ],
      },
    };
    if (configuration.uri && configuration.password) {
      phone = new SimpleSIP.UA(configuration);

      phone.on("registrationFailed", function (ev) {
        console.log("Registering on SIP server failed with error: " + ev.cause);
        configuration.uri = null;
        configuration.password = null;
      });

      phone.on("newRTCSession", function (ev) {
        const newSession = ev.session;

        session = newSession;

        eventoSip.on("endCall", () => {
          if (session && session.isEstablished()) {
            eventoSip.emit("confirmedEnded");
            console.log();
            session.terminate();
          }
        });
        // setInterval(() => {
        //   eventoSip.emit("evento", session.connection.iceConnectionState);
        // }, 2000);

        eventoSip.on("evento", (payload) => {
          console.log(payload);
        });
        eventoSip.on("mute", function () {
          session.mute();
        });

        eventoSip.on("unmute", function () {
          session.unmute();
        });

        session.on("candidate", (event) => {
          console.log(event);
        });

        phone.on("connectionstatechange", (event) => {
          console.log("EVENTO ESTADO DA CONEXAO: ", event);
        });

        session.on("failed", () => {});
        session.on("ended", () => {
          eventoSip.emit("confirmedEnded");
        });

        session.on("confirmed", function (confirmed) {
          // Verifica se session.connection está definido
          if (
            session.connection &&
            session.connection.getRemoteStreams().length > 0
          ) {
            const remoteStreams = session.connection.getRemoteStreams()[0];
            remoteAudio.srcObject = remoteStreams;
          }

          // Verifica se session.connection está definido e se existem streams locais
          if (
            session.connection &&
            session.connection.getLocalStreams().length > 0
          ) {
            const localStreams = session.connection.getLocalStreams()[0];
            localAudio.srcObject = localStreams;
          }

          eventoSip.emit("incall");
        });
        session.on("icecandidate", function (event) {
          if (
            event.candidate.type === "srflx" &&
            event.candidate.relatedAddress !== null &&
            event.candidate.relatedPort !== null
          ) {
            event.ready();
          }
        });

        session.on("addstream", function (e) {
          // Verifica se session.connection está definido
          if (session.connection) {
            remoteAudio.src = window.URL.createObjectURL(e.stream);
            remoteAudio.play();
          }
        });

        //RECEBENDO UMA CHAMADA
        if (session.direction === "incoming") {
          incomingCallAudio.play();
          isIncomingCall = true;
          eventoSip.emit("incomingcall", session.remote_identity.uri.user);

          eventoSip.on("rejected", () => {
            if (session && session.isInProgress()) {
              incomingCallAudio.pause();
              eventoSip.emit("home");
              session.terminate();
              session = null;
            } else {
              eventoSip.emit("home");
            }
          });

          eventoSip.on("accepted", () => {
            if (session && session.isInProgress()) {
              session.answer();
              incomingCallAudio.pause();
            }
          });
        }
        //REALIZANDO UMA CHAMADA
        if (session.direction === "outgoing") {
          eventoSip.emit("outgoingcall", session.remote_identity.uri.user);
        }
      });
      phone.on("registered", function (e) {
        eventoSip.emit("statusChange", "registered");
      });

      phone.on("unregistered", function (e) {
        eventoSip.emit("statusChange", "unregistered");
      });

      phone.on("registrationFailed", function (e) {
        eventoSip.emit("statusChange", "registrationFailed");
      });

      phone.on("connected", function (e) {
        eventoSip.emit("statusChange", "connected");
      });

      phone.on("disconnected", function (e) {
        eventoSip.emit("statusChange", "disconnected");
      });
      phone.start();
    }
  }

  function ativaDebug(value) {
    value === true
      ? SimpleSIP.debug.enable("SimpleSIP:*")
      : SimpleSIP.debug.disable("SimpleSIP:*");
  }

  return {
    config: _Autenticacao,

    start: function () {
      if (
        _Autenticacao.PROTOCOLO === undefined ||
        _Autenticacao.SERVIDOR === undefined ||
        _Autenticacao.RAMAL === undefined ||
        _Autenticacao.SENHA === undefined
      ) {
        console.error(
          ":::: Configuração do Usuário Inválida para Autenticação no PBX !"
        );
      } else {
        ativaDebug(true);
        iniciandoAutenticacaonoPBX();
      }
    },

    realizaUmaChamada: (numero) => {
      phone ? phone.call(numero) : eventoSip.emit("error");
    },

    ativaDebug: (value) => {
      ativaDebug(value);
    },

    unregister: () => {
      phone
        ? phone.unregister()
        : console.warn("Sem ramal cadastrado para apagar");
    },

    estouRegistradonoPBX: () => {
      console.log("estouRegistradonoPBX ::: " + phone.isRegistered());
    },

    simplesipEvento: eventoSip,

    help: function () {
      console.log("========================================================");
      console.log("=== Unified Communications - Simples Ip - Versão 1.2 ===");
      console.log("========================================================");
      console.log("UASimplesIP.start() - Para iniciar o SDK");
    },
  };
})();