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

package/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 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.1](https://github.com/dgreif/ring/compare/v10.0.0-beta.0...v10.0.0-beta.1) (2022-02-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* **homebridge:** For anyone who updated to the 10.0 beta and had their cameras reset in HomeKit, this change will cause another reset.  This moves the audio codecs back to what they were before the 10.0 beta, which means anyone upgrading directly from v9 will _not_ experience a reset of the cameras.  Using native Opus was an experimental feature, which ultimately lead to a degraded user experience.
+
+### Bug Fixes
+
+* allow video transcoding to be skipped ([1ef8cdd](https://github.com/dgreif/ring/commit/1ef8cdd54d1f118a8fdcfd28f6970d9c8b7c65f9))
+* **homebridge:** switch back to aac-eld from opus ([7dcd2a0](https://github.com/dgreif/ring/commit/7dcd2a087da7c1b24cc9bdd3c3919af5e6fb7997))
+
+## [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)
+
+
+### Features
+
+* use new WebRTC endpoint for live calls ([6e7779f](https://github.com/dgreif/ring/commit/6e7779feef9789583921fc44bab32c099f3026d2))
+
 ## [9.25.0-beta.0](https://github.com/dgreif/ring/compare/v9.24.0...v9.25.0-beta.0) (2022-01-29)
 
 

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

@@ -0,0 +1,37 @@
+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 LiveCall extends Subscribed {
+    private sessionId;
+    private camera;
+    private readonly ws;
+    private readonly onWsOpen;
+    private readonly onMessage;
+    private readonly pc;
+    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>;
+    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 sendMessage;
+    private callEnded;
+    stop(): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+}
+export {};

package/lib/api/live-call.js

@@ -0,0 +1,190 @@
+"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.LiveCall = void 0;
+const rtp_utils_1 = require("./rtp-utils");
+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");
+function getCleanSdp(sdp, includeVideo) {
+    return sdp
+        .split('\nm=')
+        .slice(1)
+        .map((section) => 'm=' + section)
+        .filter((section) => includeVideo || !section.startsWith('m=video'))
+        .join('\n');
+}
+class LiveCall extends subscribed_1.Subscribed {
+    constructor(sessionId, camera) {
+        super();
+        this.sessionId = sessionId;
+        this.camera = camera;
+        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.activated = false;
+        const liveCallSession = (0, rtp_utils_1.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.48.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;
+        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) {
+        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;
+            }
+        });
+    }
+    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.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.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.audioSplitter.close();
+        this.videoSplitter.close();
+    }
+    stop() {
+        this.callEnded();
+    }
+    sendAudioPacket(rtp) {
+        this.pc.returnAudioTrack.writeRtp(rtp);
+    }
+}
+exports.LiveCall = LiveCall;

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

@@ -0,0 +1,17 @@
+import { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RtcpPacket, RtpPacket } from '@koush/werift';
+import { Subject } from 'rxjs';
+export declare class PeerConnection {
+    pc: RTCPeerConnection;
+    onAudioRtp: Subject<RtpPacket>;
+    onAudioRtcp: Subject<RtcpPacket>;
+    onVideoRtp: Subject<RtpPacket>;
+    onVideoRtcp: Subject<RtcpPacket>;
+    returnAudioTrack: MediaStreamTrack;
+    constructor();
+    createAnswer(offer: {
+        type: 'offer';
+        sdp: string;
+    }): Promise<import("@koush/werift").RTCSessionDescription>;
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
+    close(): void;
+}

package/lib/api/peer-connection.js

@@ -0,0 +1,96 @@
+"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.PeerConnection = void 0;
+const werift_1 = require("@koush/werift");
+const rxjs_1 = require("rxjs");
+const util_1 = require("./util");
+const debug = false;
+class PeerConnection {
+    constructor() {
+        this.onAudioRtp = new rxjs_1.Subject();
+        this.onAudioRtcp = new rxjs_1.Subject();
+        this.onVideoRtp = new rxjs_1.Subject();
+        this.onVideoRtcp = new rxjs_1.Subject();
+        this.returnAudioTrack = new werift_1.MediaStreamTrack({ kind: 'audio' });
+        const pc = (this.pc = new werift_1.RTCPeerConnection({
+            codecs: {
+                audio: [
+                    new werift_1.RTCRtpCodecParameters({
+                        mimeType: 'audio/opus',
+                        clockRate: 48000,
+                        channels: 2,
+                    }),
+                ],
+                video: [
+                    new werift_1.RTCRtpCodecParameters({
+                        mimeType: 'video/H264',
+                        clockRate: 90000,
+                        rtcpFeedback: [
+                            { type: 'transport-cc' },
+                            { type: 'ccm', parameter: 'fir' },
+                            { type: 'nack' },
+                            { type: 'nack', parameter: 'pli' },
+                            { type: 'goog-remb' },
+                        ],
+                        parameters: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
+                    }),
+                ],
+            },
+        })), audioTransceiver = pc.addTransceiver(this.returnAudioTrack, {
+            direction: 'sendrecv',
+        }), videoTransceiver = pc.addTransceiver('video', {
+            direction: 'recvonly',
+        });
+        audioTransceiver.onTrack.subscribe((track) => {
+            track.onReceiveRtp.subscribe((rtp) => {
+                this.onAudioRtp.next(rtp);
+            });
+            track.onReceiveRtcp.subscribe((rtcp) => {
+                this.onAudioRtcp.next(rtcp);
+            });
+            if (debug) {
+                track.onReceiveRtp.once(() => {
+                    (0, util_1.logInfo)('received first audio packet');
+                });
+            }
+        });
+        videoTransceiver.onTrack.subscribe((track) => {
+            track.onReceiveRtp.subscribe((rtp) => {
+                this.onVideoRtp.next(rtp);
+            });
+            track.onReceiveRtcp.subscribe((rtcp) => {
+                this.onVideoRtcp.next(rtcp);
+            });
+            track.onReceiveRtp.once(() => {
+                if (debug) {
+                    (0, util_1.logInfo)('received first video packet');
+                }
+                setInterval(() => videoTransceiver.receiver.sendRtcpPLI(track.ssrc), 2000);
+            });
+        });
+    }
+    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;
+        });
+    }
+    addIceCandidate(candidate) {
+        return this.pc.addIceCandidate(candidate);
+    }
+    close() {
+        this.pc.close().catch(util_1.logError);
+    }
+}
+exports.PeerConnection = PeerConnection;

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

@@ -2,11 +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 { 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;
@@ -54,10 +52,7 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
-    startVideoOnDemand(): Promise<("" | ActiveDing) & import("./rest-client").ExtendedResponse>;
-    private pollForActiveDing;
-    private expiredDingIds;
-    getSipConnectionDetails(): Promise<ActiveDing>;
+    startLiveCall(): Promise<LiveCall>;
     private removeDingById;
     processActiveDing(ding: ActiveDing): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -90,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,10 +14,9 @@ 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;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -81,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;
@@ -231,40 +229,23 @@ class RingCamera extends subscribed_1.Subscribed {
             return response.device_health;
         });
     }
-    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() {
+    startLiveCall() {
         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;
+            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) {
@@ -277,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 = {}) {
@@ -398,58 +378,19 @@ 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 sipSession = yield this.streamVideo({
+            const liveCall = yield this.streamVideo({
                 output: ['-t', duration.toString(), outputPath],
             });
-            yield (0, rxjs_1.firstValueFrom)(sipSession.onCallEnded);
+            yield (0, rxjs_1.firstValueFrom)(liveCall.onCallEnded);
         });
     }
     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() {
@@ -481,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"
@@ -688,6 +689,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/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',