homebridge-ring 9.24.0 → 9.25.0-beta.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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.
 
+## [9.25.0-beta.0](https://github.com/dgreif/ring/compare/v9.24.0...v9.25.0-beta.0) (2022-01-29)
+
+
+### Features
+
+* **api:** decouple ffmpeg prep from execution ([#859](https://github.com/dgreif/ring/issues/859)) ([e3cc9d1](https://github.com/dgreif/ring/commit/e3cc9d15584377bf2be94a9d457efc3dfcb4bd8b))
+* handle new camera types with no battery ([11ae286](https://github.com/dgreif/ring/commit/11ae28697d8cb0e2da71e880c82e1883f04047b9))
+* slightly faster snapshots via new endpoint ([b840471](https://github.com/dgreif/ring/commit/b840471bc6b7b66e5873370251bd57c1a35b267a))
+
 ## [9.24.0](https://github.com/dgreif/ring/compare/v9.23.0...v9.24.0) (2022-01-22)
 
 

package/lib/api/rest-client.d.ts

@@ -6,6 +6,7 @@ export declare function deviceApi(path: string): string;
 export declare function appApi(path: string): string;
 export interface ExtendedResponse {
     responseTimestamp: number;
+    timeMillis: number;
 }
 export interface EmailAuth {
     email: string;

package/lib/api/rest-client.js

@@ -44,8 +44,13 @@ function requestWithRetry(requestOptions) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const options = Object.assign(Object.assign({}, defaultRequestOptions), requestOptions), { headers, body } = (yield (0, got_1.default)(options)), data = body;
-            if (data !== null && typeof data === 'object' && headers.date) {
-                data.responseTimestamp = new Date(headers.date).getTime();
+            if (data !== null && typeof data === 'object') {
+                if (headers.date) {
+                    data.responseTimestamp = new Date(headers.date).getTime();
+                }
+                if (headers['x-time-millis']) {
+                    data.timeMillis = Number(headers['x-time-millis']);
+                }
             }
             return data;
         }

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

@@ -23,7 +23,6 @@ export declare class RingCamera extends Subscribed {
     onData: BehaviorSubject<CameraData>;
     hasLight: boolean;
     hasSiren: boolean;
-    hasBattery: boolean;
     onRequestUpdate: Subject<unknown>;
     onRequestActiveDings: Subject<unknown>;
     onNewDing: Subject<ActiveDing>;
@@ -40,6 +39,7 @@ export declare class RingCamera extends Subscribed {
     get name(): string;
     get activeDings(): ActiveDing[];
     get batteryLevel(): number | null;
+    get hasBattery(): boolean;
     get hasLowBattery(): boolean;
     get isCharging(): boolean;
     get operatingOnBattery(): boolean;
@@ -75,18 +75,21 @@ export declare class RingCamera extends Subscribed {
     }): Promise<string>;
     private isTimestampInLifeTime;
     get snapshotsAreBlocked(): boolean;
-    private getSnapshotTimestamp;
-    private refreshSnapshotInProgress?;
     get snapshotLifeTime(): number;
+    private lastSnapshotTimestamp;
     private lastSnapshotTimestampLocal;
     private lastSnapshotPromise?;
     get currentTimestampAge(): number;
-    get currentTimestampExpiresIn(): number;
     get hasSnapshotWithinLifetime(): boolean;
     private checkIfSnapshotsAreBlocked;
-    private requestSnapshotUpdate;
-    private refreshSnapshot;
-    getSnapshot(): Promise<Buffer | undefined>;
+    private shouldUseExistingSnapshotPromise;
+    private fetchingSnapshot;
+    getSnapshot(): Promise<Buffer>;
+    getNextSnapshot({ afterMs, maxWaitMs, force, }: {
+        afterMs?: number;
+        maxWaitMs?: number;
+        force?: boolean;
+    }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     getSipOptions(): Promise<SipOptions>;
     getUpdatedSipOptions(expiredDingId: string): Promise<SipOptions>;
     createSipSession(options?: {

package/lib/api/ring-camera.js

@@ -18,8 +18,7 @@ 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 maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
         return null;
@@ -83,19 +82,15 @@ class RingCamera extends subscribed_1.Subscribed {
         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;
         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.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);
@@ -131,6 +126,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';
     }
@@ -312,34 +316,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);
     }
@@ -347,79 +331,73 @@ 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;
-                }
-            }
-            catch (e) {
-                this.refreshSnapshotInProgress = undefined;
-                throw e;
+            if (this.lastSnapshotPromise && this.shouldUseExistingSnapshotPromise()) {
+                return this.lastSnapshotPromise;
             }
-            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;
         });
     }
+    getNextSnapshot({ afterMs, maxWaitMs, force, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+        });
+    }
     getSipOptions() {
         return __awaiter(this, void 0, void 0, function* () {
             const activeDings = this.onActiveDings.getValue(), existingDing = activeDings

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

@@ -68,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",
@@ -687,10 +688,6 @@ export interface ActiveDing {
     sip_token: string;
     sip_ding_id: string;
 }
-export interface SnapshotTimestamp {
-    timestamp: number;
-    doorbot_id: number;
-}
 export interface AuthTokenResponse {
     access_token: string;
     expires_in: number;

package/lib/api/ring-types.js

@@ -76,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";
@@ -94,7 +95,7 @@ var RingCameraKind;
     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);
 }
@@ -108,6 +109,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',

package/lib/api/sip-session.d.ts

@@ -27,6 +27,10 @@ export declare class SipSession extends Subscribed {
     constructor(sipOptions: SipOptions, rtpOptions: RtpOptions, audioSplitter: RtpSplitter, audioRtcpSplitter: RtpSplitter, videoSplitter: RtpSplitter, videoRtcpSplitter: RtpSplitter, tlsPort: number, camera: RingCamera);
     createSipCall(sipOptions: SipOptions): SipCall;
     start(ffmpegOptions?: FfmpegOptions): Promise<RtpDescription>;
+    prepareTranscoder(transcodeVideoStream: boolean, ffmpegInputOptions: SpawnInput[] | undefined, remoteRtpOptions: RtpOptions, audioPort: number, videoPort: number, sdpInput: string): {
+        ffmpegInputArguments: SpawnInput[];
+        inputSdpLines: string[];
+    };
     private startTranscoder;
     reservePort(bufferPorts?: number): Promise<number>;
     requestKeyFrame(): Promise<void>;

package/lib/api/sip-session.js

@@ -114,31 +114,17 @@ class SipSession extends subscribed_1.Subscribed {
             }
         });
     }
-    startTranscoder(ffmpegOptions, remoteRtpOptions, audioPort, videoPort) {
-        const transcodeVideoStream = ffmpegOptions.video !== false, ffmpegArgs = [
+    prepareTranscoder(transcodeVideoStream, ffmpegInputOptions, remoteRtpOptions, audioPort, videoPort, sdpInput) {
+        const ffmpegInputArguments = [
             '-hide_banner',
             '-protocol_whitelist',
             'pipe,udp,rtp,file,crypto',
             '-f',
             'sdp',
-            ...(ffmpegOptions.input || []),
+            ...(ffmpegInputOptions || []),
             '-i',
-            'pipe:',
-            ...(ffmpegOptions.audio || ['-acodec', 'aac']),
-            ...(transcodeVideoStream
-                ? ffmpegOptions.video || ['-vcodec', 'copy']
-                : []),
-            ...(ffmpegOptions.output || []),
-        ], ff = new camera_utils_1.FfmpegProcess({
-            ffmpegArgs,
-            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
-            exitCallback: () => this.callEnded(true),
-            logLabel: `From Ring (${this.camera.name})`,
-            logger: {
-                error: util_1.logError,
-                info: util_1.logDebug,
-            },
-        }), inputSdpLines = [
+            sdpInput,
+        ], inputSdpLines = [
             'v=0',
             'o=105202070 3747 461 IN IP4 127.0.0.1',
             's=Talk',
@@ -167,8 +153,6 @@ class SipSession extends subscribed_1.Subscribed {
                 };
             });
         }
-        this.onCallEnded.subscribe(() => ff.stop());
-        ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
         this.audioSplitter.addMessageHandler(({ isRtpMessage, message }) => {
             if ((0, rtp_utils_1.isStunMessage)(message)) {
                 return null;
@@ -177,6 +161,26 @@ class SipSession extends subscribed_1.Subscribed {
                 port: isRtpMessage ? audioPort : audioPort + 1,
             };
         });
+        return {
+            ffmpegInputArguments,
+            inputSdpLines,
+        };
+    }
+    startTranscoder(ffmpegOptions, remoteRtpOptions, audioPort, videoPort) {
+        const transcodeVideoStream = ffmpegOptions.video !== false, { ffmpegInputArguments, inputSdpLines } = this.prepareTranscoder(transcodeVideoStream, ffmpegOptions.input, remoteRtpOptions, audioPort, videoPort, 'pipe:'), 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(true),
+            logLabel: `From Ring (${this.camera.name})`,
+            logger: {
+                error: util_1.logError,
+                info: util_1.logDebug,
+            },
+        });
+        this.onCallEnded.subscribe(() => ff.stop());
+        ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
     }
     reservePort(bufferPorts = 0) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/homebridge/camera-source.js

@@ -99,6 +99,7 @@ class CameraSource {
                 (0, util_1.logDebug)(`Snapshot cached for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
             }
             catch (e) {
+                this.cachedSnapshot = undefined;
                 (0, util_1.logDebug)(`Failed to cache snapshot for ${this.ringCamera.name} (${getDurationSeconds(start)}s), The camera currently reports that it is ${this.ringCamera.isOffline ? 'offline' : 'online'}`);
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-ring",
-  "version": "9.24.0",
+  "version": "9.25.0-beta.0",
   "description": "Homebridge plugin for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/homebridge/index.js",
   "bin": {