homebridge-ring 10.0.0-beta.5 → 10.0.0-beta.6

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 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.6](https://github.com/dgreif/ring/compare/v10.0.0-beta.5...v10.0.0-beta.6) (2022-05-06)
+
+
+### Features
+
+* **api:** allow custom peer connections for streaming ([3e9e784](https://github.com/dgreif/ring/commit/3e9e78458afe2849a8c414a6b50eec8718bf77cc))
+
+
+### Bug Fixes
+
+* update dependencies ([4b25595](https://github.com/dgreif/ring/commit/4b255950bcfbf94486192d55cfc90d966cd79d24))
+
 ## [10.0.0-beta.5](https://github.com/dgreif/ring/compare/v10.0.0-beta.4...v10.0.0-beta.5) (2022-04-10)
 
 

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

@@ -4,8 +4,8 @@ import { RingRestClient } from './rest-client';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { DeepPartial } from './util';
 import { Subscribed } from './subscribed';
-import { FfmpegOptions, LiveCall } from './live-call';
-import { LiveCallRingEdge } from './live-call-ring-edge';
+import { FfmpegOptions, StreamingSession } from './streaming/streaming-session';
+import { StreamingConnectionOptions } from './streaming/streaming-connection-base';
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'> & {
     health?: Partial<CameraData['health']>;
 }): number | null;
@@ -55,7 +55,8 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
-    startLiveCall(): Promise<LiveCall | LiveCallRingEdge>;
+    private createStreamingConnection;
+    startLiveCall(options?: StreamingConnectionOptions): Promise<StreamingSession>;
     private removeDingById;
     processPushNotification(notification: PushNotification): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -93,7 +94,7 @@ export declare class RingCamera extends Subscribed {
     }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     getSnapshotByUuid(uuid: string): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     recordToFile(outputPath: string, duration?: number): Promise<void>;
-    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall | LiveCallRingEdge>;
+    streamVideo(ffmpegOptions: FfmpegOptions): Promise<StreamingSession>;
     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

@@ -16,8 +16,9 @@ const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const util_1 = require("./util");
 const subscribed_1 = require("./subscribed");
-const live_call_1 = require("./live-call");
-const live_call_ring_edge_1 = require("./live-call-ring-edge");
+const webrtc_connection_1 = require("./streaming/webrtc-connection");
+const ring_edge_connection_1 = require("./streaming/ring-edge-connection");
+const streaming_session_1 = require("./streaming/streaming-session");
 const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -229,11 +230,11 @@ class RingCamera extends subscribed_1.Subscribed {
             return response.device_health;
         });
     }
-    startLiveCall() {
+    createStreamingConnection(options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isRingEdgeEnabled) {
                 const auth = yield this.restClient.getCurrentAuth();
-                return new live_call_ring_edge_1.LiveCallRingEdge(auth.access_token, this);
+                return new ring_edge_connection_1.RingEdgeConnection(auth.access_token, this, options);
             }
             const liveCall = yield this.restClient
                 .request({
@@ -249,7 +250,13 @@ class RingCamera extends subscribed_1.Subscribed {
                 }
                 throw e;
             });
-            return new live_call_1.LiveCall(liveCall.data.session_id, this);
+            return new webrtc_connection_1.WebrtcConnection(liveCall.data.session_id, this, options);
+        });
+    }
+    startLiveCall(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.createStreamingConnection(options);
+            return new streaming_session_1.StreamingSession(this, connection);
         });
     }
     removeDingById(idToRemove) {

package/lib/api/{peer-connection.d.ts → streaming/peer-connection.d.ts}

@@ -1,7 +1,24 @@
-import { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RtcpPacket, RtpPacket } from '@koush/werift';
-import { ReplaySubject, Subject } from 'rxjs';
-export declare class PeerConnection {
-    pc: RTCPeerConnection;
+import { ConnectionState, MediaStreamTrack, RTCIceCandidate, RtcpPacket, RtpPacket } from '@koush/werift';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+export interface BasicPeerConnection {
+    createOffer(): Promise<{
+        sdp: string;
+    }>;
+    createAnswer(offer: {
+        type: 'offer';
+        sdp: string;
+    }): Promise<RTCSessionDescriptionInit>;
+    acceptAnswer(answer: {
+        type: 'answer';
+        sdp: string;
+    }): Promise<void>;
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
+    onIceCandidate: Observable<RTCIceCandidate>;
+    onConnectionState: Observable<ConnectionState>;
+    close(): void;
+}
+export declare class WeriftPeerConnection implements BasicPeerConnection {
+    private pc;
     onAudioRtp: Subject<RtpPacket>;
     onAudioRtcp: Subject<RtcpPacket>;
     onVideoRtp: Subject<RtpPacket>;

package/lib/api/{peer-connection.js → streaming/peer-connection.js}

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeerConnection = void 0;
+exports.WeriftPeerConnection = void 0;
 const werift_1 = require("@koush/werift");
 const rxjs_1 = require("rxjs");
-const util_1 = require("./util");
+const util_1 = require("../util");
 const debug = false, ringIceServers = [
     'stun:stun.kinesisvideo.us-east-1.amazonaws.com:443',
     'stun:stun.kinesisvideo.us-east-2.amazonaws.com:443',
@@ -23,7 +23,7 @@ const debug = false, ringIceServers = [
     'stun:stun3.l.google.com:19302',
     'stun:stun4.l.google.com:19302',
 ];
-class PeerConnection {
+class WeriftPeerConnection {
     constructor() {
         this.onAudioRtp = new rxjs_1.Subject();
         this.onAudioRtcp = new rxjs_1.Subject();
@@ -131,4 +131,4 @@ class PeerConnection {
         this.pc.close().catch(util_1.logError);
     }
 }
-exports.PeerConnection = PeerConnection;
+exports.WeriftPeerConnection = WeriftPeerConnection;

package/lib/api/streaming/ring-edge-connection.d.ts

@@ -0,0 +1,65 @@
+import { RingCamera } from '../ring-camera';
+import { StreamingConnectionBase, StreamingConnectionOptions } from './streaming-connection-base';
+interface SessionBody {
+    doorbot_id: number;
+    session_id: string;
+}
+interface AnswerMessage {
+    method: 'sdp';
+    body: {
+        sdp: string;
+        type: 'answer';
+    } & SessionBody;
+}
+interface IceCandidateMessage {
+    method: 'ice';
+    body: {
+        ice: string;
+        mlineindex: number;
+    } & SessionBody;
+}
+interface SessionCreatedMessage {
+    method: 'session_created';
+    body: SessionBody;
+}
+interface SessionStartedMessage {
+    method: 'session_started';
+    body: SessionBody;
+}
+interface PongMessage {
+    method: 'pong';
+    body: SessionBody;
+}
+interface NotificationMessage {
+    method: 'notification';
+    body: {
+        is_ok: boolean;
+        text: string;
+    } & SessionBody;
+}
+declare enum CloseReasonCode {
+    NormalClose = 0,
+    AuthenticationFailed = 5,
+    Timeout = 6
+}
+interface CloseMessage {
+    method: 'close';
+    body: {
+        reason: {
+            code: CloseReasonCode;
+            text: string;
+        };
+    } & SessionBody;
+}
+declare type IncomingMessage = AnswerMessage | IceCandidateMessage | SessionCreatedMessage | SessionStartedMessage | PongMessage | CloseMessage | NotificationMessage;
+export declare class RingEdgeConnection extends StreamingConnectionBase {
+    private camera;
+    private readonly onSessionId;
+    private readonly onOfferSent;
+    constructor(authToken: string, camera: RingCamera, options: StreamingConnectionOptions);
+    private initiateCall;
+    private sessionId;
+    protected handleMessage(message: IncomingMessage): Promise<void>;
+    protected sendSessionMessage(method: string, body?: Record<any, any>): void;
+}
+export {};

package/lib/api/streaming/ring-edge-connection.js

@@ -0,0 +1,155 @@
+"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.RingEdgeConnection = void 0;
+const ws_1 = require("ws");
+const rxjs_1 = require("rxjs");
+const util_1 = require("../util");
+const operators_1 = require("rxjs/operators");
+const streaming_connection_base_1 = require("./streaming-connection-base");
+// eslint-disable-next-line no-shadow
+var CloseReasonCode;
+(function (CloseReasonCode) {
+    CloseReasonCode[CloseReasonCode["NormalClose"] = 0] = "NormalClose";
+    // reason: { code: 5, text: '[rsl-apps/webrtc-liveview-server/Session.cpp:429] [Auth] [0xd540]: [rsl-apps/session-manager/Manager.cpp:227] [AppAuth] Unauthorized: invalid or expired token' }
+    // reason: { code: 5, text: 'Authentication failed: -1' }
+    // reason: { code: 5, text: 'Sessions with the provided ID not found' }
+    CloseReasonCode[CloseReasonCode["AuthenticationFailed"] = 5] = "AuthenticationFailed";
+    // reason: { code: 6, text: 'Timeout waiting for ping' }
+    CloseReasonCode[CloseReasonCode["Timeout"] = 6] = "Timeout";
+})(CloseReasonCode || (CloseReasonCode = {}));
+class RingEdgeConnection extends streaming_connection_base_1.StreamingConnectionBase {
+    constructor(authToken, camera, options) {
+        super(new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                'X-Sig-API-Version': '4.0',
+                'X-Sig-Client-ID': 'ring_android-aabb123',
+                'X-Sig-Client-Info': 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
+                'X-Sig-Auth-Type': 'ring_oauth',
+            },
+        }), options);
+        this.camera = camera;
+        this.onSessionId = new rxjs_1.ReplaySubject(1);
+        this.onOfferSent = new rxjs_1.ReplaySubject(1);
+        this.sessionId = null;
+        this.addSubscriptions(this.onWsOpen.subscribe(() => {
+            (0, util_1.logDebug)(`WebSocket connected for ${camera.name} (Ring Edge)`);
+            this.initiateCall().catch((e) => {
+                (0, util_1.logError)(e);
+                this.callEnded();
+            });
+        }), 
+        // The ring-edge session needs a ping every 5 seconds to keep the connection alive
+        this.onCallAnswered
+            .pipe((0, operators_1.switchMap)(() => (0, rxjs_1.interval)(5000)))
+            .subscribe(() => {
+            if (!this.sessionId) {
+                return;
+            }
+            this.sendSessionMessage('ping');
+        }), this.pc.onIceCandidate.subscribe((iceCandidate) => __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onOfferSent);
+            this.sendMessage({
+                method: 'ice',
+                body: {
+                    doorbot_id: camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: 0,
+                },
+            });
+            // HACK: send ice candidate with both mline indexes to convince ring edge to connect both audio and video
+            // Without this, only audio will connect unless you connect from the network of the Ring Edge router
+            this.sendMessage({
+                method: 'ice',
+                body: {
+                    doorbot_id: camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: 1,
+                },
+            });
+        })));
+    }
+    initiateCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sdp } = yield this.pc.createOffer();
+            this.sendMessage({
+                method: 'live_view',
+                body: {
+                    doorbot_id: this.camera.id,
+                    stream_options: { audio_enabled: true, video_enabled: true },
+                    sdp: sdp.replace('\na=group:BUNDLE 0 1', ''),
+                },
+            });
+            this.onOfferSent.next();
+        });
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (message.body.doorbot_id !== this.camera.id) {
+                // ignore messages for other cameras
+                return;
+            }
+            if (['session_created', 'session_started'].includes(message.method) &&
+                'session_id' in message.body &&
+                !this.sessionId) {
+                this.sessionId = message.body.session_id;
+                this.onSessionId.next(this.sessionId);
+            }
+            if (message.body.session_id && message.body.session_id !== this.sessionId) {
+                // ignore messages for other sessions
+                return;
+            }
+            switch (message.method) {
+                case 'session_created':
+                case 'session_started':
+                    // session already stored above
+                    return;
+                case 'sdp':
+                    yield this.pc.acceptAnswer(message.body);
+                    this.onCallAnswered.next(message.body.sdp);
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.body.ice,
+                        sdpMLineIndex: message.body.mlineindex,
+                    });
+                    return;
+                case 'pong':
+                    return;
+                case 'close':
+                    (0, util_1.logError)('Video stream closed');
+                    (0, util_1.logError)(message.body);
+                    this.callEnded();
+                    return;
+            }
+            (0, util_1.logError)('UNKNOWN MESSAGE');
+            (0, util_1.logError)(message);
+        });
+    }
+    sendSessionMessage(method, body = {}) {
+        const message = {
+            method,
+            body: Object.assign(Object.assign({}, body), { doorbot_id: this.camera.id, session_id: this.sessionId }),
+        };
+        if (this.sessionId) {
+            // Send immediately if we already have a session id
+            // This is needed to send `close` before closing the websocket
+            this.sendMessage(message);
+        }
+        else {
+            (0, rxjs_1.firstValueFrom)(this.onSessionId)
+                .then(() => this.sendMessage(message))
+                .catch((e) => (0, util_1.logError)(e));
+        }
+    }
+}
+exports.RingEdgeConnection = RingEdgeConnection;

package/lib/api/streaming/streaming-connection-base.d.ts

@@ -0,0 +1,30 @@
+import { BasicPeerConnection } from './peer-connection';
+import { Subscribed } from '../subscribed';
+import { WebSocket } from 'ws';
+import { RtpPacket } from '@koush/werift';
+import { ReplaySubject, Subject } from 'rxjs';
+export interface StreamingConnectionOptions {
+    createPeerConnection?: () => BasicPeerConnection;
+}
+export declare abstract class StreamingConnectionBase extends Subscribed {
+    protected ws: WebSocket;
+    protected options: StreamingConnectionOptions;
+    readonly onCallAnswered: ReplaySubject<string>;
+    readonly onCallEnded: ReplaySubject<void>;
+    readonly onWsOpen: import("rxjs").Observable<unknown>;
+    protected readonly pc: BasicPeerConnection;
+    readonly onAudioRtp: Subject<RtpPacket>;
+    readonly onVideoRtp: Subject<RtpPacket>;
+    constructor(ws: WebSocket, options?: StreamingConnectionOptions);
+    protected abstract handleMessage(message: {
+        method: string;
+    }): Promise<void>;
+    protected abstract sendSessionMessage(method: string, body?: Record<any, any>): void;
+    private activated;
+    activate(): Promise<void>;
+    activateCameraSpeaker(): Promise<void>;
+    protected sendMessage(message: Record<any, any>): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+    protected callEnded(): void;
+    stop(): void;
+}

package/lib/api/streaming/streaming-connection-base.js

@@ -0,0 +1,111 @@
+"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.StreamingConnectionBase = void 0;
+const peer_connection_1 = require("./peer-connection");
+const subscribed_1 = require("../subscribed");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const util_1 = require("../util");
+class StreamingConnectionBase extends subscribed_1.Subscribed {
+    constructor(ws, options = {}) {
+        super();
+        this.ws = ws;
+        this.options = options;
+        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
+        this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.activated = false;
+        if (options.createPeerConnection) {
+            // we were passed a custom peer connection factory
+            this.pc = options.createPeerConnection();
+            // passing rtp packets is not supported for custom peer connections
+            this.onAudioRtp = new rxjs_1.Subject();
+            this.onVideoRtp = new rxjs_1.Subject();
+        }
+        else {
+            // no custom peer connection factory, use the werift and pass along rtp packets
+            const pc = new peer_connection_1.WeriftPeerConnection();
+            this.pc = pc;
+            this.onAudioRtp = pc.onAudioRtp;
+            this.onVideoRtp = pc.onVideoRtp;
+        }
+        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
+        const onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message'), onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
+        this.addSubscriptions(onMessage
+            .pipe((0, operators_1.concatMap)((message) => {
+            return this.handleMessage(JSON.parse(message.data));
+        }))
+            .subscribe(), onError.subscribe((e) => {
+            (0, util_1.logError)(e);
+            this.callEnded();
+        }), onClose.subscribe(() => {
+            this.callEnded();
+        }), this.pc.onConnectionState.subscribe((state) => {
+            if (state === 'failed') {
+                (0, util_1.logError)('Stream connection failed');
+                this.callEnded();
+            }
+            if (state === 'closed') {
+                (0, util_1.logDebug)('Stream connection closed');
+                this.callEnded();
+            }
+        }));
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
+            (0, util_1.logInfo)('Activating Session');
+            this.sendSessionMessage('activate_session');
+        });
+    }
+    activateCameraSpeaker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            this.sendSessionMessage('camera_options', {
+                stealth_mode: false,
+            });
+        });
+    }
+    sendMessage(message) {
+        this.ws.send(JSON.stringify(message));
+    }
+    sendAudioPacket(rtp) {
+        if (this.pc instanceof peer_connection_1.WeriftPeerConnection) {
+            this.pc.returnAudioTrack.writeRtp(rtp);
+        }
+        else {
+            throw new Error('Cannot send audio packets to a custom peer connection implementation');
+        }
+    }
+    callEnded() {
+        try {
+            this.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
+            });
+            this.ws.close();
+        }
+        catch (_) {
+            // ignore any errors since we are stopping the call
+        }
+        this.unsubscribe();
+        this.onCallEnded.next();
+        this.pc.close();
+    }
+    stop() {
+        this.callEnded();
+    }
+}
+exports.StreamingConnectionBase = StreamingConnectionBase;

package/lib/api/{live-call.d.ts → streaming/streaming-session.d.ts}

@@ -1,7 +1,9 @@
-import { ReplaySubject } from 'rxjs';
-import { RingCamera } from './ring-camera';
-import { Subscribed } from './subscribed';
 import { RtpPacket } from '@koush/werift';
+import { ReplaySubject, Subject } from 'rxjs';
+import { RingEdgeConnection } from './ring-edge-connection';
+import { WebrtcConnection } from './webrtc-connection';
+import { RingCamera } from '../ring-camera';
+import { Subscribed } from '../subscribed';
 declare type SpawnInput = string | number;
 export interface FfmpegOptions {
     input?: SpawnInput[];
@@ -9,27 +11,22 @@ export interface FfmpegOptions {
     audio?: SpawnInput[];
     output: SpawnInput[];
 }
-export declare class LiveCall extends Subscribed {
-    private sessionId;
-    private camera;
-    private readonly ws;
-    private readonly onWsOpen;
-    private readonly onMessage;
-    private readonly pc;
-    readonly onCallAnswered: ReplaySubject<string>;
+export declare class StreamingSession extends Subscribed {
+    private readonly camera;
+    private connection;
     readonly onCallEnded: ReplaySubject<void>;
+    readonly onVideoRtp: Subject<RtpPacket>;
+    readonly onAudioRtp: Subject<RtpPacket>;
     private readonly audioSplitter;
     private readonly videoSplitter;
-    readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
-    readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
-    constructor(sessionId: string, camera: RingCamera);
-    private handleMessage;
-    reservePort(bufferPorts?: number): Promise<number>;
-    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
+    constructor(camera: RingCamera, connection: RingEdgeConnection | WebrtcConnection);
+    private bindToConnection;
     activated: boolean;
     activate(): Promise<void>;
+    cameraSpeakerActivated: boolean;
     activateCameraSpeaker(): Promise<void>;
-    private sendMessage;
+    reservePort(bufferPorts?: number): Promise<number>;
+    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     private callEnded;
     stop(): void;
     sendAudioPacket(rtp: RtpPacket): void;

package/lib/api/{live-call.js → streaming/streaming-session.js}

@@ -9,15 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiveCall = void 0;
-const ws_1 = require("ws");
+exports.StreamingSession = void 0;
+const camera_utils_1 = require("@homebridge/camera-utils");
 const rxjs_1 = require("rxjs");
-const peer_connection_1 = require("./peer-connection");
-const util_1 = require("./util");
+const ffmpeg_1 = require("../ffmpeg");
+const util_1 = require("../util");
 const operators_1 = require("rxjs/operators");
-const subscribed_1 = require("./subscribed");
-const camera_utils_1 = require("@homebridge/camera-utils");
-const ffmpeg_1 = require("./ffmpeg");
+const subscribed_1 = require("../subscribed");
 function getCleanSdp(sdp, includeVideo) {
     return sdp
         .split('\nm=')
@@ -26,62 +24,39 @@ function getCleanSdp(sdp, includeVideo) {
         .filter((section) => includeVideo || !section.startsWith('m=video'))
         .join('\n');
 }
-function parseLiveCallSession(sessionId) {
-    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
-    return JSON.parse(text);
-}
-class LiveCall extends subscribed_1.Subscribed {
-    constructor(sessionId, camera) {
+class StreamingSession extends subscribed_1.Subscribed {
+    constructor(camera, connection) {
         super();
-        this.sessionId = sessionId;
         this.camera = camera;
-        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
+        this.connection = connection;
         this.onCallEnded = new rxjs_1.ReplaySubject(1);
+        this.onVideoRtp = new rxjs_1.Subject();
+        this.onAudioRtp = new rxjs_1.Subject();
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
         this.activated = false;
-        const liveCallSession = parseLiveCallSession(sessionId);
-        this.pc = new peer_connection_1.PeerConnection();
-        this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
-            headers: {
-                API_VERSION: '3.1',
-                API_TOKEN: sessionId,
-                CLIENT_INFO: 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
-            },
+        this.cameraSpeakerActivated = false;
+        this.bindToConnection(connection);
+    }
+    bindToConnection(connection) {
+        this.addSubscriptions(connection.onAudioRtp.subscribe(this.onAudioRtp), connection.onVideoRtp.subscribe(this.onVideoRtp));
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            yield this.connection.activate();
         });
-        this.onAudioRtp = this.pc.onAudioRtp;
-        this.onVideoRtp = this.pc.onVideoRtp;
-        this.onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message');
-        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
-        const onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
-        this.addSubscriptions(this.onMessage
-            .pipe((0, operators_1.concatMap)((message) => {
-            return this.handleMessage(JSON.parse(message.data));
-        }))
-            .subscribe(), this.onWsOpen.subscribe(() => {
-            (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
-        }), onError.subscribe((e) => {
-            (0, util_1.logError)(e);
-            this.callEnded();
-        }), onClose.subscribe(() => {
-            this.callEnded();
-        }));
     }
-    handleMessage(message) {
+    activateCameraSpeaker() {
         return __awaiter(this, void 0, void 0, function* () {
-            switch (message.method) {
-                case 'sdp':
-                    const answer = yield this.pc.createAnswer(message);
-                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
-                    this.onCallAnswered.next(message.sdp);
-                    return;
-                case 'ice':
-                    yield this.pc.addIceCandidate({
-                        candidate: message.ice,
-                        sdpMLineIndex: message.mlineindex,
-                    });
-                    return;
+            if (this.cameraSpeakerActivated) {
+                return;
             }
+            this.cameraSpeakerActivated = true;
+            yield this.connection.activateCameraSpeaker();
         });
     }
     reservePort(bufferPorts = 0) {
@@ -103,7 +78,7 @@ class LiveCall extends subscribed_1.Subscribed {
                 ...(ffmpegOptions.input || []),
                 '-i',
                 'pipe:',
-            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
+            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.connection.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
                 .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
@@ -139,48 +114,10 @@ class LiveCall extends subscribed_1.Subscribed {
             yield this.activate();
         });
     }
-    activate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.activated) {
-                return;
-            }
-            this.activated = true;
-            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
-            (0, util_1.logInfo)('Activating Session');
-            this.sendMessage({ method: 'activate_session' });
-            this.sendMessage({
-                video_enabled: true,
-                audio_enabled: true,
-                method: 'stream_options',
-            });
-        });
-    }
-    activateCameraSpeaker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendMessage({
-                stealth_mode: false,
-                method: 'camera_options',
-            });
-        });
-    }
-    sendMessage(message) {
-        this.ws.send(JSON.stringify(message));
-    }
     callEnded() {
-        try {
-            this.sendMessage({
-                reason: { code: 0, text: '' },
-                method: 'close',
-            });
-            this.ws.close();
-        }
-        catch (_) {
-            // ignore any errors since we are stopping the call
-        }
         this.unsubscribe();
         this.onCallEnded.next();
-        this.pc.close();
+        this.connection.stop();
         this.audioSplitter.close();
         this.videoSplitter.close();
     }
@@ -188,7 +125,7 @@ class LiveCall extends subscribed_1.Subscribed {
         this.callEnded();
     }
     sendAudioPacket(rtp) {
-        this.pc.returnAudioTrack.writeRtp(rtp);
+        this.connection.sendAudioPacket(rtp);
     }
 }
-exports.LiveCall = LiveCall;
+exports.StreamingSession = StreamingSession;

package/lib/api/streaming/webrtc-connection.d.ts

@@ -0,0 +1,23 @@
+import { RingCamera } from '../ring-camera';
+import { StreamingConnectionBase, StreamingConnectionOptions } from './streaming-connection-base';
+interface InitializationMessage {
+    method: 'initialization';
+    text: 'Done';
+}
+interface OfferMessage {
+    method: 'sdp';
+    sdp: string;
+    type: 'offer';
+}
+interface IceCandidateMessage {
+    method: 'ice';
+    ice: string;
+    mlineindex: number;
+}
+export declare class WebrtcConnection extends StreamingConnectionBase {
+    private sessionId;
+    constructor(sessionId: string, camera: RingCamera, options: StreamingConnectionOptions);
+    protected handleMessage(message: InitializationMessage | OfferMessage | IceCandidateMessage): Promise<void>;
+    protected sendSessionMessage(method: string, body?: Record<any, any>): void;
+}
+export {};

package/lib/api/streaming/webrtc-connection.js

@@ -0,0 +1,60 @@
+"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.WebrtcConnection = void 0;
+const ws_1 = require("ws");
+const streaming_connection_base_1 = require("./streaming-connection-base");
+const util_1 = require("../util");
+function parseLiveCallSession(sessionId) {
+    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
+    return JSON.parse(text);
+}
+class WebrtcConnection extends streaming_connection_base_1.StreamingConnectionBase {
+    constructor(sessionId, camera, options) {
+        const liveCallSession = parseLiveCallSession(sessionId);
+        super(new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
+            headers: {
+                API_VERSION: '3.1',
+                API_TOKEN: sessionId,
+                CLIENT_INFO: 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
+            },
+        }), options);
+        this.sessionId = sessionId;
+        this.addSubscriptions(this.onWsOpen.subscribe(() => {
+            (0, util_1.logDebug)(`WebSocket connected for ${camera.name}`);
+        }));
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (message.method) {
+                case 'sdp':
+                    const answer = yield this.pc.createAnswer(message);
+                    this.sendSessionMessage('sdp', answer);
+                    this.onCallAnswered.next(message.sdp);
+                    this.sendSessionMessage('stream_options', {
+                        audio_enabled: true,
+                        video_enabled: true,
+                    });
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.ice,
+                        sdpMLineIndex: message.mlineindex,
+                    });
+                    return;
+            }
+        });
+    }
+    sendSessionMessage(method, body = {}) {
+        this.sendMessage(Object.assign(Object.assign({}, body), { method }));
+    }
+}
+exports.WebrtcConnection = WebrtcConnection;

package/lib/homebridge/camera-source.js

@@ -34,7 +34,7 @@ function getSessionConfig(srtpOptions) {
         profile: 1,
     };
 }
-class StreamingSession {
+class StreamingSessionWrapper {
     constructor(liveCall, prepareStreamRequest, ringCamera, start) {
         this.liveCall = liveCall;
         this.prepareStreamRequest = prepareStreamRequest;
@@ -351,7 +351,7 @@ class CameraSource {
             const start = Date.now();
             (0, util_1.logInfo)(`Preparing Live Stream for ${this.ringCamera.name}`);
             try {
-                const liveCall = yield this.ringCamera.startLiveCall(), session = new StreamingSession(liveCall, request, this.ringCamera, start);
+                const liveCall = yield this.ringCamera.startLiveCall(), session = new StreamingSessionWrapper(liveCall, request, this.ringCamera, start);
                 this.sessions[request.sessionID] = session;
                 (0, util_1.logInfo)(`Stream Prepared for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
                 callback(undefined, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-ring",
-  "version": "10.0.0-beta.5",
+  "version": "10.0.0-beta.6",
   "description": "Homebridge plugin for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/homebridge/index.js",
   "bin": {
@@ -40,44 +40,44 @@
   "license": "MIT",
   "dependencies": {
     "@eneris/push-receiver": "^3.0.1",
-    "@homebridge/camera-utils": "2.1.0",
-    "@homebridge/plugin-ui-utils": "0.0.19",
+    "@homebridge/camera-utils": "^2.1.0",
+    "@homebridge/plugin-ui-utils": "^0.0.19",
     "@koush/werift": "0.14.5-beta9",
     "@types/socket.io-client": "1.4.36",
-    "colors": "1.4.0",
-    "debug": "4.3.4",
-    "got": "11.8.3",
-    "rxjs": "7.5.5",
-    "socket.io-client": "2.4.0",
-    "systeminformation": "5.11.9",
-    "uuid": "8.3.2",
-    "ws": "8.5.0"
+    "colors": "^1.4.0",
+    "debug": "^4.3.4",
+    "got": "^11.8.3",
+    "rxjs": "^7.5.5",
+    "socket.io-client": "^2.4.0",
+    "systeminformation": "^5.11.14",
+    "uuid": "^8.3.2",
+    "ws": "^8.6.0"
   },
   "devDependencies": {
     "@types/debug": "4.1.7",
-    "@types/jest": "27.4.1",
-    "@types/node": "17.0.23",
+    "@types/jest": "27.5.0",
+    "@types/node": "17.0.31",
     "@types/uuid": "8.3.4",
     "@types/ws": "^8.5.3",
-    "@typescript-eslint/eslint-plugin": "5.18.0",
-    "@typescript-eslint/parser": "5.18.0",
+    "@typescript-eslint/eslint-plugin": "5.22.0",
+    "@typescript-eslint/parser": "5.22.0",
     "concurrently": "^7.1.0",
     "conventional-github-releaser": "3.1.5",
     "dotenv": "16.0.0",
-    "esbuild": "^0.14.34",
-    "eslint": "8.13.0",
+    "esbuild": "^0.14.38",
+    "eslint": "8.14.0",
     "eslint-config-prettier": "8.5.0",
-    "eslint-plugin-jest": "26.1.4",
+    "eslint-plugin-jest": "26.1.5",
     "eslint-plugin-prettier": "4.0.0",
-    "express": "4.17.3",
-    "homebridge": "1.4.0",
-    "jest": "27.5.1",
+    "express": "4.18.1",
+    "homebridge": "1.4.1",
+    "jest": "28.1.0",
     "prettier": "2.6.2",
     "reflect-metadata": "0.1.13",
     "rimraf": "3.0.2",
     "standard-version": "9.3.2",
-    "ts-jest": "27.1.4",
-    "typescript": "4.6.3"
+    "ts-jest": "28.0.1",
+    "typescript": "4.6.4"
   },
   "engines": {
     "node": ">=8.3.0",

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

@@ -1,41 +0,0 @@
-import { ReplaySubject } from 'rxjs';
-import { RingCamera } from './ring-camera';
-import { Subscribed } from './subscribed';
-import { RtpPacket } from '@koush/werift';
-declare type SpawnInput = string | number;
-export interface FfmpegOptions {
-    input?: SpawnInput[];
-    video?: SpawnInput[] | false;
-    audio?: SpawnInput[];
-    output: SpawnInput[];
-}
-export declare class LiveCallRingEdge extends Subscribed {
-    private camera;
-    private readonly ws;
-    private readonly onWsOpen;
-    private readonly onMessage;
-    private readonly pc;
-    readonly onSessionId: ReplaySubject<string>;
-    readonly onCallAnswered: ReplaySubject<string>;
-    readonly onCallEnded: ReplaySubject<void>;
-    private readonly audioSplitter;
-    private readonly videoSplitter;
-    readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
-    readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
-    private readonly onOfferSent;
-    constructor(authToken: string, camera: RingCamera);
-    private initiateCall;
-    private sessionId;
-    private handleMessage;
-    reservePort(bufferPorts?: number): Promise<number>;
-    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
-    activated: boolean;
-    activate(): Promise<void>;
-    activateCameraSpeaker(): Promise<void>;
-    private sendSessionMessage;
-    private sendMessage;
-    private callEnded;
-    stop(): void;
-    sendAudioPacket(rtp: RtpPacket): void;
-}
-export {};

package/lib/api/live-call-ring-edge.js

@@ -1,294 +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.LiveCallRingEdge = void 0;
-const ws_1 = require("ws");
-const rxjs_1 = require("rxjs");
-const peer_connection_1 = require("./peer-connection");
-const util_1 = require("./util");
-const operators_1 = require("rxjs/operators");
-const subscribed_1 = require("./subscribed");
-const camera_utils_1 = require("@homebridge/camera-utils");
-const ffmpeg_1 = require("./ffmpeg");
-// eslint-disable-next-line no-shadow
-var CloseReasonCode;
-(function (CloseReasonCode) {
-    CloseReasonCode[CloseReasonCode["NormalClose"] = 0] = "NormalClose";
-    // reason: { code: 5, text: '[rsl-apps/webrtc-liveview-server/Session.cpp:429] [Auth] [0xd540]: [rsl-apps/session-manager/Manager.cpp:227] [AppAuth] Unauthorized: invalid or expired token' }
-    // reason: { code: 5, text: 'Authentication failed: -1' }
-    // reason: { code: 5, text: 'Sessions with the provided ID not found' }
-    CloseReasonCode[CloseReasonCode["AuthenticationFailed"] = 5] = "AuthenticationFailed";
-    // reason: { code: 6, text: 'Timeout waiting for ping' }
-    CloseReasonCode[CloseReasonCode["Timeout"] = 6] = "Timeout";
-})(CloseReasonCode || (CloseReasonCode = {}));
-function getCleanSdp(sdp, includeVideo) {
-    return sdp
-        .split('\nm=')
-        .slice(1)
-        .map((section) => 'm=' + section)
-        .filter((section) => includeVideo || !section.startsWith('m=video'))
-        .join('\n');
-}
-class LiveCallRingEdge extends subscribed_1.Subscribed {
-    constructor(authToken, camera) {
-        super();
-        this.camera = camera;
-        this.onSessionId = new rxjs_1.ReplaySubject(1);
-        this.onCallAnswered = new rxjs_1.ReplaySubject(1);
-        this.onCallEnded = new rxjs_1.ReplaySubject(1);
-        this.audioSplitter = new camera_utils_1.RtpSplitter();
-        this.videoSplitter = new camera_utils_1.RtpSplitter();
-        this.onOfferSent = new rxjs_1.ReplaySubject(1);
-        this.sessionId = null;
-        this.activated = false;
-        this.pc = new peer_connection_1.PeerConnection();
-        this.ws = new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
-            headers: {
-                Authorization: `Bearer ${authToken}`,
-                'X-Sig-API-Version': '4.0',
-                'X-Sig-Client-ID': 'ring_android-aabb123',
-                'X-Sig-Client-Info': 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
-                'X-Sig-Auth-Type': 'ring_oauth',
-            },
-        });
-        this.onAudioRtp = this.pc.onAudioRtp;
-        this.onVideoRtp = this.pc.onVideoRtp;
-        this.onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message');
-        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
-        const onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
-        this.addSubscriptions(this.onMessage
-            .pipe((0, operators_1.concatMap)((message) => {
-            return this.handleMessage(JSON.parse(message.data));
-        }))
-            .subscribe(), this.onWsOpen.subscribe(() => {
-            (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name} (Ring Edge)`);
-            this.initiateCall().catch((e) => {
-                (0, util_1.logError)(e);
-                this.callEnded();
-            });
-        }), onError.subscribe((e) => {
-            (0, util_1.logError)(e);
-            this.callEnded();
-        }), onClose.subscribe(() => {
-            this.callEnded();
-        }), this.onCallAnswered
-            .pipe((0, operators_1.switchMap)(() => (0, rxjs_1.interval)(5000)))
-            .subscribe(() => {
-            if (!this.sessionId) {
-                return;
-            }
-            this.sendSessionMessage('ping');
-        }), this.pc.onIceCandidate.subscribe((iceCandidate) => __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onOfferSent);
-            this.sendMessage({
-                method: 'ice',
-                body: {
-                    doorbot_id: this.camera.id,
-                    ice: iceCandidate.candidate,
-                    mlineindex: 0,
-                },
-            });
-            // HACK: send ice candidate with both mline indexes to convince ring edge to connect both audio and video
-            // Without this, only audio will connect unless you connect from the network of the Ring Edge router
-            this.sendMessage({
-                method: 'ice',
-                body: {
-                    doorbot_id: this.camera.id,
-                    ice: iceCandidate.candidate,
-                    mlineindex: 1,
-                },
-            });
-        })), this.pc.onConnectionState.subscribe((state) => {
-            if (state === 'failed') {
-                (0, util_1.logError)('Stream connection failed');
-                this.callEnded();
-            }
-            if (state === 'closed') {
-                (0, util_1.logDebug)('Stream connection closed');
-                this.callEnded();
-            }
-        }));
-    }
-    initiateCall() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const offer = yield this.pc.createOffer();
-            offer.sdp = offer.sdp.replace('\na=group:BUNDLE 0 1', '');
-            this.sendMessage({
-                method: 'live_view',
-                body: {
-                    doorbot_id: this.camera.id,
-                    stream_options: { audio_enabled: true, video_enabled: true },
-                    sdp: offer.sdp,
-                },
-            });
-            this.onOfferSent.next();
-        });
-    }
-    handleMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (message.body.doorbot_id !== this.camera.id) {
-                // ignore messages for other cameras
-                return;
-            }
-            if (['session_created', 'session_started'].includes(message.method) &&
-                'session_id' in message.body &&
-                !this.sessionId) {
-                this.sessionId = message.body.session_id;
-                this.onSessionId.next(this.sessionId);
-            }
-            if (message.body.session_id && message.body.session_id !== this.sessionId) {
-                // ignore messages for other sessions
-                return;
-            }
-            switch (message.method) {
-                case 'session_created':
-                case 'session_started':
-                    // session already stored above
-                    return;
-                case 'sdp':
-                    yield this.pc.acceptAnswer(message.body);
-                    this.onCallAnswered.next(message.body.sdp);
-                    return;
-                case 'ice':
-                    yield this.pc.addIceCandidate({
-                        candidate: message.body.ice,
-                        sdpMLineIndex: message.body.mlineindex,
-                    });
-                    return;
-                case 'pong':
-                    return;
-                case 'close':
-                    (0, util_1.logError)('Video stream closed');
-                    (0, util_1.logError)(message.body);
-                    this.callEnded();
-                    return;
-            }
-            (0, util_1.logError)('UNKNOWN MESSAGE');
-            (0, util_1.logError)(message);
-        });
-    }
-    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];
-        });
-    }
-    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 = [
-                '-hide_banner',
-                '-protocol_whitelist',
-                'pipe,udp,rtp,file,crypto',
-                '-acodec',
-                'libopus',
-                '-f',
-                'sdp',
-                ...(ffmpegOptions.input || []),
-                '-i',
-                'pipe:',
-            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
-                .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 || [])),
-                ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
-                exitCallback: () => this.callEnded(),
-                logLabel: `From Ring (${this.camera.name})`,
-                logger: {
-                    error: util_1.logError,
-                    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(inputSdp);
-            // Activate the stream now that ffmpeg is ready to receive
-            yield this.activate();
-        });
-    }
-    activate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.activated) {
-                return;
-            }
-            this.activated = true;
-            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
-            (0, util_1.logInfo)('Activating Session');
-            this.sendSessionMessage('activate_session');
-        });
-    }
-    activateCameraSpeaker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendSessionMessage('camera_options', {
-                stealth_mode: false,
-            });
-        });
-    }
-    sendSessionMessage(method, body = {}) {
-        const message = {
-            method,
-            body: Object.assign(Object.assign({}, body), { doorbot_id: this.camera.id, session_id: this.sessionId }),
-        };
-        if (this.sessionId) {
-            // Send immediately if we already have a session id
-            // This is needed to send `close` before closing the websocket
-            this.sendMessage(message);
-        }
-        else {
-            (0, rxjs_1.firstValueFrom)(this.onSessionId)
-                .then(() => this.sendMessage(message))
-                .catch((e) => (0, util_1.logError)(e));
-        }
-    }
-    sendMessage(message) {
-        this.ws.send(JSON.stringify(message));
-    }
-    callEnded() {
-        try {
-            this.sendSessionMessage('close', {
-                reason: { code: CloseReasonCode.NormalClose, text: '' },
-            });
-            this.ws.close();
-        }
-        catch (_) {
-            // ignore any errors since we are stopping the call
-        }
-        this.unsubscribe();
-        this.onCallEnded.next();
-        this.pc.close();
-        this.audioSplitter.close();
-        this.videoSplitter.close();
-    }
-    stop() {
-        this.callEnded();
-    }
-    sendAudioPacket(rtp) {
-        this.pc.returnAudioTrack.writeRtp(rtp);
-    }
-}
-exports.LiveCallRingEdge = LiveCallRingEdge;