ring-client-api 10.0.0-beta.2 → 10.0.0-beta.3

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 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.3](https://github.com/dgreif/ring/compare/v10.0.0-beta.2...v10.0.0-beta.3) (2022-03-26)
+
+
+### Bug Fixes
+
+* separate streaming setup for ring edge vs regular cameras ([6281cf9](https://github.com/dgreif/ring/commit/6281cf966de12dcea8acc6516cd9079634734dec))
+
 ## [10.0.0-beta.2](https://github.com/dgreif/ring/compare/v10.0.0-beta.1...v10.0.0-beta.2) (2022-03-26)
 
 

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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,294 @@
+"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;

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

@@ -10,29 +10,25 @@ export interface FfmpegOptions {
     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 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;
+    constructor(sessionId: string, camera: RingCamera);
     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;

package/lib/api/live-call.js

@@ -18,17 +18,6 @@ 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=')
@@ -37,26 +26,27 @@ 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(authToken, camera) {
+    constructor(sessionId, camera) {
         super();
+        this.sessionId = sessionId;
         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;
+        const liveCallSession = parseLiveCallSession(sessionId);
         this.pc = new peer_connection_1.PeerConnection();
-        this.ws = new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
+        this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
             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',
+                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.onAudioRtp = this.pc.onAudioRtp;
@@ -70,109 +60,28 @@ class LiveCall extends subscribed_1.Subscribed {
         }))
             .subscribe(), this.onWsOpen.subscribe(() => {
             (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
-            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);
+                    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.body.ice,
-                        sdpMLineIndex: message.body.mlineindex,
+                        candidate: message.ice,
+                        sdpMLineIndex: message.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) {
@@ -236,42 +145,32 @@ class LiveCall extends subscribed_1.Subscribed {
                 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');
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            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.sendSessionMessage('camera_options', {
+            this.sendMessage({
                 stealth_mode: false,
+                method: 'camera_options',
             });
         });
     }
-    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.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
             });
             this.ws.close();
         }

package/lib/api/peer-connection.d.ts

@@ -11,6 +11,10 @@ export declare class PeerConnection {
     returnAudioTrack: MediaStreamTrack;
     constructor();
     createOffer(): Promise<import("@koush/werift").RTCSessionDescription>;
+    createAnswer(offer: {
+        type: 'offer';
+        sdp: string;
+    }): Promise<import("@koush/werift").RTCSessionDescription>;
     acceptAnswer(answer: {
         type: 'answer';
         sdp: string;

package/lib/api/peer-connection.js

@@ -43,7 +43,7 @@ class PeerConnection {
                             { type: 'nack', parameter: 'pli' },
                             { type: 'goog-remb' },
                         ],
-                        parameters: 'profile-level-id=42801F',
+                        parameters: 'packetization-mode=1;profile-level-id=42801F;level-asymmetry-allowed=1',
                     }),
                 ],
             },
@@ -100,6 +100,14 @@ class PeerConnection {
             return offer;
         });
     }
+    createAnswer(offer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.pc.setRemoteDescription(offer);
+            const answer = yield this.pc.createAnswer();
+            yield this.pc.setLocalDescription(answer);
+            return answer;
+        });
+    }
     acceptAnswer(answer) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.pc.setRemoteDescription(answer);

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

@@ -5,6 +5,7 @@ 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';
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'>): number | null;
 export declare function getSearchQueryString(options: CameraEventOptions | (HistoryOptions & {
     accountId: string;
@@ -53,7 +54,7 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
-    startLiveCall(): Promise<LiveCall>;
+    startLiveCall(): Promise<LiveCall | LiveCallRingEdge>;
     private removeDingById;
     processActiveDing(ding: ActiveDing): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -87,7 +88,7 @@ export declare class RingCamera extends Subscribed {
         force?: boolean;
     }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     recordToFile(outputPath: string, duration?: number): Promise<void>;
-    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall>;
+    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall | LiveCallRingEdge>;
     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

@@ -17,6 +17,7 @@ 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 maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -234,8 +235,25 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     startLiveCall() {
         return __awaiter(this, void 0, void 0, function* () {
-            const auth = yield this.restClient.getCurrentAuth();
-            return new live_call_1.LiveCall(auth.access_token, this);
+            if (this.isRingEdgeEnabled) {
+                const auth = yield this.restClient.getCurrentAuth();
+                return new live_call_ring_edge_1.LiveCallRingEdge(auth.access_token, this);
+            }
+            const liveCall = yield this.restClient
+                .request({
+                method: 'POST',
+                url: this.doorbotUrl('live_call'),
+            })
+                .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;
+            });
+            return new live_call_1.LiveCall(liveCall.data.session_id, this);
         });
     }
     removeDingById(idToRemove) {

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

@@ -696,6 +696,21 @@ export interface ActiveDing {
     sip_token: string;
     sip_ding_id: string;
 }
+export interface LiveCallResponse {
+    ding_id: string;
+    ding_kind: DingKind;
+    device_id: number;
+    device_kind: RingCameraKind;
+    device_description: string;
+    state: DingState;
+    protocol: 'ring_media_server' | unknown;
+    now: number;
+    video_jitter_buffer_ms: number;
+    audio_jitter_buffer_ms: number;
+    data: {
+        session_id: string;
+    };
+}
 export interface AuthTokenResponse {
     access_token: string;
     expires_in: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "10.0.0-beta.2",
+  "version": "10.0.0-beta.3",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/api/index.js",
   "bin": {