ringcentral-softphone 1.3.2 → 1.3.4

package/dist/cjs/call-session/index.js

@@ -1,239 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_dgram_1 = __importDefault(require("node:dgram"));
-const node_events_1 = __importDefault(require("node:events"));
-const node_buffer_1 = require("node:buffer");
-const werift_rtp_1 = require("werift-rtp");
-const dtmf_js_1 = __importDefault(require("../dtmf.js"));
-const index_js_1 = require("../sip-message/index.js");
-const utils_js_1 = require("../utils.js");
-const streamer_js_1 = __importDefault(require("./streamer.js"));
-const wait_for_async_1 = __importDefault(require("wait-for-async"));
-class CallSession extends node_events_1.default {
-    softphone;
-    sipMessage;
-    socket;
-    localPeer;
-    remotePeer;
-    remoteIP;
-    remotePort;
-    disposed = false;
-    srtpSession;
-    encoder;
-    decoder;
-    sdp;
-    // for audio streaming
-    ssrc = (0, utils_js_1.randomInt)();
-    sequenceNumber = (0, utils_js_1.randomInt)();
-    timestamp = (0, utils_js_1.randomInt)();
-    constructor(softphone, sipMessage) {
-        super();
-        this.softphone = softphone;
-        this.encoder = softphone.codec.createEncoder();
-        this.decoder = softphone.codec.createDecoder();
-        this.sipMessage = sipMessage;
-        // inbound call from call queue, invite message may not have body
-        if (this.sipMessage.body.length > 0) {
-            this.remoteIP = this.sipMessage.body.match(/c=IN IP4 ([\d.]+)/)[1];
-            this.remotePort = parseInt(this.sipMessage.body.match(/m=audio (\d+) /)[1], 10);
-        }
-    }
-    set remoteKey(key) {
-        const localKeyBuffer = node_buffer_1.Buffer.from(utils_js_1.localKey, "base64");
-        const remoteKeyBuffer = node_buffer_1.Buffer.from(key, "base64");
-        this.srtpSession = new werift_rtp_1.SrtpSession({
-            profile: 0x0001,
-            keys: {
-                localMasterKey: localKeyBuffer.subarray(0, 16),
-                localMasterSalt: localKeyBuffer.subarray(16, 30),
-                remoteMasterKey: remoteKeyBuffer.subarray(0, 16),
-                remoteMasterSalt: remoteKeyBuffer.subarray(16, 30),
-            },
-        });
-    }
-    get callId() {
-        return this.sipMessage.getHeader("Call-ID");
-    }
-    send(data) {
-        this.socket.send(data, this.remotePort, this.remoteIP);
-    }
-    async hangup() {
-        const requestMessage = new index_js_1.RequestMessage(`BYE sip:${this.softphone.sipInfo.domain} SIP/2.0`, {
-            "Call-ID": this.callId,
-            From: this.localPeer,
-            To: this.remotePeer,
-            Via: `SIP/2.0/TLS ${this.softphone.fakeDomain};branch=${(0, utils_js_1.branch)()}`,
-        });
-        await this.softphone.send(requestMessage);
-    }
-    sendDTMF(char) {
-        const payloads = dtmf_js_1.default.charToPayloads(char);
-        const timestamp = this.timestamp;
-        let first = true;
-        for (const payload of payloads) {
-            const rtpHeader = new werift_rtp_1.RtpHeader({
-                version: 2,
-                padding: false,
-                paddingSize: 0,
-                extension: false,
-                marker: first,
-                payloadOffset: 12,
-                payloadType: 101,
-                sequenceNumber: this.sequenceNumber,
-                timestamp,
-                ssrc: this.ssrc,
-                csrcLength: 0,
-                csrc: [],
-                extensionProfile: 48862,
-                extensionLength: undefined,
-                extensions: [],
-            });
-            const rtpPacket = new werift_rtp_1.RtpPacket(rtpHeader, payload);
-            this.send(this.srtpSession.encrypt(rtpPacket.payload, rtpPacket.header));
-            this.sequenceNumber = (this.sequenceNumber + 1) % 65536;
-            first = false;
-        }
-        this.timestamp += 800;
-    }
-    async sendDTMFs(s, delay = 500) {
-        for (const c of s) {
-            this.sendDTMF(c);
-            await (0, wait_for_async_1.default)({ interval: delay });
-        }
-    }
-    // buffer is the content of a audio file, it is supposed to be uncompressed PCM data
-    // The audio should be playable by command: play -t raw -b 16 -r 16000 -e signed-integer test.wav
-    streamAudio(input) {
-        const streamer = new streamer_js_1.default(this, input);
-        streamer.start();
-        return streamer;
-    }
-    // send a single rtp packet
-    sendPacket(rtpPacket) {
-        if (this.disposed) {
-            return;
-        }
-        this.send(this.srtpSession.encrypt(rtpPacket.payload, rtpPacket.header));
-    }
-    startLocalServices() {
-        this.socket = node_dgram_1.default.createSocket("udp4");
-        this.socket.on("message", (message) => {
-            const rtpPacket = werift_rtp_1.RtpPacket.deSerialize(this.srtpSession.decrypt(message));
-            this.emit("rtpPacket", rtpPacket);
-            if (rtpPacket.header.payloadType === 101) {
-                this.emit("dtmfPacket", rtpPacket);
-                const char = dtmf_js_1.default.payloadToChar(rtpPacket.payload);
-                if (char) {
-                    this.emit("dtmf", char);
-                }
-            }
-            else if (rtpPacket.header.payloadType === this.softphone.codec.id) {
-                if (rtpPacket.payload.length === 4 &&
-                    rtpPacket.payload[0] >= 0x00 &&
-                    rtpPacket.payload[0] < 0x0c &&
-                    rtpPacket.payload[1] === 0x8a &&
-                    rtpPacket.payload[2] === 0x03 &&
-                    rtpPacket.payload[3] === 0xc0) {
-                    // special DTMF packet in audio format
-                    // first byte 0x00 to 0x0c means DTMF 0 to 9, *, #
-                    // we ignore it since DTMF is handled by `if (rtpPacket.header.payloadType === 101) {`
-                    return; // ignore it
-                }
-                try {
-                    rtpPacket.payload = this.decoder.decode(rtpPacket.payload);
-                    this.emit("audioPacket", rtpPacket);
-                }
-                catch {
-                    console.error("Audio packet decode failed", rtpPacket);
-                }
-            }
-        });
-        // as I tested, we can use a random port here and it still works
-        // but it seems that in SDP we need to tell remote our local IP Address, not 127.0.0.1
-        this.socket.bind(); // random port
-        // send a message to remote server so that it knows where to reply
-        this.send("hello");
-        const byeHandler = (inboundMessage) => {
-            if (inboundMessage.getHeader("Call-ID") !== this.callId) {
-                return;
-            }
-            if (inboundMessage.headers.CSeq.endsWith(" BYE")) {
-                this.softphone.off("message", byeHandler);
-                this.dispose();
-            }
-        };
-        this.softphone.on("message", byeHandler);
-    }
-    dispose() {
-        this.disposed = true;
-        this.emit("disposed");
-        this.removeAllListeners();
-        this.socket?.removeAllListeners();
-        this.socket?.close();
-    }
-    async transfer(transferTo) {
-        const requestMessage = new index_js_1.RequestMessage(`REFER sip:${this.softphone.sipInfo.username}@${this.softphone.sipInfo.outboundProxy};transport=tls SIP/2.0`, {
-            Via: `SIP/2.0/TLS ${this.softphone.client.localAddress}:${this.softphone.client.localPort};rport;branch=${(0, utils_js_1.branch)()};alias`,
-            "Max-Forwards": 70,
-            From: this.localPeer,
-            To: this.remotePeer,
-            Contact: `<sip:${this.softphone.sipInfo.username}@${this.softphone.client.localAddress}:${this.softphone.client.localPort};transport=TLS;ob>`,
-            "Call-ID": this.callId,
-            Event: "refer",
-            Expires: 600,
-            Supported: "replaces, 100rel, timer, norefersub",
-            Accept: "message/sipfrag;version=2.0",
-            "Allow-Events": "presence, message-summary, refer",
-            "Refer-To": `sip:${transferTo}@${this.softphone.sipInfo.domain}`,
-            "Referred-By": `<sip:${this.softphone.sipInfo.username}@${this.softphone.sipInfo.domain}>`,
-        });
-        await this.softphone.send(requestMessage);
-        return new Promise((resolve) => {
-            const notifyHandler = (inboundMessage) => {
-                if (!inboundMessage.subject.startsWith("NOTIFY ")) {
-                    return;
-                }
-                const responseMessage = new index_js_1.ResponseMessage(inboundMessage, 200);
-                this.softphone.send(responseMessage);
-                if (inboundMessage.body.trim() === "SIP/2.0 200 OK") {
-                    this.softphone.off("message", notifyHandler);
-                    resolve();
-                }
-            };
-            this.softphone.on("message", notifyHandler);
-        });
-    }
-    async toggleReceive(toReceive) {
-        let newSDP = this.sdp;
-        if (!toReceive) {
-            newSDP = newSDP.replace(/a=sendrecv/, "a=sendonly");
-        }
-        const requestMessage = new index_js_1.RequestMessage(`INVITE ${(0, utils_js_1.extractAddress)(this.remotePeer)} SIP/2.0`, {
-            "Call-Id": this.callId,
-            From: this.localPeer,
-            To: this.remotePeer,
-            Via: `SIP/2.0/TLS ${this.softphone.client.localAddress}:${this.softphone.client.localPort};rport;branch=${(0, utils_js_1.branch)()};alias`,
-            "Content-Type": "application/sdp",
-            Contact: ` <sip:${this.softphone.sipInfo.username}@${this.softphone.client.localAddress}:${this.softphone.client.localPort};transport=TLS;ob>`,
-        }, newSDP);
-        const replyMessage = await this.softphone.send(requestMessage, true);
-        const ackMessage = new index_js_1.RequestMessage(`ACK ${(0, utils_js_1.extractAddress)(this.remotePeer)} SIP/2.0`, {
-            "Call-Id": this.callId,
-            From: this.localPeer,
-            To: this.remotePeer,
-            Via: replyMessage.headers.Via,
-            CSeq: replyMessage.headers.CSeq.replace(" INVITE", " ACK"),
-        });
-        await this.softphone.send(ackMessage);
-    }
-    async hold() {
-        return this.toggleReceive(false);
-    }
-    async unhold() {
-        return this.toggleReceive(true);
-    }
-}
-exports.default = CallSession;

package/dist/cjs/call-session/outbound.js

@@ -1,66 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = __importDefault(require("./index.js"));
-const index_js_2 = require("../sip-message/index.js");
-const utils_js_1 = require("../utils.js");
-class OutboundCallSession extends index_js_1.default {
-    constructor(softphone, answerMessage) {
-        super(softphone, answerMessage);
-        this.localPeer = answerMessage.headers.From;
-        this.remotePeer = answerMessage.headers.To;
-        this.remoteKey = answerMessage.body.match(/AES_CM_128_HMAC_SHA1_80 inline:([\w+/]+)/)[1];
-        this.init();
-    }
-    init() {
-        // wait for user to answer the call
-        const answerHandler = (message) => {
-            if (message.headers.CSeq !== this.sipMessage.headers.CSeq) {
-                return;
-            }
-            if (message.subject.startsWith("SIP/2.0 486")) {
-                this.softphone.off("message", answerHandler);
-                this.emit("busy");
-                this.dispose();
-                return;
-            }
-            if (message.subject.startsWith("SIP/2.0 200")) {
-                this.softphone.off("message", answerHandler);
-                this.emit("answered");
-                const ackMessage = new index_js_2.RequestMessage(`ACK ${(0, utils_js_1.extractAddress)(this.remotePeer)} SIP/2.0`, {
-                    "Call-ID": this.callId,
-                    From: this.localPeer,
-                    To: this.remotePeer,
-                    Via: this.sipMessage.headers.Via,
-                    CSeq: this.sipMessage.headers.CSeq.replace(" INVITE", " ACK"),
-                });
-                this.softphone.send(ackMessage);
-            }
-        };
-        this.softphone.on("message", answerHandler);
-        this.once("answered", () => this.startLocalServices());
-    }
-    async cancel() {
-        const requestMessage = new index_js_2.RequestMessage(`CANCEL ${(0, utils_js_1.extractAddress)(this.remotePeer)} SIP/2.0`, {
-            "Call-ID": this.callId,
-            From: this.localPeer,
-            To: (0, utils_js_1.withoutTag)(this.remotePeer),
-            Via: this.sipMessage.headers.Via,
-            CSeq: this.sipMessage.headers.CSeq.replace(" INVITE", " CANCEL"),
-        });
-        await this.softphone.send(requestMessage);
-    }
-    get sessionId() {
-        const header = this.sipMessage.headers["p-rc-api-ids"];
-        let match = header.match(/party-id=([^;]+);session-id=([^;]+)/);
-        return match[2];
-    }
-    get partyId() {
-        const header = this.sipMessage.headers["p-rc-api-ids"];
-        let match = header.match(/party-id=([^;]+);session-id=([^;]+)/);
-        return match[1];
-    }
-}
-exports.default = OutboundCallSession;

package/dist/cjs/call-session/streamer.d.ts

@@ -1,17 +0,0 @@
-import EventEmitter from "node:events";
-import { Buffer } from "node:buffer";
-import type CallSession from "./index.js";
-declare class Streamer extends EventEmitter {
-    paused: boolean;
-    private callSession;
-    private buffer;
-    private originalBuffer;
-    constructor(callSesstion: CallSession, buffer: Buffer);
-    start(): void;
-    stop(): void;
-    pause(): void;
-    resume(): void;
-    get finished(): boolean;
-    private sendPacket;
-}
-export default Streamer;

package/dist/cjs/call-session/streamer.js

@@ -1,76 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_events_1 = __importDefault(require("node:events"));
-const node_buffer_1 = require("node:buffer");
-const werift_rtp_1 = require("werift-rtp");
-class Streamer extends node_events_1.default {
-    paused = false;
-    callSession;
-    buffer;
-    originalBuffer;
-    constructor(callSesstion, buffer) {
-        super();
-        this.callSession = callSesstion;
-        this.buffer = buffer;
-        this.originalBuffer = buffer;
-    }
-    start() {
-        this.buffer = this.originalBuffer;
-        this.paused = false;
-        this.sendPacket();
-    }
-    stop() {
-        this.buffer = node_buffer_1.Buffer.alloc(0);
-    }
-    pause() {
-        this.paused = true;
-    }
-    resume() {
-        this.paused = false;
-        this.sendPacket();
-    }
-    get finished() {
-        return this.callSession.disposed ||
-            this.buffer.length < this.callSession.softphone.codec.packetSize;
-    }
-    sendPacket() {
-        if (!this.paused && !this.finished) {
-            const temp = this.callSession.encoder.encode(this.buffer.subarray(0, this.callSession.softphone.codec.packetSize));
-            const rtpPacket = new werift_rtp_1.RtpPacket(new werift_rtp_1.RtpHeader({
-                version: 2,
-                padding: false,
-                paddingSize: 0,
-                extension: false,
-                marker: false,
-                payloadOffset: 12,
-                payloadType: this.callSession.softphone.codec.id,
-                sequenceNumber: this.callSession.sequenceNumber,
-                timestamp: this.callSession.timestamp,
-                ssrc: this.callSession.ssrc,
-                csrcLength: 0,
-                csrc: [],
-                extensionProfile: 48862,
-                extensionLength: undefined,
-                extensions: [],
-            }), temp);
-            this.callSession.send(this.callSession.srtpSession.encrypt(rtpPacket.payload, rtpPacket.header));
-            this.callSession.sequenceNumber += 1;
-            if (this.callSession.sequenceNumber > 65535) {
-                this.callSession.sequenceNumber = 0;
-            }
-            this.callSession.timestamp +=
-                this.callSession.softphone.codec.timestampInterval;
-            this.buffer = this.buffer.subarray(this.callSession.softphone.codec.packetSize);
-            if (this.finished) {
-                this.emit("finished");
-            }
-            else {
-                setTimeout(() => this.sendPacket(), 20);
-            }
-        }
-    }
-}
-exports.default = Streamer;

package/dist/cjs/codec.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_buffer_1 = require("node:buffer");
-const opus_1 = require("@evan/opus");
-class Codec {
-    id;
-    name;
-    packetSize;
-    timestampInterval;
-    createEncoder;
-    createDecoder;
-    constructor(name) {
-        this.name = name;
-        switch (name) {
-            case "OPUS/16000": {
-                this.createEncoder = () => {
-                    const encoder = new opus_1.Encoder({ channels: 1, sample_rate: 16000 });
-                    return { encode: (pcm) => node_buffer_1.Buffer.from(encoder.encode(pcm)) };
-                };
-                this.createDecoder = () => {
-                    const decoder = new opus_1.Decoder({ channels: 1, sample_rate: 16000 });
-                    return {
-                        decode: (opus) => node_buffer_1.Buffer.from(decoder.decode(opus)),
-                    };
-                };
-                this.id = 109;
-                this.packetSize = 640;
-                this.timestampInterval = 320;
-                break;
-            }
-            case "OPUS/48000/2": {
-                this.createEncoder = () => {
-                    const encoder = new opus_1.Encoder({ channels: 2, sample_rate: 48000 });
-                    return { encode: (pcm) => node_buffer_1.Buffer.from(encoder.encode(pcm)) };
-                };
-                this.createDecoder = () => {
-                    const decoder = new opus_1.Decoder({ channels: 2, sample_rate: 48000 });
-                    return {
-                        decode: (opus) => node_buffer_1.Buffer.from(decoder.decode(opus)),
-                    };
-                };
-                this.id = 111;
-                this.packetSize = 3840;
-                this.timestampInterval = 960;
-                break;
-            }
-            case "PCMU/8000": {
-                this.createEncoder = () => {
-                    return { encode: (pcm) => pcm };
-                };
-                this.createDecoder = () => {
-                    return { decode: (audio) => audio };
-                };
-                this.id = 0;
-                this.packetSize = 160;
-                this.timestampInterval = 160;
-                break;
-            }
-            default: {
-                throw new Error(`unsupported codec: ${name}`);
-            }
-        }
-    }
-}
-exports.default = Codec;

package/dist/cjs/dtmf.d.ts

@@ -1,8 +0,0 @@
-import { Buffer } from "node:buffer";
-declare class DTMF {
-    static readonly phoneChars: string[];
-    private static readonly payloads;
-    static charToPayloads: (char: string) => Buffer<ArrayBuffer>[];
-    static payloadToChar: (payload: Buffer) => string;
-}
-export default DTMF;

package/dist/cjs/dtmf.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_buffer_1 = require("node:buffer");
-class DTMF {
-    static phoneChars = [
-        "0",
-        "1",
-        "2",
-        "3",
-        "4",
-        "5",
-        "6",
-        "7",
-        "8",
-        "9",
-        "*",
-        "#",
-    ];
-    static payloads = [
-        0x00060000,
-        0x000600a0,
-        0x00060140,
-        0x00860320,
-        0x00860320,
-        0x00860320,
-    ];
-    static charToPayloads = (char) => {
-        const index = DTMF.phoneChars.indexOf(char[0]);
-        if (index === -1) {
-            throw new Error("invalid phone char");
-        }
-        return DTMF.payloads.map((payload) => {
-            const temp = payload + index * 0x01000000;
-            const buffer = node_buffer_1.Buffer.alloc(4);
-            buffer.writeIntBE(temp, 0, 4);
-            return buffer;
-        });
-    };
-    static payloadToChar = (payload) => {
-        const intBE = payload.readIntBE(0, 4);
-        const index = (intBE - 0x00060000) / 0x01000000;
-        return DTMF.phoneChars[index];
-    };
-}
-exports.default = DTMF;