ring-client-api 9.25.0-beta.0 → 10.0.0-beta.1

package/lib/api/sip-session.js

@@ -1,216 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SipSession = void 0;
-const rxjs_1 = require("rxjs");
-const rtp_utils_1 = require("./rtp-utils");
-const camera_utils_1 = require("@homebridge/camera-utils");
-const sip_call_1 = require("./sip-call");
-const subscribed_1 = require("./subscribed");
-const util_1 = require("./util");
-const ffmpeg_1 = require("./ffmpeg");
-const operators_1 = require("rxjs/operators");
-class SipSession extends subscribed_1.Subscribed {
-    constructor(sipOptions, rtpOptions, audioSplitter, audioRtcpSplitter, videoSplitter, videoRtcpSplitter, tlsPort, camera) {
-        super();
-        this.sipOptions = sipOptions;
-        this.rtpOptions = rtpOptions;
-        this.audioSplitter = audioSplitter;
-        this.audioRtcpSplitter = audioRtcpSplitter;
-        this.videoSplitter = videoSplitter;
-        this.videoRtcpSplitter = videoRtcpSplitter;
-        this.tlsPort = tlsPort;
-        this.camera = camera;
-        this.hasStarted = false;
-        this.hasCallEnded = false;
-        this.onCallEndedSubject = new rxjs_1.ReplaySubject(1);
-        this.onCallEnded = this.onCallEndedSubject.asObservable();
-        this.sipCall = this.createSipCall(this.sipOptions);
-    }
-    createSipCall(sipOptions) {
-        if (this.sipCall) {
-            this.sipCall.destroy();
-        }
-        const call = (this.sipCall = new sip_call_1.SipCall(sipOptions, this.rtpOptions, this.tlsPort));
-        this.addSubscriptions(call.onEndedByRemote.subscribe(() => this.callEnded(false)));
-        return this.sipCall;
-    }
-    start(ffmpegOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasStarted) {
-                throw new Error('SIP Session has already been started');
-            }
-            this.hasStarted = true;
-            if (this.hasCallEnded) {
-                throw new Error('SIP Session has already ended');
-            }
-            try {
-                const videoPort = yield this.reservePort(1), audioPort = yield this.reservePort(1), rtpDescription = yield this.sipCall.invite(), sendStunRequests = () => {
-                    (0, rtp_utils_1.sendStunBindingRequest)({
-                        rtpSplitter: this.audioSplitter,
-                        rtcpSplitter: this.audioRtcpSplitter,
-                        rtpDescription,
-                        localUfrag: this.sipCall.audioUfrag,
-                        type: 'audio',
-                    });
-                    (0, rtp_utils_1.sendStunBindingRequest)({
-                        rtpSplitter: this.videoSplitter,
-                        rtcpSplitter: this.videoRtcpSplitter,
-                        rtpDescription,
-                        localUfrag: this.sipCall.videoUfrag,
-                        type: 'video',
-                    });
-                };
-                if (ffmpegOptions) {
-                    this.startTranscoder(ffmpegOptions, rtpDescription, audioPort, videoPort);
-                }
-                // if rtcp-mux is supported, rtp splitter will be used for both rtp and rtcp
-                if (rtpDescription.audio.port === rtpDescription.audio.rtcpPort) {
-                    this.audioRtcpSplitter.close();
-                    this.audioRtcpSplitter = this.audioSplitter;
-                }
-                if (rtpDescription.video.port === rtpDescription.video.rtcpPort) {
-                    this.videoRtcpSplitter.close();
-                    this.videoRtcpSplitter = this.videoSplitter;
-                }
-                if (rtpDescription.video.iceUFrag) {
-                    // ICE is supported
-                    (0, util_1.logDebug)(`Connecting to ${this.camera.name} using ICE`);
-                    (0, rtp_utils_1.createStunResponder)(this.audioSplitter);
-                    (0, rtp_utils_1.createStunResponder)(this.videoSplitter);
-                    sendStunRequests();
-                }
-                else {
-                    // ICE is not supported, use stun as keep alive
-                    (0, util_1.logDebug)(`Connecting to ${this.camera.name} using STUN`);
-                    this.addSubscriptions(
-                    // hole punch every .5 seconds to keep stream alive and port open (matches behavior from Ring app)
-                    (0, rxjs_1.timer)(0, 500).subscribe(sendStunRequests));
-                }
-                this.addSubscriptions(this.audioSplitter.onMessage.pipe((0, operators_1.take)(1)).subscribe(() => {
-                    (0, util_1.logDebug)(`Audio stream latched for ${this.camera.name}`);
-                }), this.videoSplitter.onMessage.pipe((0, operators_1.take)(1)).subscribe(() => {
-                    (0, util_1.logDebug)(`Video stream latched for ${this.camera.name}`);
-                }));
-                return rtpDescription;
-            }
-            catch (e) {
-                if (e === sip_call_1.expiredDingError) {
-                    const sipOptions = yield this.camera.getUpdatedSipOptions(this.sipOptions.dingId);
-                    this.createSipCall(sipOptions);
-                    this.hasStarted = false;
-                    return this.start(ffmpegOptions);
-                }
-                this.callEnded(true);
-                throw e;
-            }
-        });
-    }
-    prepareTranscoder(transcodeVideoStream, ffmpegInputOptions, remoteRtpOptions, audioPort, videoPort, sdpInput) {
-        const ffmpegInputArguments = [
-            '-hide_banner',
-            '-protocol_whitelist',
-            'pipe,udp,rtp,file,crypto',
-            '-f',
-            'sdp',
-            ...(ffmpegInputOptions || []),
-            '-i',
-            sdpInput,
-        ], inputSdpLines = [
-            'v=0',
-            'o=105202070 3747 461 IN IP4 127.0.0.1',
-            's=Talk',
-            'c=IN IP4 127.0.0.1',
-            'b=AS:380',
-            't=0 0',
-            'a=rtcp-xr:rcvr-rtt=all:10000 stat-summary=loss,dup,jitt,TTL voip-metrics',
-            `m=audio ${audioPort} RTP/SAVP 0 101`,
-            'a=rtpmap:0 PCMU/8000',
-            (0, camera_utils_1.createCryptoLine)(remoteRtpOptions.audio),
-            'a=rtcp-mux',
-        ];
-        if (transcodeVideoStream) {
-            inputSdpLines.push(`m=video ${videoPort} RTP/SAVP 99`, 'a=rtpmap:99 H264/90000', (0, camera_utils_1.createCryptoLine)(remoteRtpOptions.video), 'a=rtcp-mux');
-            let haveReceivedStreamPacket = false;
-            this.videoSplitter.addMessageHandler(({ isRtpMessage, message }) => {
-                if ((0, rtp_utils_1.isStunMessage)(message)) {
-                    return null;
-                }
-                if (!haveReceivedStreamPacket) {
-                    this.sipCall.requestKeyFrame().catch(rxjs_1.noop);
-                    haveReceivedStreamPacket = true;
-                }
-                return {
-                    port: isRtpMessage ? videoPort : videoPort + 1,
-                };
-            });
-        }
-        this.audioSplitter.addMessageHandler(({ isRtpMessage, message }) => {
-            if ((0, rtp_utils_1.isStunMessage)(message)) {
-                return null;
-            }
-            return {
-                port: isRtpMessage ? audioPort : audioPort + 1,
-            };
-        });
-        return {
-            ffmpegInputArguments,
-            inputSdpLines,
-        };
-    }
-    startTranscoder(ffmpegOptions, remoteRtpOptions, audioPort, videoPort) {
-        const transcodeVideoStream = ffmpegOptions.video !== false, { ffmpegInputArguments, inputSdpLines } = this.prepareTranscoder(transcodeVideoStream, ffmpegOptions.input, remoteRtpOptions, audioPort, videoPort, 'pipe:'), ff = new camera_utils_1.FfmpegProcess({
-            ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
-                ? ffmpegOptions.video || ['-vcodec', 'copy']
-                : []), ...(ffmpegOptions.output || [])),
-            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
-            exitCallback: () => this.callEnded(true),
-            logLabel: `From Ring (${this.camera.name})`,
-            logger: {
-                error: util_1.logError,
-                info: util_1.logDebug,
-            },
-        });
-        this.onCallEnded.subscribe(() => ff.stop());
-        ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
-    }
-    reservePort(bufferPorts = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ports = yield (0, camera_utils_1.reservePorts)({ count: bufferPorts + 1 });
-            return ports[0];
-        });
-    }
-    requestKeyFrame() {
-        return this.sipCall.requestKeyFrame();
-    }
-    activateCameraSpeaker() {
-        return this.sipCall.activateCameraSpeaker();
-    }
-    callEnded(sendBye) {
-        if (this.hasCallEnded) {
-            return;
-        }
-        this.hasCallEnded = true;
-        if (sendBye) {
-            this.sipCall.sendBye().catch(util_1.logError);
-        }
-        // clean up
-        this.onCallEndedSubject.next(null);
-        this.sipCall.destroy();
-        this.videoSplitter.close();
-        this.audioSplitter.close();
-        this.unsubscribe();
-    }
-    stop() {
-        this.callEnded(true);
-    }
-}
-exports.SipSession = SipSession;

package/lib/api/sip.d.ts

@@ -1,87 +0,0 @@
-export function copyMessage(msg: any, deep: any): any;
-export function create(options: any, callback: any): {
-    send: (m: any, callback: any) => void;
-    encodeFlowUri: (flow: any) => {
-        schema: string;
-        user: any;
-        host: any;
-        params: {};
-    };
-    decodeFlowUri: (uri: any) => {
-        protocol: any;
-        address: any;
-        port: number;
-        local: {
-            address: any;
-            port: number;
-        };
-    } | undefined;
-    isFlowUri: (uri: any) => boolean;
-    hostname: () => any;
-    destroy: () => void;
-    makeResponse: typeof makeResponse;
-};
-export function start(options: any, callback: any): void;
-export function parseAOR(data: any): any;
-export function parseUri(s: any): any;
-export function stringifyUri(uri: any): string;
-export function stringifyAuthHeader(a: any): string;
-export function stringify(m: any): string;
-export function makeResponse(rq: any, status: any, reason: any, extension: any): {
-    status: any;
-    reason: any;
-    version: any;
-    headers: {
-        via: any;
-        to: any;
-        from: any;
-        'call-id': any;
-        cseq: any;
-    };
-};
-export function makeStreamParser(onMessage: any, onFlood: any, maxBytesHeaders: any, maxContentLength: any): (data: any) => void;
-declare function parseMessage(s: any): {
-    headers: {};
-} | undefined;
-export function makeTransport(options: any, callback: any): {
-    open: (target: any, error: any) => any;
-    get: (target: any, error: any) => any;
-    send: (target: any, message: any) => void;
-    destroy: () => void;
-};
-export function resolve(uri: any, action: any): any;
-export function generateBranch(): string;
-export function makeTransactionLayer(options: any, transport: any): {
-    createServerTransaction: (rq: any, cn: any) => {
-        send: (...args: any[]) => void;
-        message: (...args: any[]) => void;
-        shutdown: () => void;
-    };
-    createClientTransaction: (connection: any, rq: any, callback: any) => {
-        message: (...args: any[]) => void;
-        shutdown: () => void;
-    };
-    getServer: (m: any) => any;
-    getClient: (m: any) => any;
-    destroy: () => void;
-};
-export function send(m: any, callback: any): void;
-declare function destroy(): void;
-export function encodeFlowUri(flow: any): {
-    schema: string;
-    user: any;
-    host: any;
-    params: {};
-};
-export function decodeFlowUri(uri: any): {
-    protocol: any;
-    address: any;
-    port: number;
-    local: {
-        address: any;
-        port: number;
-    };
-} | undefined;
-export function isFlowUri(uri: any): boolean;
-export function hostname(): any;
-export { parseMessage as parse, destroy as stop };