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

package/lib/api/ring-camera.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RingCamera = exports.getSearchQueryString = exports.getBatteryLevel = void 0;
 const ring_types_1 = require("./ring-types");
@@ -92,7 +83,7 @@ class RingCamera extends subscribed_1.Subscribed {
         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);
+            return Boolean(chime_settings?.enable);
         }), (0, operators_1.distinctUntilChanged)());
         if (!initialData.subscribed) {
             this.subscribeToDingEvents().catch((e) => {
@@ -159,53 +150,45 @@ class RingCamera extends subscribed_1.Subscribed {
     deviceUrl(path = '') {
         return (0, rest_client_1.deviceApi)(`devices/${this.id}/${path}`);
     }
-    setLight(on) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasLight) {
-                return false;
-            }
-            const state = on ? 'on' : 'off';
-            yield this.restClient.request({
-                method: 'PUT',
-                url: this.doorbotUrl('floodlight_light_' + state),
-            });
-            this.updateData(Object.assign(Object.assign({}, this.data), { led_status: state }));
-            return true;
+    async setLight(on) {
+        if (!this.hasLight) {
+            return false;
+        }
+        const state = on ? 'on' : 'off';
+        await this.restClient.request({
+            method: 'PUT',
+            url: this.doorbotUrl('floodlight_light_' + state),
         });
+        this.updateData({ ...this.data, led_status: state });
+        return true;
     }
-    setSiren(on) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasSiren) {
-                return false;
-            }
-            yield this.restClient.request({
-                method: 'PUT',
-                url: this.doorbotUrl('siren_' + (on ? 'on' : 'off')),
-            });
-            this.updateData(Object.assign(Object.assign({}, this.data), { siren_status: { seconds_remaining: 1 } }));
-            return true;
+    async setSiren(on) {
+        if (!this.hasSiren) {
+            return false;
+        }
+        await this.restClient.request({
+            method: 'PUT',
+            url: this.doorbotUrl('siren_' + (on ? 'on' : 'off')),
         });
-    }
-    setSettings(settings) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.restClient.request({
-                method: 'PUT',
-                url: this.doorbotUrl(),
-                json: { doorbot: { settings } },
-            });
-            this.requestUpdate();
+        this.updateData({ ...this.data, siren_status: { seconds_remaining: 1 } });
+        return true;
+    }
+    async setSettings(settings) {
+        await this.restClient.request({
+            method: 'PUT',
+            url: this.doorbotUrl(),
+            json: { doorbot: { settings } },
         });
+        this.requestUpdate();
     }
-    setDeviceSettings(settings) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.restClient.request({
-                method: 'PATCH',
-                url: this.deviceUrl('settings'),
-                json: settings,
-            });
-            this.requestUpdate();
-            return response;
+    async setDeviceSettings(settings) {
+        const response = await this.restClient.request({
+            method: 'PATCH',
+            url: this.deviceUrl('settings'),
+            json: settings,
         });
+        this.requestUpdate();
+        return response;
     }
     getDeviceSettings() {
         return this.restClient.request({
@@ -214,51 +197,42 @@ class RingCamera extends subscribed_1.Subscribed {
         });
     }
     // Enable or disable the in-home doorbell (if digital or mechanical)
-    setInHomeDoorbell(enable) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasInHomeDoorbell) {
-                return false;
-            }
-            yield this.setSettings({ chime_settings: { enable } });
-            return true;
-        });
+    async setInHomeDoorbell(enable) {
+        if (!this.hasInHomeDoorbell) {
+            return false;
+        }
+        await this.setSettings({ chime_settings: { enable } });
+        return true;
     }
-    getHealth() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.restClient.request({
-                url: this.doorbotUrl('health'),
-            });
-            return response.device_health;
+    async getHealth() {
+        const response = await this.restClient.request({
+            url: this.doorbotUrl('health'),
         });
+        return response.device_health;
     }
-    createStreamingConnection(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isRingEdgeEnabled) {
-                const auth = yield this.restClient.getCurrentAuth();
-                return new ring_edge_connection_1.RingEdgeConnection(auth.access_token, this, options);
+    async createStreamingConnection(options) {
+        if (this.isRingEdgeEnabled) {
+            const auth = await this.restClient.getCurrentAuth();
+            return new ring_edge_connection_1.RingEdgeConnection(auth.access_token, this, options);
+        }
+        const liveCall = await this.restClient
+            .request({
+            method: 'POST',
+            url: this.doorbotUrl('live_call'),
+        })
+            .catch((e) => {
+            if (e.response?.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);
             }
-            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 webrtc_connection_1.WebrtcConnection(liveCall.data.session_id, this, options);
+            throw e;
         });
+        return new webrtc_connection_1.WebrtcConnection(liveCall.data.session_id, this, options);
     }
-    startLiveCall(options = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connection = yield this.createStreamingConnection(options);
-            return new streaming_session_1.StreamingSession(this, connection);
-        });
+    async startLiveCall(options = {}) {
+        const connection = await this.createStreamingConnection(options);
+        return new streaming_session_1.StreamingSession(this, connection);
     }
     removeDingById(idToRemove) {
         const allActiveDings = this.activeNotifications, otherDings = allActiveDings.filter(({ ding }) => ding.id !== idToRemove);
@@ -294,13 +268,11 @@ class RingCamera extends subscribed_1.Subscribed {
             url: `https://api.ring.com/recordings/public/footages/${this.id}?start_at_ms=${startAtMs}&end_at_ms=${endAtMs}&kinds=online_periodical&kinds=offline_periodical`,
         });
     }
-    getRecordingUrl(dingIdStr, { transcoded = false } = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = transcoded ? 'recording' : 'share/play', response = yield this.restClient.request({
-                url: (0, rest_client_1.clientApi)(`dings/${dingIdStr}/${path}?disable_redirect=true`),
-            });
-            return response.url;
+    async getRecordingUrl(dingIdStr, { transcoded = false } = {}) {
+        const path = transcoded ? 'recording' : 'share/play', response = await this.restClient.request({
+            url: (0, rest_client_1.clientApi)(`dings/${dingIdStr}/${path}?disable_redirect=true`),
         });
+        return response.url;
     }
     isTimestampInLifeTime(timestampAge) {
         return timestampAge < this.snapshotLifeTime;
@@ -341,57 +313,53 @@ class RingCamera extends subscribed_1.Subscribed {
             return false;
         }
     }
-    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(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'
-                        : '';
-                    throw new Error(`Snapshot for ${this.name} (${this.deviceType} - ${this.model}) failed to refresh after ${maxSnapshotRefreshSeconds} seconds${extraMessageForBatteryCam}`);
-                }),
-            ]);
-            try {
-                yield this.lastSnapshotPromise;
-            }
-            catch (e) {
-                // snapshot request failed, don't use it again
-                this.lastSnapshotPromise = undefined;
-                throw e;
-            }
-            this.fetchingSnapshot = false;
+    async getSnapshot({ uuid } = {}) {
+        if (this.lastSnapshotPromise && this.shouldUseExistingSnapshotPromise()) {
             return this.lastSnapshotPromise;
-        });
+        }
+        this.checkIfSnapshotsAreBlocked();
+        this.lastSnapshotPromise = Promise.race([
+            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'
+                    : '';
+                throw new Error(`Snapshot for ${this.name} (${this.deviceType} - ${this.model}) failed to refresh after ${maxSnapshotRefreshSeconds} seconds${extraMessageForBatteryCam}`);
+            }),
+        ]);
+        try {
+            await this.lastSnapshotPromise;
+        }
+        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, 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}`,
-                responseType: 'buffer',
-                searchParams: {
-                    'after-ms': afterMs,
-                    'max-wait-ms': maxWaitMs,
-                    extras: force ? 'force' : undefined,
-                    uuid,
-                },
-                headers: {
-                    accept: 'image/jpeg',
-                },
-            }), { responseTimestamp, timeMillis } = response, timestampAge = Math.abs(responseTimestamp - timeMillis);
-            this.lastSnapshotTimestamp = timeMillis;
-            this.lastSnapshotTimestampLocal = Date.now() - timestampAge;
-            return response;
-        });
+    async getNextSnapshot({ afterMs, maxWaitMs, force, uuid, }) {
+        const response = await this.restClient.request({
+            url: `https://app-snaps.ring.com/snapshots/next/${this.id}`,
+            responseType: 'buffer',
+            searchParams: {
+                'after-ms': afterMs,
+                'max-wait-ms': maxWaitMs,
+                extras: force ? 'force' : undefined,
+                uuid,
+            },
+            headers: {
+                accept: 'image/jpeg',
+            },
+        }), { responseTimestamp, timeMillis } = response, timestampAge = Math.abs(responseTimestamp - timeMillis);
+        this.lastSnapshotTimestamp = timeMillis;
+        this.lastSnapshotTimestampLocal = Date.now() - timestampAge;
+        return response;
     }
     getSnapshotByUuid(uuid) {
         return this.restClient.request({
@@ -402,20 +370,16 @@ class RingCamera extends subscribed_1.Subscribed {
             },
         });
     }
-    recordToFile(outputPath, duration = 30) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const liveCall = yield this.streamVideo({
-                output: ['-t', duration.toString(), outputPath],
-            });
-            yield (0, rxjs_1.firstValueFrom)(liveCall.onCallEnded);
+    async recordToFile(outputPath, duration = 30) {
+        const liveCall = await this.streamVideo({
+            output: ['-t', duration.toString(), outputPath],
         });
+        await (0, rxjs_1.firstValueFrom)(liveCall.onCallEnded);
     }
-    streamVideo(ffmpegOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const liveCall = yield this.startLiveCall();
-            yield liveCall.startTranscoding(ffmpegOptions);
-            return liveCall;
-        });
+    async streamVideo(ffmpegOptions) {
+        const liveCall = await this.startLiveCall();
+        await liveCall.startTranscoding(ffmpegOptions);
+        return liveCall;
     }
     /**
      * Returns a SimpleWebRtcSession, which can be initiated with an sdp offer.

package/lib/api/ring-chime.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RingChime = void 0;
 const ring_types_1 = require("./ring-types");
@@ -52,16 +43,14 @@ class RingChime {
             url: (0, rest_client_1.clientApi)('ringtones'),
         });
     }
-    getRingtoneByDescription(description, kind) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ringtones = yield this.getRingtones(), requestedRingtone = ringtones.audios.find((audio) => audio.available &&
-                audio.description === description &&
-                audio.kind === kind);
-            if (!requestedRingtone) {
-                throw new Error('Requested ringtone not found');
-            }
-            return requestedRingtone;
-        });
+    async getRingtoneByDescription(description, kind) {
+        const ringtones = await this.getRingtones(), requestedRingtone = ringtones.audios.find((audio) => audio.available &&
+            audio.description === description &&
+            audio.kind === kind);
+        if (!requestedRingtone) {
+            throw new Error('Requested ringtone not found');
+        }
+        return requestedRingtone;
     }
     chimeUrl(path = '') {
         return (0, rest_client_1.clientApi)(`chimes/${this.id}/${path}`);
@@ -73,37 +62,31 @@ class RingChime {
             json: { kind },
         });
     }
-    snooze(time) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // time is in minutes, max 24 * 60 (1440)
-            yield this.restClient.request({
-                url: this.chimeUrl('do_not_disturb'),
-                method: 'POST',
-                json: { time },
-            });
-            this.requestUpdate();
+    async snooze(time) {
+        // time is in minutes, max 24 * 60 (1440)
+        await this.restClient.request({
+            url: this.chimeUrl('do_not_disturb'),
+            method: 'POST',
+            json: { time },
         });
+        this.requestUpdate();
     }
-    clearSnooze() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.restClient.request({
-                url: this.chimeUrl('do_not_disturb'),
-                method: 'POST',
-            });
-            this.requestUpdate();
+    async clearSnooze() {
+        await this.restClient.request({
+            url: this.chimeUrl('do_not_disturb'),
+            method: 'POST',
         });
+        this.requestUpdate();
     }
-    updateChime(update) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.restClient.request({
-                url: this.chimeUrl(),
-                method: 'PUT',
-                json: { chime: update },
-            });
-            this.requestUpdate();
-            // inform caller if this change requires a reboot
-            return Object.keys(update.settings || {}).some((key) => settingsWhichRequireReboot.includes(key));
+    async updateChime(update) {
+        await this.restClient.request({
+            url: this.chimeUrl(),
+            method: 'PUT',
+            json: { chime: update },
         });
+        this.requestUpdate();
+        // inform caller if this change requires a reboot
+        return Object.keys(update.settings || {}).some((key) => settingsWhichRequireReboot.includes(key));
     }
     setVolume(volume) {
         if (volume < 0 || volume > 11) {
@@ -115,13 +98,11 @@ class RingChime {
             },
         });
     }
-    getHealth() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.restClient.request({
-                url: (0, rest_client_1.clientApi)(`chimes/${this.id}/health`),
-            });
-            return response.device_health;
+    async getHealth() {
+        const response = await this.restClient.request({
+            url: (0, rest_client_1.clientApi)(`chimes/${this.id}/health`),
         });
+        return response.device_health;
     }
 }
 exports.RingChime = RingChime;

package/lib/api/ring-device.js

@@ -50,7 +50,10 @@ class RingDevice extends subscribed_1.Subscribed {
             datatype: 'DeviceInfoSetType',
             dst: this.assetId,
             body: [
-                Object.assign({ zid: this.zid }, body),
+                {
+                    zid: this.zid,
+                    ...body,
+                },
             ],
         });
     }

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

@@ -1,4 +1,4 @@
-import { ConnectionState, MediaStreamTrack, RTCIceCandidate, RtcpPacket, RtpPacket } from '@koush/werift';
+import { ConnectionState, MediaStreamTrack, RTCIceCandidate, RtcpPacket, RtpPacket } from 'werift';
 import { Observable, ReplaySubject, Subject } from 'rxjs';
 export interface BasicPeerConnection {
     createOffer(): Promise<{
@@ -27,11 +27,11 @@ export declare class WeriftPeerConnection implements BasicPeerConnection {
     onConnectionState: ReplaySubject<"failed" | "closed" | "connected" | "connecting" | "new" | "disconnected">;
     returnAudioTrack: MediaStreamTrack;
     constructor();
-    createOffer(): Promise<import("@koush/werift").RTCSessionDescription>;
+    createOffer(): Promise<import("werift").RTCSessionDescription>;
     createAnswer(offer: {
         type: 'offer';
         sdp: string;
-    }): Promise<import("@koush/werift").RTCSessionDescription>;
+    }): Promise<import("werift").RTCSessionDescription>;
     acceptAnswer(answer: {
         type: 'answer';
         sdp: string;

package/lib/api/streaming/peer-connection.js

@@ -1,16 +1,7 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WeriftPeerConnection = void 0;
-const werift_1 = require("@koush/werift");
+const werift_1 = require("werift");
 const rxjs_1 = require("rxjs");
 const util_1 = require("../util");
 const debug = false, ringIceServers = [
@@ -40,6 +31,12 @@ class WeriftPeerConnection {
                         clockRate: 48000,
                         channels: 2,
                     }),
+                    new werift_1.RTCRtpCodecParameters({
+                        mimeType: 'audio/PCMU',
+                        clockRate: 8000,
+                        channels: 1,
+                        payloadType: 0,
+                    }),
                 ],
                 video: [
                     new werift_1.RTCRtpCodecParameters({
@@ -104,25 +101,19 @@ class WeriftPeerConnection {
             this.onConnectionState.next(pc.connectionState);
         });
     }
-    createOffer() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const offer = yield this.pc.createOffer();
-            yield this.pc.setLocalDescription(offer);
-            return offer;
-        });
+    async createOffer() {
+        const offer = await this.pc.createOffer();
+        await this.pc.setLocalDescription(offer);
+        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;
-        });
+    async createAnswer(offer) {
+        await this.pc.setRemoteDescription(offer);
+        const answer = await this.pc.createAnswer();
+        await this.pc.setLocalDescription(answer);
+        return answer;
     }
-    acceptAnswer(answer) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.pc.setRemoteDescription(answer);
-        });
+    async acceptAnswer(answer) {
+        await this.pc.setRemoteDescription(answer);
     }
     addIceCandidate(candidate) {
         return this.pc.addIceCandidate(candidate);