ring-client-api 9.23.0 → 10.0.0-beta.0

package/lib/api/ring-camera.js

@@ -14,12 +14,10 @@ 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 snapshotRefreshDelay = 500, maxSnapshotRefreshSeconds = 35, // needs to be 30+ because battery cam can't take snapshot while recording
-maxSnapshotRefreshAttempts = (maxSnapshotRefreshSeconds * 1000) / snapshotRefreshDelay, fullDayMs = 24 * 60 * 60 * 1000;
+const live_call_1 = require("./live-call");
+const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
         return null;
@@ -73,17 +71,6 @@ class RingCamera extends subscribed_1.Subscribed {
         this.restClient = restClient;
         this.avoidSnapshotBatteryDrain = avoidSnapshotBatteryDrain;
         this.treatKnockAsDing = treatKnockAsDing;
-        this.id = this.initialData.id;
-        this.deviceType = this.initialData.kind;
-        this.model = ring_types_1.RingCameraModel[this.initialData.kind] || 'Unknown Model';
-        this.onData = new rxjs_1.BehaviorSubject(this.initialData);
-        this.hasLight = this.initialData.led_status !== undefined;
-        this.hasSiren = this.initialData.siren_status !== undefined;
-        this.hasBattery = (0, ring_types_1.isBatteryCameraKind)(this.deviceType) ||
-            (typeof this.initialData.battery_life === 'string' &&
-                this.batteryLevel !== null &&
-                this.batteryLevel < 100 &&
-                this.batteryLevel >= 0);
         this.onRequestUpdate = new rxjs_1.Subject();
         this.onRequestActiveDings = new rxjs_1.Subject();
         this.onNewDing = new rxjs_1.Subject();
@@ -93,12 +80,19 @@ 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.lastSnapshotTimestamp = 0;
+        this.lastSnapshotTimestampLocal = 0;
+        this.fetchingSnapshot = false;
+        this.id = this.initialData.id;
+        this.deviceType = this.initialData.kind;
+        this.model = ring_types_1.RingCameraModel[this.initialData.kind] || 'Unknown Model';
+        this.onData = new rxjs_1.BehaviorSubject(this.initialData);
+        this.hasLight = this.initialData.led_status !== undefined;
+        this.hasSiren = this.initialData.siren_status !== undefined;
         this.onBatteryLevel = this.onData.pipe((0, operators_1.map)(getBatteryLevel), (0, operators_1.distinctUntilChanged)());
         this.onInHomeDoorbellStatus = this.onData.pipe((0, operators_1.map)(({ settings: { chime_settings } }) => {
             return Boolean(chime_settings === null || chime_settings === void 0 ? void 0 : chime_settings.enable);
         }), (0, operators_1.distinctUntilChanged)());
-        this.expiredDingIds = [];
-        this.lastSnapshotTimestampLocal = 0;
         if (!initialData.subscribed) {
             this.subscribeToDingEvents().catch((e) => {
                 (0, util_1.logError)('Failed to subscribe ' + initialData.description + ' to ding events');
@@ -130,6 +124,15 @@ class RingCamera extends subscribed_1.Subscribed {
     get batteryLevel() {
         return getBatteryLevel(this.data);
     }
+    get hasBattery() {
+        if (this.batteryLevel === null) {
+            return false;
+        }
+        return ((0, ring_types_1.isBatteryCameraKind)(this.deviceType) ||
+            (typeof this.initialData.battery_life === 'string' &&
+                this.batteryLevel < 100 &&
+                this.batteryLevel >= 0));
+    }
     get hasLowBattery() {
         return this.data.alerts.battery === 'low';
     }
@@ -226,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) {
@@ -272,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 = {}) {
@@ -311,34 +296,14 @@ class RingCamera extends subscribed_1.Subscribed {
     get snapshotsAreBlocked() {
         return this.data.settings.motion_detection_enabled === false;
     }
-    getSnapshotTimestamp() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { timestamps, responseTimestamp } = yield this.restClient.request({
-                url: (0, rest_client_1.clientApi)('snapshots/timestamps'),
-                method: 'POST',
-                json: {
-                    doorbot_ids: [this.id],
-                },
-            }), deviceTimestamp = timestamps[0], timestamp = deviceTimestamp ? deviceTimestamp.timestamp : 0, timestampAge = Math.abs(responseTimestamp - timestamp);
-            this.lastSnapshotTimestampLocal = timestamp ? Date.now() - timestampAge : 0;
-            return {
-                timestamp,
-                inLifeTime: this.isTimestampInLifeTime(timestampAge),
-            };
-        });
-    }
     get snapshotLifeTime() {
         return this.avoidSnapshotBatteryDrain && this.operatingOnBattery
             ? 600 * 1000 // battery cams only refresh timestamp every 10 minutes
-            : 10 * 1000; // snapshot updates will be forced.  Limit to 10 lifetime
+            : 10 * 1000; // snapshot updates will be forced.  Limit to 10s lifetime
     }
     get currentTimestampAge() {
         return Date.now() - this.lastSnapshotTimestampLocal;
     }
-    get currentTimestampExpiresIn() {
-        // Gets 0 if stale snapshot is used because snapshot timestamp refused to update (recording in progress on battery cam)
-        return Math.max(this.lastSnapshotTimestampLocal - Date.now() + this.snapshotLifeTime, 0);
-    }
     get hasSnapshotWithinLifetime() {
         return this.isTimestampInLifeTime(this.currentTimestampAge);
     }
@@ -346,131 +311,86 @@ class RingCamera extends subscribed_1.Subscribed {
         if (this.snapshotsAreBlocked) {
             throw new Error(`Motion detection is disabled for ${this.name}, which prevents snapshots from this camera.  This can be caused by Modes settings or by turning off the Record Motion setting.`);
         }
+        if (this.isOffline) {
+            throw new Error(`Cannot fetch snapshot for ${this.name} because it is offline`);
+        }
     }
-    requestSnapshotUpdate() {
-        return this.restClient.request({
-            method: 'PUT',
-            url: (0, rest_client_1.clientApi)('snapshots/update_all'),
-            json: {
-                doorbot_ids: [this.id],
-                refresh: true,
-            },
-        });
-    }
-    refreshSnapshot() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasSnapshotWithinLifetime) {
-                (0, util_1.logDebug)(`Snapshot for ${this.name} is still within its life time (${this.currentTimestampAge / 1000}s old)`);
-                return true;
-            }
-            this.checkIfSnapshotsAreBlocked();
-            if (!this.avoidSnapshotBatteryDrain || !this.operatingOnBattery) {
-                // tell the camera to update snapshot immediately.
-                // avoidSnapshotBatteryDrain is best if you have a battery cam that you request snapshots for frequently.  This can lead to battery drain if snapshot updates are forced.
-                yield this.requestSnapshotUpdate();
-            }
-            for (let i = 0; i < maxSnapshotRefreshAttempts; i++) {
-                this.checkIfSnapshotsAreBlocked();
-                const { timestamp, inLifeTime } = yield this.getSnapshotTimestamp();
-                if (!timestamp && this.isOffline) {
-                    throw new Error(`No snapshot available and device ${this.name} is offline`);
-                }
-                if (inLifeTime) {
-                    return false;
-                }
-                yield (0, util_1.delay)(snapshotRefreshDelay);
-            }
-            const extraMessageForBatteryCam = this.operatingOnBattery
-                ? '.  This is normal behavior since this camera is unable to capture snapshots while streaming'
-                : '';
-            throw new Error(`Snapshot for ${this.name} (${this.deviceType} - ${this.model}) failed to refresh after ${maxSnapshotRefreshAttempts} attempts${extraMessageForBatteryCam}`);
-        });
+    shouldUseExistingSnapshotPromise() {
+        if (this.fetchingSnapshot) {
+            return true;
+        }
+        if (this.hasSnapshotWithinLifetime) {
+            (0, util_1.logDebug)(`Snapshot for ${this.name} is still within its life time (${this.currentTimestampAge / 1000}s old)`);
+            return true;
+        }
+        if (!this.avoidSnapshotBatteryDrain || !this.operatingOnBattery) {
+            // tell the camera to update snapshot immediately.
+            // avoidSnapshotBatteryDrain is best if you have a battery cam that you request snapshots for frequently.  This can lead to battery drain if snapshot updates are forced.
+            return false;
+        }
     }
     getSnapshot() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.refreshSnapshotInProgress =
-                this.refreshSnapshotInProgress ||
-                    this.refreshSnapshot().catch((e) => {
-                        (0, util_1.logError)(e.message);
-                        throw e;
-                    });
-            try {
-                const useLastSnapshot = yield this.refreshSnapshotInProgress;
-                this.refreshSnapshotInProgress = undefined;
-                if (useLastSnapshot && this.lastSnapshotPromise) {
-                    return this.lastSnapshotPromise;
-                }
+            if (this.lastSnapshotPromise && this.shouldUseExistingSnapshotPromise()) {
+                return this.lastSnapshotPromise;
             }
-            catch (e) {
-                this.refreshSnapshotInProgress = undefined;
-                throw e;
-            }
-            this.lastSnapshotPromise = this.restClient.request({
-                url: (0, rest_client_1.clientApi)(`snapshots/image/${this.id}`),
-                responseType: 'buffer',
-            });
+            this.checkIfSnapshotsAreBlocked();
+            this.lastSnapshotPromise = Promise.race([
+                this.getNextSnapshot({
+                    afterMs: this.lastSnapshotTimestamp,
+                    force: true,
+                }),
+                (0, util_1.delay)(maxSnapshotRefreshSeconds * 1000).then(() => {
+                    const extraMessageForBatteryCam = this.operatingOnBattery
+                        ? '.  This is normal behavior since this camera is unable to capture snapshots while streaming'
+                        : '';
+                    throw new Error(`Snapshot for ${this.name} (${this.deviceType} - ${this.model}) failed to refresh after ${maxSnapshotRefreshSeconds} seconds${extraMessageForBatteryCam}`);
+                }),
+            ]);
             try {
                 yield this.lastSnapshotPromise;
             }
-            catch (_) {
+            catch (e) {
                 // snapshot request failed, don't use it again
                 this.lastSnapshotPromise = undefined;
+                throw e;
             }
+            this.fetchingSnapshot = false;
             return this.lastSnapshotPromise;
         });
     }
-    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 = {}) {
+    getNextSnapshot({ afterMs, maxWaitMs, force, }) {
         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);
+            const response = yield this.restClient.request({
+                url: `https://app-snaps.ring.com/snapshots/next/${this.id}?extras=force`,
+                responseType: 'buffer',
+                searchParams: {
+                    'after-ms': afterMs,
+                    'max-wait-ms': maxWaitMs,
+                    extras: force ? 'force' : undefined,
+                },
+                headers: {
+                    accept: 'image/jpeg',
+                },
+            }), { responseTimestamp, timeMillis } = response, timestampAge = Math.abs(responseTimestamp - timeMillis);
+            this.lastSnapshotTimestamp = timeMillis;
+            this.lastSnapshotTimestampLocal = Date.now() - timestampAge;
+            return response;
         });
     }
     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() {
@@ -502,5 +422,3 @@ class RingCamera extends subscribed_1.Subscribed {
     }
 }
 exports.RingCamera = RingCamera;
-// SOMEDAY: extract image from video file?
-// ffmpeg -i input.mp4 -r 1 -f image2 image-%2d.png

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

@@ -5,7 +5,7 @@ export declare class RingChime {
     private initialData;
     private restClient;
     id: number;
-    deviceType: "chime" | "chime_pro" | "chime_v2" | "chime_pro_v2";
+    deviceType: import("./ring-types").ChimeKind;
     model: string;
     onData: BehaviorSubject<ChimeData>;
     onRequestUpdate: Subject<unknown>;

package/lib/api/ring-chime.js

@@ -23,11 +23,11 @@ class RingChime {
     constructor(initialData, restClient) {
         this.initialData = initialData;
         this.restClient = restClient;
+        this.onRequestUpdate = new rxjs_1.Subject();
         this.id = this.initialData.id;
         this.deviceType = this.initialData.kind;
         this.model = ring_types_1.ChimeModel[this.deviceType] || 'Chime';
         this.onData = new rxjs_1.BehaviorSubject(this.initialData);
-        this.onRequestUpdate = new rxjs_1.Subject();
     }
     updateData(update) {
         this.onData.next(update);

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

@@ -10,6 +10,7 @@ export declare enum RingDeviceType {
     TemperatureSensor = "sensor.temperature",
     WaterSensor = "sensor.water",
     TiltSensor = "sensor.tilt",
+    GlassbreakSensor = "sensor.glassbreak",
     RangeExtender = "range-extender.zwave",
     ZigbeeAdapter = "adapter.zigbee",
     AccessCodeVault = "access-code.vault",
@@ -67,6 +68,7 @@ export declare enum RingCameraKind {
     doorbell_portal = "doorbell_portal",
     doorbell_scallop = "doorbell_scallop",
     doorbell_scallop_lite = "doorbell_scallop_lite",
+    doorbell_graham_cracker = "doorbell_graham_cracker",
     lpd_v1 = "lpd_v1",
     lpd_v2 = "lpd_v2",
     jbox_v1 = "jbox_v1",
@@ -80,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"
@@ -214,7 +217,7 @@ export interface BeamBridge {
     role: string;
     updated_at: string;
 }
-declare type ChimeKind = 'chime' | 'chime_pro' | 'chime_v2' | 'chime_pro_v2';
+export declare type ChimeKind = 'chime' | 'chime_pro' | 'chime_v2' | 'chime_pro_v2';
 export declare const ChimeModel: {
     readonly [P in ChimeKind]: string;
 };
@@ -686,9 +689,20 @@ export interface ActiveDing {
     sip_token: string;
     sip_ding_id: string;
 }
-export interface SnapshotTimestamp {
-    timestamp: number;
-    doorbot_id: number;
+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;

package/lib/api/ring-types.js

@@ -14,6 +14,7 @@ var RingDeviceType;
     RingDeviceType["TemperatureSensor"] = "sensor.temperature";
     RingDeviceType["WaterSensor"] = "sensor.water";
     RingDeviceType["TiltSensor"] = "sensor.tilt";
+    RingDeviceType["GlassbreakSensor"] = "sensor.glassbreak";
     RingDeviceType["RangeExtender"] = "range-extender.zwave";
     RingDeviceType["ZigbeeAdapter"] = "adapter.zigbee";
     RingDeviceType["AccessCodeVault"] = "access-code.vault";
@@ -75,6 +76,7 @@ var RingCameraKind;
     RingCameraKind["doorbell_portal"] = "doorbell_portal";
     RingCameraKind["doorbell_scallop"] = "doorbell_scallop";
     RingCameraKind["doorbell_scallop_lite"] = "doorbell_scallop_lite";
+    RingCameraKind["doorbell_graham_cracker"] = "doorbell_graham_cracker";
     RingCameraKind["lpd_v1"] = "lpd_v1";
     RingCameraKind["lpd_v2"] = "lpd_v2";
     RingCameraKind["jbox_v1"] = "jbox_v1";
@@ -88,12 +90,13 @@ 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";
 })(RingCameraKind = exports.RingCameraKind || (exports.RingCameraKind = {}));
 // RegExp taken from ring.com app
-const isWiredCameraRegExp = new RegExp(/(^(lpd|jbox|stickup_cam_elite|stickup_cam_mini|hp_cam|spotlightw|floodlight))/);
+const isWiredCameraRegExp = new RegExp(/(^(lpd|jbox|stickup_cam_elite|stickup_cam_mini|hp_cam|spotlightw|floodlight|doorbell_graham_cracker))/);
 function isBatteryCameraKind(kind) {
     return !kind.match(isWiredCameraRegExp);
 }
@@ -107,6 +110,7 @@ exports.RingCameraModel = {
     doorbell_portal: 'Door View Cam',
     doorbell_scallop: 'Doorbell 3 Plus',
     doorbell_scallop_lite: 'Doorbell 3',
+    doorbell_graham_cracker: 'Doorbell Wired',
     lpd_v1: 'Doorbell Pro',
     lpd_v2: 'Doorbell Pro',
     jbox_v1: 'Doorbell Elite',
@@ -120,6 +124,7 @@ exports.RingCameraModel = {
     stickup_cam_v4: 'Spotlight Cam',
     floodlight_v1: 'Floodlight Cam',
     floodlight_v2: 'Floodlight Cam',
+    floodlight_pro: 'Floodlight Pro',
     cocoa_camera: 'Stick Up Cam',
     cocoa_doorbell: 'Doorbell Gen 2',
     stickup_cam_mini: 'Indoor Cam',

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

@@ -1,29 +1,26 @@
-/// <reference types="node" />
-import { RtpSplitter, SrtpOptions } from '@homebridge/camera-utils';
-export interface RtpStreamOptions extends SrtpOptions {
+import { DingKind } from './ring-types';
+export interface LiveCallSession {
+    alexa_port: 18443;
+    app_session_token: string;
+    availability_zone: 'availability-zone';
+    custom_timer: {
+        max_sec: number;
+    };
+    ding_id: string;
+    ding_kind: DingKind;
+    doorbot_id: number;
+    exp: number;
+    ip: string;
     port: number;
-    rtcpPort: number;
+    private_ip: string;
+    rms_fqdn: string;
+    rms_version: string;
+    rsp_port: number;
+    rtsp_port: number;
+    session_id: string;
+    sip_port: number;
+    webrtc_port: number;
+    webrtc_url: string;
+    wwr_port: number;
 }
-export interface RtpOptions {
-    audio: RtpStreamOptions;
-    video: RtpStreamOptions;
-}
-export interface RtpStreamDescription extends RtpStreamOptions {
-    ssrc?: number;
-    iceUFrag?: string;
-    icePwd?: string;
-}
-export interface RtpDescription {
-    address: string;
-    audio: RtpStreamDescription;
-    video: RtpStreamDescription;
-}
-export declare function isStunMessage(message: Buffer): boolean;
-export declare function sendStunBindingRequest({ rtpDescription, rtpSplitter, rtcpSplitter, localUfrag, type, }: {
-    rtpSplitter: RtpSplitter;
-    rtcpSplitter: RtpSplitter;
-    rtpDescription: RtpDescription;
-    localUfrag?: string;
-    type: 'video' | 'audio';
-}): void;
-export declare function createStunResponder(rtpSplitter: RtpSplitter): void;
+export declare function parseLiveCallSession(sessionId: string): LiveCallSession;

package/lib/api/rtp-utils.js

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

package/lib/api/util.js

@@ -8,14 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomString = exports.randomInteger = exports.mapAsync = exports.stringify = exports.requestInput = exports.getHardwareId = exports.generateUuid = exports.enableDebug = exports.useLogger = exports.logError = exports.logInfo = exports.logDebug = exports.delay = void 0;
-const debug = require("debug");
+const debug_1 = __importDefault(require("debug"));
 const colors_1 = require("colors");
 const readline_1 = require("readline");
 const uuid_1 = require("uuid");
 const systeminformation_1 = require("systeminformation");
-const debugLogger = debug('ring'), uuidNamespace = 'e53ffdc0-e91d-4ce1-bec2-df939d94739c';
+const debugLogger = (0, debug_1.default)('ring'), uuidNamespace = 'e53ffdc0-e91d-4ce1-bec2-df939d94739c';
 let logger = {
     logInfo(message) {
         debugLogger(message);