ringcentral-softphone 1.3.2 → 1.3.4

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

@@ -1,234 +0,0 @@
-import dgram from "node:dgram";
-import EventEmitter from "node:events";
-import { Buffer } from "node:buffer";
-import { RtpHeader, RtpPacket, SrtpSession } from "werift-rtp";
-import DTMF from "../dtmf.js";
-import { RequestMessage, ResponseMessage, } from "../sip-message/index.js";
-import { branch, extractAddress, localKey, randomInt } from "../utils.js";
-import Streamer from "./streamer.js";
-import waitFor from "wait-for-async";
-class CallSession extends EventEmitter {
-    softphone;
-    sipMessage;
-    socket;
-    localPeer;
-    remotePeer;
-    remoteIP;
-    remotePort;
-    disposed = false;
-    srtpSession;
-    encoder;
-    decoder;
-    sdp;
-    // for audio streaming
-    ssrc = randomInt();
-    sequenceNumber = randomInt();
-    timestamp = 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 = Buffer.from(localKey, "base64");
-        const remoteKeyBuffer = Buffer.from(key, "base64");
-        this.srtpSession = new 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 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=${branch()}`,
-        });
-        await this.softphone.send(requestMessage);
-    }
-    sendDTMF(char) {
-        const payloads = DTMF.charToPayloads(char);
-        const timestamp = this.timestamp;
-        let first = true;
-        for (const payload of payloads) {
-            const rtpHeader = new 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 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 waitFor({ 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(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 = dgram.createSocket("udp4");
-        this.socket.on("message", (message) => {
-            const rtpPacket = RtpPacket.deSerialize(this.srtpSession.decrypt(message));
-            this.emit("rtpPacket", rtpPacket);
-            if (rtpPacket.header.payloadType === 101) {
-                this.emit("dtmfPacket", rtpPacket);
-                const char = DTMF.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 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=${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 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 RequestMessage(`INVITE ${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=${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 RequestMessage(`ACK ${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);
-    }
-}
-export default CallSession;

package/dist/esm/call-session/outbound.d.ts

@@ -1,11 +0,0 @@
-import CallSession from "./index.js";
-import { type InboundMessage } from "../sip-message/index.js";
-import type Softphone from "../index.js";
-declare class OutboundCallSession extends CallSession {
-    constructor(softphone: Softphone, answerMessage: InboundMessage);
-    init(): void;
-    cancel(): Promise<void>;
-    get sessionId(): string;
-    get partyId(): string;
-}
-export default OutboundCallSession;

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

@@ -1,61 +0,0 @@
-import CallSession from "./index.js";
-import { RequestMessage } from "../sip-message/index.js";
-import { extractAddress, withoutTag } from "../utils.js";
-class OutboundCallSession extends CallSession {
-    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 RequestMessage(`ACK ${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 RequestMessage(`CANCEL ${extractAddress(this.remotePeer)} SIP/2.0`, {
-            "Call-ID": this.callId,
-            From: this.localPeer,
-            To: 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];
-    }
-}
-export default OutboundCallSession;

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

@@ -1,71 +0,0 @@
-import EventEmitter from "node:events";
-import { Buffer } from "node:buffer";
-import { RtpHeader, RtpPacket } from "werift-rtp";
-class Streamer extends EventEmitter {
-    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 = 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 RtpPacket(new 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);
-            }
-        }
-    }
-}
-export default Streamer;

package/dist/esm/codec.d.ts

@@ -1,15 +0,0 @@
-import { Buffer } from "node:buffer";
-declare class Codec {
-    id: number;
-    name: "OPUS/16000" | "OPUS/48000/2" | "PCMU/8000";
-    packetSize: number;
-    timestampInterval: number;
-    createEncoder: () => {
-        encode: (pcm: Buffer) => Buffer;
-    };
-    createDecoder: () => {
-        decode: (audio: Buffer) => Buffer;
-    };
-    constructor(name: "OPUS/16000" | "OPUS/48000/2" | "PCMU/8000");
-}
-export default Codec;

package/dist/esm/codec.js

@@ -1,63 +0,0 @@
-import { Buffer } from "node:buffer";
-import { Decoder, Encoder } from "@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 Encoder({ channels: 1, sample_rate: 16000 });
-                    return { encode: (pcm) => Buffer.from(encoder.encode(pcm)) };
-                };
-                this.createDecoder = () => {
-                    const decoder = new Decoder({ channels: 1, sample_rate: 16000 });
-                    return {
-                        decode: (opus) => Buffer.from(decoder.decode(opus)),
-                    };
-                };
-                this.id = 109;
-                this.packetSize = 640;
-                this.timestampInterval = 320;
-                break;
-            }
-            case "OPUS/48000/2": {
-                this.createEncoder = () => {
-                    const encoder = new Encoder({ channels: 2, sample_rate: 48000 });
-                    return { encode: (pcm) => Buffer.from(encoder.encode(pcm)) };
-                };
-                this.createDecoder = () => {
-                    const decoder = new Decoder({ channels: 2, sample_rate: 48000 });
-                    return {
-                        decode: (opus) => 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}`);
-            }
-        }
-    }
-}
-export default Codec;

package/dist/esm/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/esm/dtmf.js

@@ -1,43 +0,0 @@
-import { Buffer } from "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 = 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];
-    };
-}
-export default DTMF;

package/dist/esm/index.d.ts

@@ -1,28 +0,0 @@
-import EventEmitter from "node:events";
-import { TLSSocket } from "node:tls";
-import InboundCallSession from "./call-session/inbound.js";
-import OutboundCallSession from "./call-session/outbound.js";
-import { InboundMessage, OutboundMessage } from "./sip-message/index.js";
-import { SoftPhoneOptions } from "./types.js";
-import Codec from "./codec.js";
-declare class Softphone extends EventEmitter {
-    sipInfo: SoftPhoneOptions;
-    client: TLSSocket;
-    codec: Codec;
-    fakeDomain: string;
-    fakeEmail: string;
-    private intervalHandle?;
-    private connected;
-    constructor(sipInfo: SoftPhoneOptions);
-    private instanceId;
-    private registerCallId;
-    register(): Promise<void>;
-    enableDebugMode(): void;
-    revoke(): void;
-    send(message: OutboundMessage, waitForReply?: true): Promise<InboundMessage>;
-    send(message: OutboundMessage, waitForReply?: false): Promise<undefined>;
-    answer(inviteMessage: InboundMessage): Promise<InboundCallSession>;
-    decline(inviteMessage: InboundMessage): Promise<void>;
-    call(callee: string): Promise<OutboundCallSession>;
-}
-export default Softphone;