homebridge-ring 9.25.0-beta.1 → 10.0.0-beta.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [10.0.0-beta.0](https://github.com/dgreif/ring/compare/v9.25.0-beta.1...v10.0.0-beta.0) (2022-02-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* `ring-client-api` only (homebridge not impacted) - All streaming will now be done using the new Ring api via WebRTC + WebSockets.  For those using `camera.streamVideo`, you should not notice any difference.  Anyone directly interacting with sip sessions, you will need to migrate to the new `LiveCall` api.  It's fairly similar, and should be more reliable long term.  A number of other sip-specific methods have been removed from the `RingCamera` api as well.
+* Node 10 is no longer officially supported.  It may still work, but could break without warning in the future.
+* **homebridge:** The minimum supported homebridge version for this plugin is now 1.4.0
+* **homebridge:** This change will break all existing automations related to cameras, and will likely move them back to the default room in HomeKit.  Once updated, you will have to set up your automations again manually.  This is necessary to get camera audio working again after the switch to Opus
+* **homebridge:** Switching to Opus requires the camera to be removed and re-added to HomeKit.  Until this is done, you will not receive audio from your cameras.
+
+### Features
+
+* add floodlight pro ([f749d38](https://github.com/dgreif/ring/commit/f749d38e0528e631864bf20819692a466744e1f2)), closes [#889](https://github.com/dgreif/ring/issues/889)
+* **homebridge:** stream opus audio without ffmpeg for transcoding ([ee142bc](https://github.com/dgreif/ring/commit/ee142bc0eee9dcfda41d162b2105535b8fdcbf9a))
+
+
+### Bug Fixes
+
+* drop support for node 10 ([509d556](https://github.com/dgreif/ring/commit/509d55670b3dd4efee1be968618f6bc6b142ae2b))
+* **homebridge:** force cameras to be recreated in HomeKit ([94a1520](https://github.com/dgreif/ring/commit/94a15204f4a9ccbe94968be8db05add6baa5fcfa))
+* **homebridge:** increase minimum homebridge version to 1.4.0 ([d5be74a](https://github.com/dgreif/ring/commit/d5be74aae45a3e353bcaba4fc42fa25c6b2fa37e))
+* remove sip calling in favor of live calls ([7aeae37](https://github.com/dgreif/ring/commit/7aeae37e6e93b68747e14983cea9c0a9229faec6))
+* use Buffer.from ([2b28d90](https://github.com/dgreif/ring/commit/2b28d9028fc7f2c2e11b11cf3b27cc03f097eab2))
+
 ## [9.25.0-beta.1](https://github.com/dgreif/ring/compare/v9.25.0-beta.0...v9.25.0-beta.1) (2022-02-14)
 
 

package/lib/api/index.d.ts

@@ -4,4 +4,3 @@ export * from './ring-camera';
 export * from './ring-chime';
 export * from './ring-device';
 export * from './ring-types';
-export * from './sip-session';

package/lib/api/index.js

@@ -16,4 +16,3 @@ __exportStar(require("./ring-camera"), exports);
 __exportStar(require("./ring-chime"), exports);
 __exportStar(require("./ring-device"), exports);
 __exportStar(require("./ring-types"), exports);
-__exportStar(require("./sip-session"), exports);

package/lib/api/live-call.d.ts

@@ -16,7 +16,7 @@ export declare class LiveCall extends Subscribed {
     private readonly onWsOpen;
     private readonly onMessage;
     private readonly pc;
-    readonly onCallAnswered: ReplaySubject<void>;
+    readonly onCallAnswered: ReplaySubject<string>;
     readonly onCallEnded: ReplaySubject<void>;
     private readonly audioSplitter;
     private readonly videoSplitter;
@@ -25,10 +25,6 @@ export declare class LiveCall extends Subscribed {
     constructor(sessionId: string, camera: RingCamera);
     private handleMessage;
     reservePort(bufferPorts?: number): Promise<number>;
-    prepareTranscoder(transcodeVideoStream: boolean, ffmpegInputOptions: SpawnInput[] | undefined, audioPort: number, videoPort: number, sdpInput: string): {
-        ffmpegInputArguments: SpawnInput[];
-        inputSdpLines: string[];
-    };
     startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     activated: boolean;
     activate(): Promise<void>;

package/lib/api/live-call.js

@@ -62,7 +62,7 @@ class LiveCall extends subscribed_1.Subscribed {
                 case 'sdp':
                     const answer = yield this.pc.createAnswer(message);
                     this.sendMessage(Object.assign({ method: 'sdp' }, answer));
-                    this.onCallAnswered.next();
+                    this.onCallAnswered.next(message.sdp);
                     return;
                 case 'ice':
                     yield this.pc.addIceCandidate({
@@ -79,57 +79,22 @@ class LiveCall extends subscribed_1.Subscribed {
             return ports[0];
         });
     }
-    prepareTranscoder(transcodeVideoStream, ffmpegInputOptions, audioPort, videoPort, sdpInput) {
-        const ffmpegInputArguments = [
-            '-hide_banner',
-            '-protocol_whitelist',
-            'pipe,udp,rtp,file,crypto',
-            '-acodec',
-            'libopus',
-            '-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 101`,
-            'a=rtpmap:101 OPUS/48000/2',
-            'a=rtcp-fb:101 nack pli',
-            'a=fmtp:101 useinbandfec=1;sprop-stereo=0',
-            'a=rtcp-mux',
-        ];
-        if (transcodeVideoStream) {
-            inputSdpLines.push(`m=video ${videoPort} RTP/SAVP 96`, 'a=rtpmap:96 H264/90000', 'a=rtcp-fb:96 nack', 'a=rtcp-fb:96 nack pli', 'a=fmtp:96 packetization-mode=1;profile-level-id=640029;level-asymmetry-allowed=1', 'a=rtcp-mux');
-            this.addSubscriptions(this.onVideoRtp
-                .pipe((0, operators_1.concatMap)((rtp) => {
-                return this.videoSplitter.send(rtp.serialize(), {
-                    port: videoPort,
-                });
-            }))
-                .subscribe());
-        }
-        this.addSubscriptions(this.onAudioRtp
-            .pipe((0, operators_1.concatMap)((rtp) => {
-            return this.audioSplitter.send(rtp.serialize(), {
-                port: audioPort,
-            });
-        }))
-            .subscribe());
-        return {
-            ffmpegInputArguments,
-            inputSdpLines,
-        };
-    }
     startTranscoding(ffmpegOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const videoPort = yield this.reservePort(1), audioPort = yield this.reservePort(1), transcodeVideoStream = ffmpegOptions.video !== false, { ffmpegInputArguments, inputSdpLines } = this.prepareTranscoder(transcodeVideoStream, ffmpegOptions.input, audioPort, videoPort, 'pipe:'), ff = new camera_utils_1.FfmpegProcess({
+            const videoPort = yield this.reservePort(1), audioPort = yield this.reservePort(1), transcodeVideoStream = ffmpegOptions.video !== false, ffmpegInputArguments = [
+                '-hide_banner',
+                '-protocol_whitelist',
+                'pipe,udp,rtp,file,crypto',
+                '-acodec',
+                'libopus',
+                '-f',
+                'sdp',
+                ...(ffmpegOptions.input || []),
+                '-i',
+                'pipe:',
+            ], inputSdp = (yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered))
+                .replace(/m=audio \d+/, `m=audio ${audioPort}`)
+                .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new camera_utils_1.FfmpegProcess({
                 ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream
                     ? ffmpegOptions.video || ['-vcodec', 'copy']
                     : []), ...(ffmpegOptions.output || [])),
@@ -141,8 +106,24 @@ class LiveCall extends subscribed_1.Subscribed {
                     info: util_1.logDebug,
                 },
             });
+            this.addSubscriptions(this.onAudioRtp
+                .pipe((0, operators_1.concatMap)((rtp) => {
+                return this.audioSplitter.send(rtp.serialize(), {
+                    port: audioPort,
+                });
+            }))
+                .subscribe());
+            if (transcodeVideoStream) {
+                this.addSubscriptions(this.onVideoRtp
+                    .pipe((0, operators_1.concatMap)((rtp) => {
+                    return this.videoSplitter.send(rtp.serialize(), {
+                        port: videoPort,
+                    });
+                }))
+                    .subscribe());
+            }
             this.onCallEnded.subscribe(() => ff.stop());
-            ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
+            ff.writeStdin(inputSdp);
             // Activate the stream now that ffmpeg is ready to receive
             yield this.activate();
         });

package/lib/api/ring-camera.d.ts

@@ -2,12 +2,9 @@
 import { ActiveDing, CameraData, CameraDeviceSettingsData, CameraEventOptions, CameraEventResponse, CameraHealth, HistoryOptions, PeriodicFootageResponse, VideoSearchResponse } from './ring-types';
 import { RingRestClient } from './rest-client';
 import { BehaviorSubject, Subject } from 'rxjs';
-import { SrtpOptions } from '@homebridge/camera-utils';
 import { DeepPartial } from './util';
-import { FfmpegOptions, SipSession } from './sip-session';
-import { SipOptions } from './sip-call';
 import { Subscribed } from './subscribed';
-import { LiveCall } from './live-call';
+import { FfmpegOptions, LiveCall } from './live-call';
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'>): number | null;
 export declare function getSearchQueryString(options: CameraEventOptions | (HistoryOptions & {
     accountId: string;
@@ -56,10 +53,6 @@ export declare class RingCamera extends Subscribed {
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
     startLiveCall(): Promise<LiveCall>;
-    startVideoOnDemand(): Promise<("" | ActiveDing) & import("./rest-client").ExtendedResponse>;
-    private pollForActiveDing;
-    private expiredDingIds;
-    getSipConnectionDetails(): Promise<ActiveDing>;
     private removeDingById;
     processActiveDing(ding: ActiveDing): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -92,15 +85,8 @@ export declare class RingCamera extends Subscribed {
         maxWaitMs?: number;
         force?: boolean;
     }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
-    getSipOptions(): Promise<SipOptions>;
-    getUpdatedSipOptions(expiredDingId: string): Promise<SipOptions>;
-    createSipSession(options?: {
-        audio?: SrtpOptions;
-        video?: SrtpOptions;
-        skipFfmpegCheck?: boolean;
-    }): Promise<SipSession>;
     recordToFile(outputPath: string, duration?: number): Promise<void>;
-    streamVideo(ffmpegOptions: FfmpegOptions): Promise<SipSession>;
+    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall>;
     subscribeToDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     unsubscribeFromDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     subscribeToMotionEvents(): Promise<void & import("./rest-client").ExtendedResponse>;

package/lib/api/ring-camera.js

@@ -14,9 +14,7 @@ const ring_types_1 = require("./ring-types");
 const rest_client_1 = require("./rest-client");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
-const camera_utils_1 = require("@homebridge/camera-utils");
 const util_1 = require("./util");
-const sip_session_1 = require("./sip-session");
 const subscribed_1 = require("./subscribed");
 const live_call_1 = require("./live-call");
 const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
@@ -82,7 +80,6 @@ class RingCamera extends subscribed_1.Subscribed {
         this.onMotionDetected = this.onActiveDings.pipe((0, operators_1.map)((dings) => dings.some((ding) => ding.motion || ding.kind === 'motion')), (0, operators_1.distinctUntilChanged)(), (0, operators_1.publishReplay)(1), (0, operators_1.refCount)());
         this.onMotionStarted = this.onMotionDetected.pipe((0, operators_1.filter)((currentlyDetected) => currentlyDetected), (0, operators_1.mapTo)(null), // no value needed, event is what matters
         (0, operators_1.share)());
-        this.expiredDingIds = [];
         this.lastSnapshotTimestamp = 0;
         this.lastSnapshotTimestampLocal = 0;
         this.fetchingSnapshot = false;
@@ -251,42 +248,6 @@ class RingCamera extends subscribed_1.Subscribed {
             return new live_call_1.LiveCall(liveCall.data.session_id, this);
         });
     }
-    startVideoOnDemand() {
-        return this.restClient
-            .request({
-            method: 'POST',
-            url: this.doorbotUrl('live_view'), // Ring app uses vod for battery cams, but doesn't appear to be necessary
-        })
-            .catch((e) => {
-            var _a;
-            if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 403) {
-                const errorMessage = `Camera ${this.name} returned 403 when starting a live stream.  This usually indicates that live streaming is blocked by Modes settings.  Check your Ring app and verify that you are able to stream from this camera with the current Modes settings.`;
-                (0, util_1.logError)(errorMessage);
-                throw new Error(errorMessage);
-            }
-            throw e;
-        });
-    }
-    pollForActiveDing() {
-        // try every second until a new ding is received
-        this.addSubscriptions((0, rxjs_1.interval)(1000)
-            .pipe((0, operators_1.takeUntil)(this.onNewDing))
-            .subscribe(() => {
-            this.onRequestActiveDings.next(null);
-        }));
-    }
-    getSipConnectionDetails() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const vodPromise = (0, rxjs_1.firstValueFrom)(this.onNewDing), videoOnDemandDing = yield this.startVideoOnDemand();
-            if (videoOnDemandDing && 'sip_from' in videoOnDemandDing) {
-                // wired cams return a ding from live_view so we don't need to wait
-                return videoOnDemandDing;
-            }
-            // battery cams return '' from live_view so we need to request active dings and wait
-            this.pollForActiveDing();
-            return vodPromise;
-        });
-    }
     removeDingById(idToRemove) {
         const allActiveDings = this.activeDings, otherDings = allActiveDings.filter((ding) => ding.id_str !== idToRemove);
         this.onActiveDings.next(otherDings);
@@ -297,7 +258,6 @@ class RingCamera extends subscribed_1.Subscribed {
         this.onNewDing.next(ding);
         setTimeout(() => {
             this.removeDingById(ding.id_str);
-            this.expiredDingIds = this.expiredDingIds.filter((id) => id !== dingId);
         }, 65 * 1000); // dings last ~1 minute
     }
     getEvents(options = {}) {
@@ -418,49 +378,9 @@ class RingCamera extends subscribed_1.Subscribed {
             return response;
         });
     }
-    getSipOptions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const activeDings = this.onActiveDings.getValue(), existingDing = activeDings
-                .filter((ding) => !this.expiredDingIds.includes(ding.id_str))
-                .slice()
-                .reverse()[0], ding = existingDing || (yield this.getSipConnectionDetails());
-            return {
-                to: ding.sip_to,
-                from: ding.sip_from,
-                dingId: ding.id_str,
-                localIp: yield (0, camera_utils_1.getDefaultIpAddress)(),
-            };
-        });
-    }
-    getUpdatedSipOptions(expiredDingId) {
-        // Got a 480 from sip session, which means it's no longer active
-        this.expiredDingIds.push(expiredDingId);
-        return this.getSipOptions();
-    }
-    createSipSession(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const audioSplitter = new camera_utils_1.RtpSplitter(), audioRtcpSplitter = new camera_utils_1.RtpSplitter(), videoSplitter = new camera_utils_1.RtpSplitter(), videoRtcpSplitter = new camera_utils_1.RtpSplitter(), [sipOptions, ffmpegIsInstalled, audioPort, audioRtcpPort, videoPort, videoRtcpPort, [tlsPort],] = yield Promise.all([
-                this.getSipOptions(),
-                options.skipFfmpegCheck ? Promise.resolve(true) : (0, camera_utils_1.isFfmpegInstalled)(),
-                audioSplitter.portPromise,
-                audioRtcpSplitter.portPromise,
-                videoSplitter.portPromise,
-                videoRtcpSplitter.portPromise,
-                (0, camera_utils_1.reservePorts)({ type: 'tcp' }),
-            ]), rtpOptions = {
-                audio: Object.assign({ port: audioPort, rtcpPort: audioRtcpPort }, (options.audio || (0, camera_utils_1.generateSrtpOptions)())),
-                video: Object.assign({ port: videoPort, rtcpPort: videoRtcpPort }, (options.video || (0, camera_utils_1.generateSrtpOptions)())),
-            };
-            if (!ffmpegIsInstalled) {
-                throw new Error('Ffmpeg is not installed.  See https://github.com/dgreif/ring/wiki/FFmpeg for directions.');
-            }
-            return new sip_session_1.SipSession(sipOptions, rtpOptions, audioSplitter, audioRtcpSplitter, videoSplitter, videoRtcpSplitter, tlsPort, this);
-        });
-    }
     recordToFile(outputPath, duration = 30) {
         return __awaiter(this, void 0, void 0, function* () {
-            const liveCall = yield this.startLiveCall();
-            yield liveCall.startTranscoding({
+            const liveCall = yield this.streamVideo({
                 output: ['-t', duration.toString(), outputPath],
             });
             yield (0, rxjs_1.firstValueFrom)(liveCall.onCallEnded);
@@ -468,9 +388,9 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     streamVideo(ffmpegOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            const sipSession = yield this.createSipSession();
-            yield sipSession.start(ffmpegOptions);
-            return sipSession;
+            const liveCall = yield this.startLiveCall();
+            yield liveCall.startTranscoding(ffmpegOptions);
+            return liveCall;
         });
     }
     subscribeToDingEvents() {
@@ -502,5 +422,3 @@ class RingCamera extends subscribed_1.Subscribed {
     }
 }
 exports.RingCamera = RingCamera;
-// SOMEDAY: extract image from video file?
-// ffmpeg -i input.mp4 -r 1 -f image2 image-%2d.png

package/lib/api/ring-types.d.ts

@@ -82,6 +82,7 @@ export declare enum RingCameraKind {
     stickup_cam_v4 = "stickup_cam_v4",
     floodlight_v1 = "floodlight_v1",
     floodlight_v2 = "floodlight_v2",
+    floodlight_pro = "floodlight_pro",
     cocoa_camera = "cocoa_camera",
     cocoa_doorbell = "cocoa_doorbell",
     stickup_cam_mini = "stickup_cam_mini"

package/lib/api/ring-types.js

@@ -90,6 +90,7 @@ var RingCameraKind;
     RingCameraKind["stickup_cam_v4"] = "stickup_cam_v4";
     RingCameraKind["floodlight_v1"] = "floodlight_v1";
     RingCameraKind["floodlight_v2"] = "floodlight_v2";
+    RingCameraKind["floodlight_pro"] = "floodlight_pro";
     RingCameraKind["cocoa_camera"] = "cocoa_camera";
     RingCameraKind["cocoa_doorbell"] = "cocoa_doorbell";
     RingCameraKind["stickup_cam_mini"] = "stickup_cam_mini";
@@ -123,6 +124,7 @@ exports.RingCameraModel = {
     stickup_cam_v4: 'Spotlight Cam',
     floodlight_v1: 'Floodlight Cam',
     floodlight_v2: 'Floodlight Cam',
+    floodlight_pro: 'Floodlight Pro',
     cocoa_camera: 'Stick Up Cam',
     cocoa_doorbell: 'Doorbell Gen 2',
     stickup_cam_mini: 'Indoor Cam',

package/lib/api/rtp-utils.d.ts

@@ -1,33 +1,4 @@
-/// <reference types="node" />
-import { RtpSplitter, SrtpOptions } from '@homebridge/camera-utils';
 import { DingKind } from './ring-types';
-export interface RtpStreamOptions extends SrtpOptions {
-    port: number;
-    rtcpPort: number;
-}
-export interface RtpOptions {
-    audio: RtpStreamOptions;
-    video: RtpStreamOptions;
-}
-export interface RtpStreamDescription extends RtpStreamOptions {
-    ssrc?: number;
-    iceUFrag?: string;
-    icePwd?: string;
-}
-export interface RtpDescription {
-    address: string;
-    audio: RtpStreamDescription;
-    video: RtpStreamDescription;
-}
-export declare function isStunMessage(message: Buffer): boolean;
-export declare function sendStunBindingRequest({ rtpDescription, rtpSplitter, rtcpSplitter, localUfrag, type, }: {
-    rtpSplitter: RtpSplitter;
-    rtcpSplitter: RtpSplitter;
-    rtpDescription: RtpDescription;
-    localUfrag?: string;
-    type: 'video' | 'audio';
-}): void;
-export declare function createStunResponder(rtpSplitter: RtpSplitter): void;
 export interface LiveCallSession {
     alexa_port: 18443;
     app_session_token: string;

package/lib/api/rtp-utils.js

@@ -1,61 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLiveCallSession = exports.createStunResponder = exports.sendStunBindingRequest = exports.isStunMessage = void 0;
-const util_1 = require("./util");
-const stun = require('stun');
-const stunMagicCookie = 0x2112a442; // https://tools.ietf.org/html/rfc5389#section-6
-function isStunMessage(message) {
-    return message.length > 8 && message.readInt32BE(4) === stunMagicCookie;
-}
-exports.isStunMessage = isStunMessage;
-function sendStunBindingRequest({ rtpDescription, rtpSplitter, rtcpSplitter, localUfrag, type, }) {
-    const message = stun.createMessage(1), remoteDescription = rtpDescription[type], { address } = rtpDescription, { iceUFrag, icePwd, port, rtcpPort } = remoteDescription;
-    if (iceUFrag && icePwd && localUfrag) {
-        // Full ICE supported.  Send as formal stun request
-        message.addUsername(iceUFrag + ':' + localUfrag);
-        message.addMessageIntegrity(icePwd);
-        stun
-            .request(`${address}:${port}`, {
-            socket: rtpSplitter.socket,
-            message,
-        })
-            .then(() => (0, util_1.logDebug)(`${type} stun complete`))
-            .catch((e) => {
-            (0, util_1.logError)(`${type} stun error`);
-            (0, util_1.logError)(e);
-        });
-    }
-    else {
-        // ICE not supported.  Fire and forget the stun request for RTP and RTCP
-        const encodedMessage = stun.encode(message);
-        rtpSplitter.send(encodedMessage, { address, port }).catch(util_1.logError);
-        rtcpSplitter
-            .send(encodedMessage, { address, port: rtcpPort })
-            .catch(util_1.logError);
-    }
-}
-exports.sendStunBindingRequest = sendStunBindingRequest;
-function createStunResponder(rtpSplitter) {
-    return rtpSplitter.addMessageHandler(({ message, info }) => {
-        if (!isStunMessage(message)) {
-            return null;
-        }
-        try {
-            const decodedMessage = stun.decode(message), response = stun.createMessage(stun.constants.STUN_BINDING_RESPONSE, decodedMessage.transactionId);
-            response.addXorAddress(info.address, info.port);
-            rtpSplitter.send(stun.encode(response), info).catch(util_1.logError);
-        }
-        catch (e) {
-            (0, util_1.logDebug)('Failed to Decode STUN Message');
-            (0, util_1.logDebug)(message.toString('hex'));
-            (0, util_1.logDebug)(e);
-        }
-        return null;
-    });
-}
-exports.createStunResponder = createStunResponder;
+exports.parseLiveCallSession = void 0;
 function parseLiveCallSession(sessionId) {
-    const encodedSession = sessionId.split('.')[1], buff = new Buffer(encodedSession, 'base64'), text = buff.toString('ascii');
+    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
     return JSON.parse(text);
 }
 exports.parseLiveCallSession = parseLiveCallSession;