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

package/lib/api/live-call.js

@@ -18,17 +18,6 @@ const operators_1 = require("rxjs/operators");
 const subscribed_1 = require("./subscribed");
 const camera_utils_1 = require("@homebridge/camera-utils");
 const ffmpeg_1 = require("./ffmpeg");
-// eslint-disable-next-line no-shadow
-var CloseReasonCode;
-(function (CloseReasonCode) {
-    CloseReasonCode[CloseReasonCode["NormalClose"] = 0] = "NormalClose";
-    // reason: { code: 5, text: '[rsl-apps/webrtc-liveview-server/Session.cpp:429] [Auth] [0xd540]: [rsl-apps/session-manager/Manager.cpp:227] [AppAuth] Unauthorized: invalid or expired token' }
-    // reason: { code: 5, text: 'Authentication failed: -1' }
-    // reason: { code: 5, text: 'Sessions with the provided ID not found' }
-    CloseReasonCode[CloseReasonCode["AuthenticationFailed"] = 5] = "AuthenticationFailed";
-    // reason: { code: 6, text: 'Timeout waiting for ping' }
-    CloseReasonCode[CloseReasonCode["Timeout"] = 6] = "Timeout";
-})(CloseReasonCode || (CloseReasonCode = {}));
 function getCleanSdp(sdp, includeVideo) {
     return sdp
         .split('\nm=')
@@ -37,26 +26,27 @@ function getCleanSdp(sdp, includeVideo) {
         .filter((section) => includeVideo || !section.startsWith('m=video'))
         .join('\n');
 }
+function parseLiveCallSession(sessionId) {
+    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
+    return JSON.parse(text);
+}
 class LiveCall extends subscribed_1.Subscribed {
-    constructor(authToken, camera) {
+    constructor(sessionId, camera) {
         super();
+        this.sessionId = sessionId;
         this.camera = camera;
-        this.onSessionId = new rxjs_1.ReplaySubject(1);
         this.onCallAnswered = new rxjs_1.ReplaySubject(1);
         this.onCallEnded = new rxjs_1.ReplaySubject(1);
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
-        this.onOfferSent = new rxjs_1.ReplaySubject(1);
-        this.sessionId = null;
         this.activated = false;
+        const liveCallSession = parseLiveCallSession(sessionId);
         this.pc = new peer_connection_1.PeerConnection();
-        this.ws = new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
+        this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
             headers: {
-                Authorization: `Bearer ${authToken}`,
-                'X-Sig-API-Version': '4.0',
-                'X-Sig-Client-ID': 'ring_android-aabb123',
-                'X-Sig-Client-Info': 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
-                'X-Sig-Auth-Type': 'ring_oauth',
+                API_VERSION: '3.1',
+                API_TOKEN: sessionId,
+                CLIENT_INFO: 'Ring/3.49.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
             },
         });
         this.onAudioRtp = this.pc.onAudioRtp;
@@ -70,109 +60,28 @@ class LiveCall extends subscribed_1.Subscribed {
         }))
             .subscribe(), this.onWsOpen.subscribe(() => {
             (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
-            this.initiateCall().catch((e) => {
-                (0, util_1.logError)(e);
-                this.callEnded();
-            });
         }), onError.subscribe((e) => {
             (0, util_1.logError)(e);
             this.callEnded();
         }), onClose.subscribe(() => {
             this.callEnded();
-        }), this.onCallAnswered
-            .pipe((0, operators_1.switchMap)(() => (0, rxjs_1.interval)(5000)))
-            .subscribe(() => {
-            if (!this.sessionId) {
-                return;
-            }
-            this.sendSessionMessage('ping');
-        }), this.pc.onIceCandidate.subscribe((iceCandidate) => __awaiter(this, void 0, void 0, function* () {
-            yield (0, rxjs_1.firstValueFrom)(this.onOfferSent);
-            this.sendMessage({
-                method: 'ice',
-                body: {
-                    doorbot_id: this.camera.id,
-                    ice: iceCandidate.candidate,
-                    mlineindex: 0,
-                },
-            });
-            // HACK: send ice candidate with both mline indexes to convince ring edge to connect both audio and video
-            // Without this, only audio will connect unless you connect from the network of the Ring Edge router
-            this.sendMessage({
-                method: 'ice',
-                body: {
-                    doorbot_id: this.camera.id,
-                    ice: iceCandidate.candidate,
-                    mlineindex: 1,
-                },
-            });
-        })), this.pc.onConnectionState.subscribe((state) => {
-            if (state === 'failed') {
-                (0, util_1.logError)('Stream connection failed');
-                this.callEnded();
-            }
-            if (state === 'closed') {
-                (0, util_1.logDebug)('Stream connection closed');
-                this.callEnded();
-            }
         }));
     }
-    initiateCall() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const offer = yield this.pc.createOffer();
-            offer.sdp = offer.sdp.replace('\na=group:BUNDLE 0 1', '');
-            this.sendMessage({
-                method: 'live_view',
-                body: {
-                    doorbot_id: this.camera.id,
-                    stream_options: { audio_enabled: true, video_enabled: true },
-                    sdp: offer.sdp,
-                },
-            });
-            this.onOfferSent.next();
-        });
-    }
     handleMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (message.body.doorbot_id !== this.camera.id) {
-                // ignore messages for other cameras
-                return;
-            }
-            if (['session_created', 'session_started'].includes(message.method) &&
-                'session_id' in message.body &&
-                !this.sessionId) {
-                this.sessionId = message.body.session_id;
-                this.onSessionId.next(this.sessionId);
-            }
-            if (message.body.session_id && message.body.session_id !== this.sessionId) {
-                // ignore messages for other sessions
-                return;
-            }
             switch (message.method) {
-                case 'session_created':
-                case 'session_started':
-                    // session already stored above
-                    return;
                 case 'sdp':
-                    yield this.pc.acceptAnswer(message.body);
-                    this.onCallAnswered.next(message.body.sdp);
+                    const answer = yield this.pc.createAnswer(message);
+                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
+                    this.onCallAnswered.next(message.sdp);
                     return;
                 case 'ice':
                     yield this.pc.addIceCandidate({
-                        candidate: message.body.ice,
-                        sdpMLineIndex: message.body.mlineindex,
+                        candidate: message.ice,
+                        sdpMLineIndex: message.mlineindex,
                     });
                     return;
-                case 'pong':
-                    return;
-                case 'close':
-                    (0, util_1.logError)('Video stream closed');
-                    (0, util_1.logError)(message.body);
-                    this.callEnded();
-                    return;
             }
-            (0, util_1.logError)('UNKNOWN MESSAGE');
-            (0, util_1.logError)(message);
         });
     }
     reservePort(bufferPorts = 0) {
@@ -238,40 +147,31 @@ class LiveCall extends subscribed_1.Subscribed {
             this.activated = true;
             yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
             (0, util_1.logInfo)('Activating Session');
-            this.sendSessionMessage('activate_session');
+            this.sendMessage({ method: 'activate_session' });
+            this.sendMessage({
+                video_enabled: true,
+                audio_enabled: true,
+                method: 'stream_options',
+            });
         });
     }
     activateCameraSpeaker() {
         return __awaiter(this, void 0, void 0, function* () {
             yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendSessionMessage('camera_options', {
+            this.sendMessage({
                 stealth_mode: false,
+                method: 'camera_options',
             });
         });
     }
-    sendSessionMessage(method, body = {}) {
-        const message = {
-            method,
-            body: Object.assign(Object.assign({}, body), { doorbot_id: this.camera.id, session_id: this.sessionId }),
-        };
-        if (this.sessionId) {
-            // Send immediately if we already have a session id
-            // This is needed to send `close` before closing the websocket
-            this.sendMessage(message);
-        }
-        else {
-            (0, rxjs_1.firstValueFrom)(this.onSessionId)
-                .then(() => this.sendMessage(message))
-                .catch((e) => (0, util_1.logError)(e));
-        }
-    }
     sendMessage(message) {
         this.ws.send(JSON.stringify(message));
     }
     callEnded() {
         try {
-            this.sendSessionMessage('close', {
-                reason: { code: CloseReasonCode.NormalClose, text: '' },
+            this.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
             });
             this.ws.close();
         }

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

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

package/lib/api/peer-connection.js

@@ -13,7 +13,16 @@ exports.PeerConnection = void 0;
 const werift_1 = require("@koush/werift");
 const rxjs_1 = require("rxjs");
 const util_1 = require("./util");
-const debug = false;
+const debug = false, ringIceServers = [
+    'stun:stun.kinesisvideo.us-east-1.amazonaws.com:443',
+    'stun:stun.kinesisvideo.us-east-2.amazonaws.com:443',
+    'stun:stun.kinesisvideo.us-west-2.amazonaws.com:443',
+    'stun:stun.l.google.com:19302',
+    'stun:stun1.l.google.com:19302',
+    'stun:stun2.l.google.com:19302',
+    'stun:stun3.l.google.com:19302',
+    'stun:stun4.l.google.com:19302',
+];
 class PeerConnection {
     constructor() {
         this.onAudioRtp = new rxjs_1.Subject();
@@ -43,10 +52,12 @@ class PeerConnection {
                             { type: 'nack', parameter: 'pli' },
                             { type: 'goog-remb' },
                         ],
-                        parameters: 'profile-level-id=42801F',
+                        parameters: 'packetization-mode=1;profile-level-id=640029;level-asymmetry-allowed=1',
                     }),
                 ],
             },
+            iceServers: ringIceServers.map((server) => ({ urls: server })),
+            iceTransportPolicy: 'all',
         })), audioTransceiver = pc.addTransceiver(this.returnAudioTrack, {
             direction: 'sendrecv',
         }), videoTransceiver = pc.addTransceiver('video', {
@@ -100,6 +111,14 @@ class PeerConnection {
             return offer;
         });
     }
+    createAnswer(offer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.pc.setRemoteDescription(offer);
+            const answer = yield this.pc.createAnswer();
+            yield this.pc.setLocalDescription(answer);
+            return answer;
+        });
+    }
     acceptAnswer(answer) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.pc.setRemoteDescription(answer);

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

@@ -1,11 +1,14 @@
 /// <reference types="node" />
-import { ActiveDing, CameraData, CameraDeviceSettingsData, CameraEventOptions, CameraEventResponse, CameraHealth, HistoryOptions, PeriodicFootageResponse, VideoSearchResponse } from './ring-types';
+import { CameraData, CameraDeviceSettingsData, CameraEventOptions, CameraEventResponse, CameraHealth, HistoryOptions, PeriodicFootageResponse, PushNotification, VideoSearchResponse } from './ring-types';
 import { RingRestClient } from './rest-client';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { DeepPartial } from './util';
 import { Subscribed } from './subscribed';
 import { FfmpegOptions, LiveCall } from './live-call';
-export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'>): number | null;
+import { LiveCallRingEdge } from './live-call-ring-edge';
+export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'> & {
+    health?: Partial<CameraData['health']>;
+}): number | null;
 export declare function getSearchQueryString(options: CameraEventOptions | (HistoryOptions & {
     accountId: string;
 })): string;
@@ -14,7 +17,6 @@ export declare class RingCamera extends Subscribed {
     isDoorbot: boolean;
     private restClient;
     private avoidSnapshotBatteryDrain;
-    private treatKnockAsDing;
     id: number;
     deviceType: import("./ring-types").RingCameraKind;
     model: string;
@@ -22,20 +24,20 @@ export declare class RingCamera extends Subscribed {
     hasLight: boolean;
     hasSiren: boolean;
     onRequestUpdate: Subject<unknown>;
-    onRequestActiveDings: Subject<unknown>;
-    onNewDing: Subject<ActiveDing>;
-    onActiveDings: BehaviorSubject<ActiveDing[]>;
-    onDoorbellPressed: import("rxjs").Observable<ActiveDing>;
+    onNewNotification: Subject<PushNotification>;
+    onActiveNotifications: BehaviorSubject<PushNotification[]>;
+    onDoorbellPressed: import("rxjs").Observable<PushNotification>;
     onMotionDetected: import("rxjs").Observable<boolean>;
     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, treatKnockAsDing: boolean);
+    constructor(initialData: CameraData, isDoorbot: boolean, restClient: RingRestClient, avoidSnapshotBatteryDrain: boolean);
     updateData(update: CameraData): void;
     requestUpdate(): void;
     get data(): CameraData;
     get name(): string;
-    get activeDings(): ActiveDing[];
+    get activeNotifications(): PushNotification[];
+    get latestNotification(): PushNotification | undefined;
     get batteryLevel(): number | null;
     get hasBattery(): boolean;
     get hasLowBattery(): boolean;
@@ -53,9 +55,9 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
-    startLiveCall(): Promise<LiveCall>;
+    startLiveCall(): Promise<LiveCall | LiveCallRingEdge>;
     private removeDingById;
-    processActiveDing(ding: ActiveDing): void;
+    processPushNotification(notification: PushNotification): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
     videoSearch({ dateFrom, dateTo, order }?: {
         dateFrom: number;
@@ -80,14 +82,18 @@ export declare class RingCamera extends Subscribed {
     private checkIfSnapshotsAreBlocked;
     private shouldUseExistingSnapshotPromise;
     private fetchingSnapshot;
-    getSnapshot(): Promise<Buffer>;
-    getNextSnapshot({ afterMs, maxWaitMs, force, }: {
+    getSnapshot({ uuid }?: {
+        uuid?: string;
+    }): Promise<Buffer>;
+    getNextSnapshot({ afterMs, maxWaitMs, force, uuid, }: {
         afterMs?: number;
         maxWaitMs?: number;
         force?: boolean;
+        uuid?: string;
     }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
+    getSnapshotByUuid(uuid: string): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     recordToFile(outputPath: string, duration?: number): Promise<void>;
-    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall>;
+    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall | LiveCallRingEdge>;
     subscribeToDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     unsubscribeFromDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     subscribeToMotionEvents(): Promise<void & import("./rest-client").ExtendedResponse>;

package/lib/api/ring-camera.js

@@ -17,6 +17,7 @@ const operators_1 = require("rxjs/operators");
 const util_1 = require("./util");
 const subscribed_1 = require("./subscribed");
 const live_call_1 = require("./live-call");
+const live_call_ring_edge_1 = require("./live-call-ring-edge");
 const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -40,8 +41,9 @@ function getBatteryLevel(data) {
     const levels = [
         parseBatteryLife(data.battery_life),
         parseBatteryLife(data.battery_life_2),
-    ].filter((level) => level !== null);
-    if (!levels.length) {
+    ].filter((level) => level !== null), { health } = data;
+    if (!levels.length ||
+        (health && !health.battery_percentage && !health.battery_present)) {
         return null;
     }
     return Math.min(...levels);
@@ -64,20 +66,17 @@ function getSearchQueryString(options) {
 }
 exports.getSearchQueryString = getSearchQueryString;
 class RingCamera extends subscribed_1.Subscribed {
-    constructor(initialData, isDoorbot, restClient, avoidSnapshotBatteryDrain, treatKnockAsDing) {
+    constructor(initialData, isDoorbot, restClient, avoidSnapshotBatteryDrain) {
         super();
         this.initialData = initialData;
         this.isDoorbot = isDoorbot;
         this.restClient = restClient;
         this.avoidSnapshotBatteryDrain = avoidSnapshotBatteryDrain;
-        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' ||
-            (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.onNewNotification = new rxjs_1.Subject();
+        this.onActiveNotifications = new rxjs_1.BehaviorSubject([]);
+        this.onDoorbellPressed = this.onNewNotification.pipe((0, operators_1.filter)((notification) => notification.action === ring_types_1.PushNotificationAction.Ding), (0, operators_1.share)());
+        this.onMotionDetected = this.onActiveNotifications.pipe((0, operators_1.map)((notifications) => notifications.some((notification) => notification.action === ring_types_1.PushNotificationAction.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;
@@ -118,20 +117,18 @@ class RingCamera extends subscribed_1.Subscribed {
     get name() {
         return this.data.description;
     }
-    get activeDings() {
-        return this.onActiveDings.getValue();
+    get activeNotifications() {
+        return this.onActiveNotifications.getValue();
+    }
+    get latestNotification() {
+        const notifications = this.activeNotifications;
+        return notifications[notifications.length - 1];
     }
     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));
+        return this.batteryLevel !== null;
     }
     get hasLowBattery() {
         return this.data.alerts.battery === 'low';
@@ -234,20 +231,37 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     startLiveCall() {
         return __awaiter(this, void 0, void 0, function* () {
-            const auth = yield this.restClient.getCurrentAuth();
-            return new live_call_1.LiveCall(auth.access_token, this);
+            if (this.isRingEdgeEnabled) {
+                const auth = yield this.restClient.getCurrentAuth();
+                return new live_call_ring_edge_1.LiveCallRingEdge(auth.access_token, this);
+            }
+            const liveCall = yield this.restClient
+                .request({
+                method: 'POST',
+                url: this.doorbotUrl('live_call'),
+            })
+                .catch((e) => {
+                var _a;
+                if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 403) {
+                    const errorMessage = `Camera ${this.name} returned 403 when starting a live stream.  This usually indicates that live streaming is blocked by Modes settings.  Check your Ring app and verify that you are able to stream from this camera with the current Modes settings.`;
+                    (0, util_1.logError)(errorMessage);
+                    throw new Error(errorMessage);
+                }
+                throw e;
+            });
+            return new live_call_1.LiveCall(liveCall.data.session_id, this);
         });
     }
     removeDingById(idToRemove) {
-        const allActiveDings = this.activeDings, otherDings = allActiveDings.filter((ding) => ding.id_str !== idToRemove);
-        this.onActiveDings.next(otherDings);
+        const allActiveDings = this.activeNotifications, otherDings = allActiveDings.filter(({ ding }) => ding.id !== idToRemove);
+        this.onActiveNotifications.next(otherDings);
     }
-    processActiveDing(ding) {
-        const activeDings = this.activeDings, dingId = ding.id_str;
-        this.onActiveDings.next(activeDings.filter((d) => d.id_str !== dingId).concat([ding]));
-        this.onNewDing.next(ding);
+    processPushNotification(notification) {
+        const activeDings = this.activeNotifications, dingId = notification.ding.id;
+        this.onActiveNotifications.next(activeDings.filter((d) => d.ding.id !== dingId).concat([notification]));
+        this.onNewNotification.next(notification);
         setTimeout(() => {
-            this.removeDingById(ding.id_str);
+            this.removeDingById(dingId);
         }, 65 * 1000); // dings last ~1 minute
     }
     getEvents(options = {}) {
@@ -319,17 +333,19 @@ class RingCamera extends subscribed_1.Subscribed {
             return false;
         }
     }
-    getSnapshot() {
+    getSnapshot({ uuid } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.lastSnapshotPromise && this.shouldUseExistingSnapshotPromise()) {
                 return this.lastSnapshotPromise;
             }
             this.checkIfSnapshotsAreBlocked();
             this.lastSnapshotPromise = Promise.race([
-                this.getNextSnapshot({
-                    afterMs: this.lastSnapshotTimestamp,
-                    force: true,
-                }),
+                this.getNextSnapshot(uuid
+                    ? { uuid }
+                    : {
+                        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'
@@ -349,7 +365,7 @@ class RingCamera extends subscribed_1.Subscribed {
             return this.lastSnapshotPromise;
         });
     }
-    getNextSnapshot({ afterMs, maxWaitMs, force, }) {
+    getNextSnapshot({ afterMs, maxWaitMs, force, uuid, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.restClient.request({
                 url: `https://app-snaps.ring.com/snapshots/next/${this.id}`,
@@ -358,6 +374,7 @@ class RingCamera extends subscribed_1.Subscribed {
                     'after-ms': afterMs,
                     'max-wait-ms': maxWaitMs,
                     extras: force ? 'force' : undefined,
+                    uuid,
                 },
                 headers: {
                     accept: 'image/jpeg',
@@ -368,6 +385,15 @@ class RingCamera extends subscribed_1.Subscribed {
             return response;
         });
     }
+    getSnapshotByUuid(uuid) {
+        return this.restClient.request({
+            url: (0, rest_client_1.clientApi)('snapshots/uuid?uuid=' + uuid),
+            responseType: 'buffer',
+            headers: {
+                accept: 'image/jpeg',
+            },
+        });
+    }
     recordToFile(outputPath, duration = 30) {
         return __awaiter(this, void 0, void 0, function* () {
             const liveCall = yield this.streamVideo({