ring-client-api 9.22.0 → 9.25.0-beta.0

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 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)
+
+
+### Features
+
+* support glassbreak sensor ([98271f9](https://github.com/dgreif/ring/commit/98271f91f13aaae051fccaab7165cd17f2a2377c))
+
+
+### Bug Fixes
+
+* allow process to exit when RingApi.disconnect() is called ([#851](https://github.com/dgreif/ring/issues/851)) ([8ef25ac](https://github.com/dgreif/ring/commit/8ef25acca66c533873b7fd43c7c899e34b4a7617))
+* avoid error when ring terminates video stream ([7717d5e](https://github.com/dgreif/ring/commit/7717d5eaa40afed3d34f0e8e6eea1402e21afef7)), closes [#853](https://github.com/dgreif/ring/issues/853)
+* update dependencies ([c80d052](https://github.com/dgreif/ring/commit/c80d052f9eaf4c0a50a495166177daa40299ffa7))
+
+## [9.23.0](https://github.com/dgreif/ring/compare/v9.22.1...v9.23.0) (2021-10-17)
+
+
+### Features
+
+* **homebridge:** config option to hide camera lights ([58be17c](https://github.com/dgreif/ring/commit/58be17cfee524bfb158566e59d60438e9b6f0f5d)), closes [#802](https://github.com/dgreif/ring/issues/802)
+* **homebridge:** option to treat "knock" as a ding ([7ece8b2](https://github.com/dgreif/ring/commit/7ece8b25314ef403a6c2bab6a28476a3b7229507)), closes [#514](https://github.com/dgreif/ring/issues/514)
+
+
+### Bug Fixes
+
+* update dependencies ([b685e27](https://github.com/dgreif/ring/commit/b685e27e952a94635a277848821ebfa640d50ee2))
+
+### [9.22.1](https://github.com/dgreif/ring/compare/v9.22.0...v9.22.1) (2021-10-13)
+
+
+### Bug Fixes
+
+* **homebridge:** prevent login attempt for null refresh tokens ([#791](https://github.com/dgreif/ring/issues/791)) ([bbc9db5](https://github.com/dgreif/ring/commit/bbc9db5578f9b3ed2af49256c8581fef5af8e134))
+
 ## [9.22.0](https://github.com/dgreif/ring/compare/v9.21.2...v9.22.0) (2021-10-02)
 
 

package/README.md

@@ -45,6 +45,7 @@ Option | Default | Explanation
 `ffmpegPath` | Uses `ffmpeg-for-homebridge` | A custom path to the `ffmpeg` executable.  By default, the static binaries built in [ffmpeg-for-homebridge](https://github.com/oznu/ffmpeg-for-homebridg) will be used.  If you prefer to use your own version of ffmpeg, you can pass a complete path, or simply `"ffmpeg"` to use ffmpeg from your `PATH`.
 `controlCenterDisplayName` | 'ring-client-api' | This allows you to change the displayed name for the Authorized Device within Control Center in the Ring app
 `avoidSnapshotBatteryDrain` | false | Causes snapshots for battery cameras to be fetched at a minimum 10 minute interval to avoid draining the battery.
+`treatKnockAsDing` | false | Will cause "knock" (`door_activity`) dings to be emitted from `onDoorbellPressed`
 
 ## Locations
 ```typescript
@@ -108,7 +109,7 @@ Camera also includes the following observables:
 * `onDoorbellPressed`: emits a ding every time the doorbell is pressed
 * `onMotionDetected`: `true` or `false` based on `onActiveDings` containing a motion ding
 
-Some other useful propeties
+Some other useful properties
 * `id`
 * `name`: same as `description` from `data`
 * `hasLight`: does this camera have a light

package/lib/api/api.d.ts

@@ -9,6 +9,7 @@ export interface RingApiOptions extends SessionOptions {
     cameraDingsPollingSeconds?: number;
     locationModePollingSeconds?: number;
     avoidSnapshotBatteryDrain?: boolean;
+    treatKnockAsDing?: boolean;
     debug?: boolean;
     ffmpegPath?: string;
     externalPorts?: {

package/lib/api/api.js

@@ -24,7 +24,8 @@ class RingApi extends subscribed_1.Subscribed {
         super();
         this.options = options;
         this.restClient = new rest_client_1.RingRestClient(this.options);
-        this.onRefreshTokenUpdated = this.restClient.onRefreshTokenUpdated.asObservable();
+        this.onRefreshTokenUpdated =
+            this.restClient.onRefreshTokenUpdated.asObservable();
         if (options.debug) {
             (0, util_1.enableDebug)();
         }
@@ -128,7 +129,7 @@ class RingApi extends subscribed_1.Subscribed {
         return __awaiter(this, void 0, void 0, function* () {
             const rawLocations = yield this.fetchRawLocations(), { authorizedDoorbots, chimes, doorbots, allCameras, baseStations, beamBridges, } = yield this.fetchRingDevices(), locationIdsWithHubs = [...baseStations, ...beamBridges].map((x) => x.location_id), cameras = allCameras.map((data) => new ring_camera_1.RingCamera(data, doorbots.includes(data) ||
                 authorizedDoorbots.includes(data) ||
-                data.kind.startsWith('doorbell'), this.restClient, this.options.avoidSnapshotBatteryDrain || false)), ringChimes = chimes.map((data) => new ring_chime_1.RingChime(data, this.restClient)), locations = rawLocations
+                data.kind.startsWith('doorbell'), this.restClient, this.options.avoidSnapshotBatteryDrain || false, this.options.treatKnockAsDing || false)), ringChimes = chimes.map((data) => new ring_chime_1.RingChime(data, this.restClient)), locations = rawLocations
                 .filter((location) => {
                 return (!Array.isArray(this.options.locationIds) ||
                     this.options.locationIds.includes(location.location_id));
@@ -169,6 +170,7 @@ class RingApi extends subscribed_1.Subscribed {
             .catch((e) => {
             (0, util_1.logError)(e);
         });
+        this.restClient.clearTimeouts();
     }
 }
 exports.RingApi = RingApi;

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;
@@ -24,6 +25,7 @@ export declare class RingRestClient {
     refreshToken: string | undefined;
     private hardwareIdPromise;
     private _authPromise;
+    private timeouts;
     private clearPreviousAuth;
     private get authPromise();
     private sessionPromise?;
@@ -44,4 +46,5 @@ export declare class RingRestClient {
         url: string;
     }): Promise<T & ExtendedResponse>;
     getCurrentAuth(): Promise<AuthTokenResponse>;
+    clearTimeouts(): void;
 }

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;
         }
@@ -66,12 +71,15 @@ function requestWithRetry(requestOptions) {
 class RingRestClient {
     constructor(authOptions) {
         this.authOptions = authOptions;
-        // prettier-ignore
-        this.refreshToken = ('refreshToken' in this.authOptions ? this.authOptions.refreshToken : undefined);
-        this.hardwareIdPromise = (0, util_1.getHardwareId)(this.authOptions.systemId);
+        this.timeouts = [];
         this.sessionPromise = undefined;
         this.using2fa = false;
         this.onRefreshTokenUpdated = new rxjs_1.ReplaySubject(1);
+        this.refreshToken =
+            'refreshToken' in this.authOptions
+                ? this.authOptions.refreshToken
+                : undefined;
+        this.hardwareIdPromise = (0, util_1.getHardwareId)(this.authOptions.systemId);
     }
     clearPreviousAuth() {
         this._authPromise = undefined;
@@ -83,11 +91,12 @@ class RingRestClient {
             authPromise
                 .then(({ expires_in }) => {
                 // clear the existing auth promise 1 minute before it expires
-                setTimeout(() => {
+                const timeout = setTimeout(() => {
                     if (this._authPromise === authPromise) {
                         this.clearPreviousAuth();
                     }
                 }, ((expires_in || 3600) - 60) * 1000);
+                this.timeouts.push(timeout);
             })
                 .catch(() => {
                 // ignore these errors here, they should be handled by the function making a rest request
@@ -288,5 +297,8 @@ class RingRestClient {
     getCurrentAuth() {
         return this.authPromise;
     }
+    clearTimeouts() {
+        this.timeouts.forEach(clearTimeout);
+    }
 }
 exports.RingRestClient = RingRestClient;

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

@@ -16,13 +16,13 @@ export declare class RingCamera extends Subscribed {
     isDoorbot: boolean;
     private restClient;
     private avoidSnapshotBatteryDrain;
+    private treatKnockAsDing;
     id: number;
     deviceType: import("./ring-types").RingCameraKind;
     model: string;
     onData: BehaviorSubject<CameraData>;
     hasLight: boolean;
     hasSiren: boolean;
-    hasBattery: boolean;
     onRequestUpdate: Subject<unknown>;
     onRequestActiveDings: Subject<unknown>;
     onNewDing: Subject<ActiveDing>;
@@ -32,13 +32,14 @@ export declare class RingCamera extends Subscribed {
     onMotionStarted: import("rxjs").Observable<null>;
     onBatteryLevel: import("rxjs").Observable<number | null>;
     onInHomeDoorbellStatus: import("rxjs").Observable<boolean>;
-    constructor(initialData: CameraData, isDoorbot: boolean, restClient: RingRestClient, avoidSnapshotBatteryDrain: boolean);
+    constructor(initialData: CameraData, isDoorbot: boolean, restClient: RingRestClient, avoidSnapshotBatteryDrain: boolean, treatKnockAsDing: boolean);
     updateData(update: CameraData): void;
     requestUpdate(): void;
     get data(): CameraData;
     get name(): string;
     get activeDings(): ActiveDing[];
     get batteryLevel(): number | null;
+    get hasBattery(): boolean;
     get hasLowBattery(): boolean;
     get isCharging(): boolean;
     get operatingOnBattery(): boolean;
@@ -74,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;
@@ -66,37 +65,36 @@ function getSearchQueryString(options) {
 }
 exports.getSearchQueryString = getSearchQueryString;
 class RingCamera extends subscribed_1.Subscribed {
-    constructor(initialData, isDoorbot, restClient, avoidSnapshotBatteryDrain) {
+    constructor(initialData, isDoorbot, restClient, avoidSnapshotBatteryDrain, treatKnockAsDing) {
         super();
         this.initialData = initialData;
         this.isDoorbot = isDoorbot;
         this.restClient = restClient;
         this.avoidSnapshotBatteryDrain = avoidSnapshotBatteryDrain;
-        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.treatKnockAsDing = treatKnockAsDing;
         this.onRequestUpdate = new rxjs_1.Subject();
         this.onRequestActiveDings = new rxjs_1.Subject();
         this.onNewDing = new rxjs_1.Subject();
         this.onActiveDings = new rxjs_1.BehaviorSubject([]);
-        this.onDoorbellPressed = this.onNewDing.pipe((0, operators_1.filter)((ding) => ding.kind === 'ding'), (0, operators_1.share)());
+        this.onDoorbellPressed = this.onNewDing.pipe((0, operators_1.filter)((ding) => ding.kind === 'ding' ||
+            (this.treatKnockAsDing && ding.kind === 'door_activity')), (0, operators_1.share)());
         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;
+        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');
@@ -128,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';
     }
@@ -309,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);
     }
@@ -344,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-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",
@@ -214,7 +216,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,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

@@ -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";
@@ -93,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);
 }
@@ -107,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

@@ -32,8 +32,8 @@ class SipSession extends subscribed_1.Subscribed {
         this.hasStarted = false;
         this.hasCallEnded = false;
         this.onCallEndedSubject = new rxjs_1.ReplaySubject(1);
-        this.sipCall = this.createSipCall(this.sipOptions);
         this.onCallEnded = this.onCallEndedSubject.asObservable();
+        this.sipCall = this.createSipCall(this.sipOptions);
     }
     createSipCall(sipOptions) {
         if (this.sipCall) {
@@ -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/api/sip.d.ts

@@ -19,6 +19,7 @@ export function create(options: any, callback: any): {
     isFlowUri: (uri: any) => boolean;
     hostname: () => any;
     destroy: () => void;
+    makeResponse: typeof makeResponse;
 };
 export function start(options: any, callback: any): void;
 export function parseAOR(data: any): any;

package/lib/api/sip.js

@@ -1300,6 +1300,7 @@ exports.create = function (options, callback) {
             transaction.destroy();
             transport.destroy();
         },
+        makeResponse,
     };
 };
 exports.start = function (options, callback) {

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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "9.22.0",
+  "version": "9.25.0-beta.0",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/api/index.js",
   "bin": {
@@ -57,38 +57,38 @@
     "@homebridge/plugin-ui-utils": "0.0.19",
     "@types/socket.io-client": "1.4.36",
     "colors": "1.4.0",
-    "debug": "4.3.2",
-    "got": "11.8.2",
-    "rxjs": "7.3.1",
+    "debug": "4.3.3",
+    "got": "11.8.3",
+    "rxjs": "7.5.2",
     "sdp": "3.0.3",
     "socket.io-client": "2.4.0",
     "stun": "2.1.0",
-    "systeminformation": "5.9.4",
+    "systeminformation": "5.10.7",
     "uuid": "8.3.2"
   },
   "devDependencies": {
     "@types/debug": "4.1.7",
-    "@types/jest": "27.0.2",
-    "@types/node": "16.10.2",
-    "@types/uuid": "8.3.1",
-    "@typescript-eslint/eslint-plugin": "4.32.0",
-    "@typescript-eslint/parser": "4.32.0",
-    "concurrently": "^6.2.2",
+    "@types/jest": "27.4.0",
+    "@types/node": "17.0.10",
+    "@types/uuid": "8.3.4",
+    "@typescript-eslint/eslint-plugin": "5.10.0",
+    "@typescript-eslint/parser": "5.10.0",
+    "concurrently": "^7.0.0",
     "conventional-github-releaser": "3.1.5",
-    "dotenv": "10.0.0",
-    "eslint": "7.32.0",
+    "dotenv": "14.2.0",
+    "eslint": "8.7.0",
     "eslint-config-prettier": "8.3.0",
-    "eslint-plugin-jest": "24.5.0",
+    "eslint-plugin-jest": "25.7.0",
     "eslint-plugin-prettier": "4.0.0",
-    "express": "4.17.1",
-    "homebridge": "1.3.4",
-    "jest": "27.2.4",
-    "prettier": "2.4.1",
+    "express": "4.17.2",
+    "homebridge": "1.4.0",
+    "jest": "27.4.7",
+    "prettier": "2.5.1",
     "reflect-metadata": "0.1.13",
     "rimraf": "3.0.2",
-    "standard-version": "9.3.1",
-    "ts-jest": "27.0.5",
-    "typescript": "4.4.3"
+    "standard-version": "9.3.2",
+    "ts-jest": "27.1.3",
+    "typescript": "4.5.5"
   },
   "engines": {
     "node": "^10 || ^12.20 || ^14 || ^16",