ring-client-api 10.0.0-beta.1 → 10.0.0-beta.4

package/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 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.
 
+## [10.0.0-beta.4](https://github.com/dgreif/ring/compare/v10.0.0-beta.3...v10.0.0-beta.4) (2022-04-03)
+
+
+### ⚠ BREAKING CHANGES
+
+* **api:** All ding-related functionality will now use the `PushNotification` type, and the `ActiveDing` type has been removed
+* **api:** The `cameraDingsPollingSeconds` option has been removed.  Ding events will now be received via push notifications (no setup required)
+* **api:** The `treatKnockAsDing` option has been removed.  Knocks should now register as "dings" automatically, though I have not been able to test this functionality
+
+### Features
+
+* **api:** convert ding handling to use notifications ([5b62318](https://github.com/dgreif/ring/commit/5b62318b6a71bcc224a2b29cbd6e21162fc9891e))
+* **api:** update notification types ([15d3e7e](https://github.com/dgreif/ring/commit/15d3e7e40744e2c3ed48140fa94fbc0c6f9d4088))
+* **homebridge:** faster snapshots from camera notifications ([7fc821b](https://github.com/dgreif/ring/commit/7fc821b71013c36314d6d428b8152e631ea4b497))
+* receive dings from push notifications ([c9f130f](https://github.com/dgreif/ring/commit/c9f130f0f1f21b6db2454d611641ef7c29c7e620))
+
+
+### Bug Fixes
+
+* more closely match ring edge live streaming setup flow ([4bb3189](https://github.com/dgreif/ring/commit/4bb3189d6ce6614f7af64d04b410c3922957d555))
+* update uuid namespace to force new client sessions ([bc3e943](https://github.com/dgreif/ring/commit/bc3e9432c41dda085845f72f332dcf480c92475d))
+* use camera health to determine battery and charging status ([fac7033](https://github.com/dgreif/ring/commit/fac70331bdd4dd94bc6caa143eb1bcb9ead06923)), closes [#873](https://github.com/dgreif/ring/issues/873)
+
+## [10.0.0-beta.3](https://github.com/dgreif/ring/compare/v10.0.0-beta.2...v10.0.0-beta.3) (2022-03-26)
+
+
+### Bug Fixes
+
+* separate streaming setup for ring edge vs regular cameras ([6281cf9](https://github.com/dgreif/ring/commit/6281cf966de12dcea8acc6516cd9079634734dec))
+
+## [10.0.0-beta.2](https://github.com/dgreif/ring/compare/v10.0.0-beta.1...v10.0.0-beta.2) (2022-03-26)
+
+
+### Features
+
+* support ring edge camera streaming ([b30d99f](https://github.com/dgreif/ring/commit/b30d99f9ffaa1fabc1d09b830cf8ba0e69fe84a0))
+
+
+### Bug Fixes
+
+* **api:** allow snapshot to be force-updated based on options ([fa0212a](https://github.com/dgreif/ring/commit/fa0212ab539cc268f8000c5b9ea39a00799cb8d7))
+
 ## [10.0.0-beta.1](https://github.com/dgreif/ring/compare/v10.0.0-beta.0...v10.0.0-beta.1) (2022-02-27)
 
 

package/README.md

@@ -27,7 +27,6 @@ const ringApi = new RingApi({
 
   // The following are all optional. See below for details
   cameraStatusPollingSeconds: 20,
-  cameraDingsPollingSeconds: 2,
   locationIds: ['488e4800-fcde-4493-969b-d1a06f683102', '4bbed7a7-06df-4f18-b3af-291c89854d60']
 });
 ```
@@ -37,7 +36,6 @@ const ringApi = new RingApi({
 Option | Default | Explanation
 --- | --- | ---
 `cameraStatusPollingSeconds` | `undefined` (No Polling) | How frequently to poll for updates to your cameras and chimes (in seconds).  Information like light/siren/volume/snooze status do not update in real time and need to be requested periodically.
-`cameraDingsPollingSeconds` | `undefined` (No Polling) | How frequently to poll for new events from your cameras (in seconds).  These include motion and doorbell presses.  Without this option, cameras will not emit any information about motion and doorbell presses.
 `locationModePollingSeconds` | `undefined` (No Polling) | How frequently to poll for location mode updates (in seconds).  This is only useful if you are using location modes to control camera settings and want to keep an up-to-date reference of the current mode for each location.  Polling is automatically disabled for locations equipped with a Ring Alarm.
 `locationIds` | All Locations | Allows you to limit the results to a specific set of locations. This is mainly useful for the [homebridge-ring Plugin](./homebridge), but can also be used if you only care about listening for events at a subset of your locations and don't want to create websocket connections to _all_ of your locations. This will also limit the results for `ringApi.getCameras()` to the configured locations. If this option is not included, all locations will be returned.
 `debug` | false | Turns on additional logging.  In particular, ffmpeg logging.
@@ -45,7 +43,6 @@ 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

package/lib/api/api.d.ts

@@ -1,15 +1,13 @@
 import { RefreshTokenAuth, RingRestClient, SessionOptions } from './rest-client';
 import { Location } from './location';
-import { ActiveDing, BaseStation, BeamBridge, CameraData, ChimeData, ProfileResponse, UserLocation } from './ring-types';
+import { BaseStation, BeamBridge, CameraData, ChimeData, ProfileResponse, UserLocation } from './ring-types';
 import { RingCamera } from './ring-camera';
 import { Subscribed } from './subscribed';
 export interface RingApiOptions extends SessionOptions {
     locationIds?: string[];
     cameraStatusPollingSeconds?: number;
-    cameraDingsPollingSeconds?: number;
     locationModePollingSeconds?: number;
     avoidSnapshotBatteryDrain?: boolean;
-    treatKnockAsDing?: boolean;
     debug?: boolean;
     ffmpegPath?: string;
     externalPorts?: {
@@ -34,8 +32,8 @@ export declare class RingApi extends Subscribed {
         baseStations: BaseStation[];
         beamBridges: BeamBridge[];
     }>;
-    fetchActiveDings(): Promise<ActiveDing[] & import("./rest-client").ExtendedResponse>;
     private listenForDeviceUpdates;
+    registerPushReceiver(cameras: RingCamera[]): Promise<void>;
     fetchRawLocations(): Promise<UserLocation[]>;
     fetchAmazonKeyLocks(): Promise<any[] & import("./rest-client").ExtendedResponse>;
     fetchAndBuildLocations(): Promise<Location[]>;

package/lib/api/api.js

@@ -8,6 +8,9 @@ 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.RingApi = void 0;
 const rest_client_1 = require("./rest-client");
@@ -19,6 +22,7 @@ const operators_1 = require("rxjs/operators");
 const util_1 = require("./util");
 const ffmpeg_1 = require("./ffmpeg");
 const subscribed_1 = require("./subscribed");
+const push_receiver_1 = __importDefault(require("@eneris/push-receiver"));
 class RingApi extends subscribed_1.Subscribed {
     constructor(options) {
         super();
@@ -51,16 +55,13 @@ class RingApi extends subscribed_1.Subscribed {
             };
         });
     }
-    fetchActiveDings() {
-        return this.restClient.request({
-            url: (0, rest_client_1.clientApi)('dings/active'),
-        });
-    }
     listenForDeviceUpdates(cameras, chimes) {
-        const { cameraStatusPollingSeconds, cameraDingsPollingSeconds } = this.options, onCamerasRequestUpdate = (0, rxjs_1.merge)(...cameras.map((camera) => camera.onRequestUpdate)), onChimesRequestUpdate = (0, rxjs_1.merge)(...chimes.map((chime) => chime.onRequestUpdate)), onCamerasRequestActiveDings = (0, rxjs_1.merge)(...cameras.map((camera) => camera.onRequestActiveDings)), onUpdateReceived = new rxjs_1.Subject(), onActiveDingsReceived = new rxjs_1.Subject(), onPollForStatusUpdate = cameraStatusPollingSeconds
+        const { cameraStatusPollingSeconds } = this.options;
+        if (!cameraStatusPollingSeconds) {
+            return;
+        }
+        const onCamerasRequestUpdate = (0, rxjs_1.merge)(...cameras.map((camera) => camera.onRequestUpdate)), onChimesRequestUpdate = (0, rxjs_1.merge)(...chimes.map((chime) => chime.onRequestUpdate)), onUpdateReceived = new rxjs_1.Subject(), onPollForStatusUpdate = cameraStatusPollingSeconds
             ? onUpdateReceived.pipe((0, operators_1.debounceTime)(cameraStatusPollingSeconds * 1000))
-            : rxjs_1.EMPTY, onPollForActiveDings = cameraDingsPollingSeconds
-            ? onActiveDingsReceived.pipe((0, operators_1.debounceTime)(cameraDingsPollingSeconds * 1000))
             : rxjs_1.EMPTY, camerasById = cameras.reduce((byId, camera) => {
             byId[camera.id] = camera;
             return byId;
@@ -94,22 +95,59 @@ class RingApi extends subscribed_1.Subscribed {
         if (cameraStatusPollingSeconds) {
             onUpdateReceived.next(null); // kick off polling
         }
-        this.addSubscriptions((0, rxjs_1.merge)(onCamerasRequestActiveDings, onPollForActiveDings).subscribe(() => __awaiter(this, void 0, void 0, function* () {
-            const activeDings = yield this.fetchActiveDings().catch(() => null);
-            onActiveDingsReceived.next(null);
-            if (!activeDings || !activeDings.length) {
-                return;
-            }
-            activeDings.forEach((activeDing) => {
-                const camera = camerasById[activeDing.doorbot_id];
-                if (camera) {
-                    camera.processActiveDing(activeDing);
+    }
+    registerPushReceiver(cameras) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pushReceiver = new push_receiver_1.default({
+                logLevel: 'NONE',
+                senderId: '876313859327', // for Ring android app.  703521446232 for ring-site
+            }), camerasById = cameras.reduce((byId, camera) => {
+                byId[camera.id] = camera;
+                return byId;
+            }, {});
+            pushReceiver.onCredentialsChanged(({ newCredentials: { fcm: { token }, }, }) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.restClient.request({
+                        url: (0, rest_client_1.clientApi)('device'),
+                        method: 'PATCH',
+                        json: {
+                            device: {
+                                metadata: {
+                                    pn_service: 'fcm',
+                                },
+                                os: 'android',
+                                push_notification_token: token,
+                            },
+                        },
+                    });
+                }
+                catch (e) {
+                    (0, util_1.logError)(e);
+                }
+            }));
+            pushReceiver.onNotification(({ message }) => {
+                var _a;
+                const dataJson = (_a = message.data) === null || _a === void 0 ? void 0 : _a.gcmData;
+                try {
+                    const notification = JSON.parse(dataJson);
+                    if (!notification.ding) {
+                        // We may get notification that are not for a ding/motion, which can be ignored
+                        return;
+                    }
+                    camerasById[notification.ding.doorbot_id].processPushNotification(notification);
+                }
+                catch (e) {
+                    (0, util_1.logError)(e);
                 }
             });
-        })));
-        if (cameras.length && cameraDingsPollingSeconds) {
-            onActiveDingsReceived.next(null); // kick off polling
-        }
+            try {
+                yield pushReceiver.connect();
+            }
+            catch (e) {
+                (0, util_1.logError)('Failed to connect push notification receiver');
+                (0, util_1.logError)(e);
+            }
+        });
     }
     fetchRawLocations() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -129,7 +167,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, this.options.treatKnockAsDing || 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)), 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));
@@ -140,6 +178,9 @@ class RingApi extends subscribed_1.Subscribed {
                 locationModePollingSeconds: this.options.locationModePollingSeconds,
             }, this.restClient));
             this.listenForDeviceUpdates(cameras, ringChimes);
+            this.registerPushReceiver(cameras).catch((e) => {
+                (0, util_1.logError)(e);
+            });
             return locations;
         });
     }

package/lib/api/live-call-ring-edge.d.ts

@@ -0,0 +1,41 @@
+import { ReplaySubject } from 'rxjs';
+import { RingCamera } from './ring-camera';
+import { Subscribed } from './subscribed';
+import { RtpPacket } from '@koush/werift';
+declare type SpawnInput = string | number;
+export interface FfmpegOptions {
+    input?: SpawnInput[];
+    video?: SpawnInput[] | false;
+    audio?: SpawnInput[];
+    output: SpawnInput[];
+}
+export declare class LiveCallRingEdge extends Subscribed {
+    private camera;
+    private readonly ws;
+    private readonly onWsOpen;
+    private readonly onMessage;
+    private readonly pc;
+    readonly onSessionId: ReplaySubject<string>;
+    readonly onCallAnswered: ReplaySubject<string>;
+    readonly onCallEnded: ReplaySubject<void>;
+    private readonly audioSplitter;
+    private readonly videoSplitter;
+    readonly onVideoRtp: import("rxjs").Subject<RtpPacket>;
+    readonly onAudioRtp: import("rxjs").Subject<RtpPacket>;
+    private readonly onOfferSent;
+    constructor(authToken: string, camera: RingCamera);
+    private initiateCall;
+    private sessionId;
+    private handleMessage;
+    reservePort(bufferPorts?: number): Promise<number>;
+    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
+    activated: boolean;
+    activate(): Promise<void>;
+    activateCameraSpeaker(): Promise<void>;
+    private sendSessionMessage;
+    private sendMessage;
+    private callEnded;
+    stop(): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+}
+export {};

package/lib/api/live-call-ring-edge.js

@@ -0,0 +1,294 @@
+"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.LiveCallRingEdge = void 0;
+const ws_1 = require("ws");
+const rxjs_1 = require("rxjs");
+const peer_connection_1 = require("./peer-connection");
+const util_1 = require("./util");
+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=')
+        .slice(1)
+        .map((section) => 'm=' + section)
+        .filter((section) => includeVideo || !section.startsWith('m=video'))
+        .join('\n');
+}
+class LiveCallRingEdge extends subscribed_1.Subscribed {
+    constructor(authToken, camera) {
+        super();
+        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;
+        this.pc = new peer_connection_1.PeerConnection();
+        this.ws = new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
+            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',
+            },
+        });
+        this.onAudioRtp = this.pc.onAudioRtp;
+        this.onVideoRtp = this.pc.onVideoRtp;
+        this.onMessage = (0, rxjs_1.fromEvent)(this.ws, 'message');
+        this.onWsOpen = (0, rxjs_1.fromEvent)(this.ws, 'open');
+        const onError = (0, rxjs_1.fromEvent)(this.ws, 'error'), onClose = (0, rxjs_1.fromEvent)(this.ws, 'close');
+        this.addSubscriptions(this.onMessage
+            .pipe((0, operators_1.concatMap)((message) => {
+            return this.handleMessage(JSON.parse(message.data));
+        }))
+            .subscribe(), this.onWsOpen.subscribe(() => {
+            (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name} (Ring Edge)`);
+            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);
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.body.ice,
+                        sdpMLineIndex: message.body.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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ports = yield (0, camera_utils_1.reservePorts)({ count: bufferPorts + 1 });
+            return ports[0];
+        });
+    }
+    startTranscoding(ffmpegOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const videoPort = yield this.reservePort(1), audioPort = yield this.reservePort(1), transcodeVideoStream = ffmpegOptions.video !== false, ffmpegInputArguments = [
+                '-hide_banner',
+                '-protocol_whitelist',
+                'pipe,udp,rtp,file,crypto',
+                '-acodec',
+                'libopus',
+                '-f',
+                'sdp',
+                ...(ffmpegOptions.input || []),
+                '-i',
+                'pipe:',
+            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
+                .replace(/m=audio \d+/, `m=audio ${audioPort}`)
+                .replace(/m=video \d+/, `m=video ${videoPort}`), 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(),
+                logLabel: `From Ring (${this.camera.name})`,
+                logger: {
+                    error: util_1.logError,
+                    info: util_1.logDebug,
+                },
+            });
+            this.addSubscriptions(this.onAudioRtp
+                .pipe((0, operators_1.concatMap)((rtp) => {
+                return this.audioSplitter.send(rtp.serialize(), {
+                    port: audioPort,
+                });
+            }))
+                .subscribe());
+            if (transcodeVideoStream) {
+                this.addSubscriptions(this.onVideoRtp
+                    .pipe((0, operators_1.concatMap)((rtp) => {
+                    return this.videoSplitter.send(rtp.serialize(), {
+                        port: videoPort,
+                    });
+                }))
+                    .subscribe());
+            }
+            this.onCallEnded.subscribe(() => ff.stop());
+            ff.writeStdin(inputSdp);
+            // Activate the stream now that ffmpeg is ready to receive
+            yield this.activate();
+        });
+    }
+    activate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activated) {
+                return;
+            }
+            this.activated = true;
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            (0, util_1.logInfo)('Activating Session');
+            this.sendSessionMessage('activate_session');
+        });
+    }
+    activateCameraSpeaker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            this.sendSessionMessage('camera_options', {
+                stealth_mode: false,
+            });
+        });
+    }
+    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.ws.close();
+        }
+        catch (_) {
+            // ignore any errors since we are stopping the call
+        }
+        this.unsubscribe();
+        this.onCallEnded.next();
+        this.pc.close();
+        this.audioSplitter.close();
+        this.videoSplitter.close();
+    }
+    stop() {
+        this.callEnded();
+    }
+    sendAudioPacket(rtp) {
+        this.pc.returnAudioTrack.writeRtp(rtp);
+    }
+}
+exports.LiveCallRingEdge = LiveCallRingEdge;

package/lib/api/live-call.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveCall = void 0;
-const rtp_utils_1 = require("./rtp-utils");
 const ws_1 = require("ws");
 const rxjs_1 = require("rxjs");
 const peer_connection_1 = require("./peer-connection");
@@ -27,6 +26,10 @@ 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(sessionId, camera) {
         super();
@@ -37,13 +40,13 @@ class LiveCall extends subscribed_1.Subscribed {
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
         this.activated = false;
-        const liveCallSession = (0, rtp_utils_1.parseLiveCallSession)(sessionId);
+        const liveCallSession = parseLiveCallSession(sessionId);
         this.pc = new peer_connection_1.PeerConnection();
         this.ws = new ws_1.WebSocket(`wss://${liveCallSession.rms_fqdn}:${liveCallSession.webrtc_port}/`, {
             headers: {
                 API_VERSION: '3.1',
                 API_TOKEN: sessionId,
-                CLIENT_INFO: 'Ring/3.48.0;Platform/Android;OS/7.0;Density/2.0;Device/samsung-SM-T710;Locale/en-US;TimeZone/GMT-07:00',
+                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;

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

@@ -1,17 +1,24 @@
 import { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RtcpPacket, RtpPacket } from '@koush/werift';
-import { Subject } from 'rxjs';
+import { ReplaySubject, Subject } from 'rxjs';
 export declare class PeerConnection {
     pc: RTCPeerConnection;
     onAudioRtp: Subject<RtpPacket>;
     onAudioRtcp: Subject<RtcpPacket>;
     onVideoRtp: Subject<RtpPacket>;
     onVideoRtcp: Subject<RtcpPacket>;
+    onIceCandidate: Subject<RTCIceCandidate>;
+    onConnectionState: ReplaySubject<"failed" | "closed" | "connected" | "connecting" | "new" | "disconnected">;
     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;
+    }): Promise<void>;
     addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
     close(): void;
 }

package/lib/api/peer-connection.js

@@ -13,13 +13,24 @@ 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();
         this.onAudioRtcp = new rxjs_1.Subject();
         this.onVideoRtp = new rxjs_1.Subject();
         this.onVideoRtcp = new rxjs_1.Subject();
+        this.onIceCandidate = new rxjs_1.Subject();
+        this.onConnectionState = new rxjs_1.ReplaySubject(1);
         this.returnAudioTrack = new werift_1.MediaStreamTrack({ kind: 'audio' });
         const pc = (this.pc = new werift_1.RTCPeerConnection({
             codecs: {
@@ -41,10 +52,12 @@ class PeerConnection {
                             { type: 'nack', parameter: 'pli' },
                             { type: 'goog-remb' },
                         ],
-                        parameters: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
+                        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', {
@@ -77,6 +90,26 @@ class PeerConnection {
                 setInterval(() => videoTransceiver.receiver.sendRtcpPLI(track.ssrc), 2000);
             });
         });
+        this.pc.onIceCandidate.subscribe((iceCandidate) => {
+            this.onIceCandidate.next(iceCandidate);
+        });
+        pc.iceConnectionStateChange.subscribe(() => {
+            (0, util_1.logInfo)(`iceConnectionStateChange: ${pc.iceConnectionState}`);
+            if (pc.iceConnectionState === 'closed') {
+                this.onConnectionState.next('closed');
+            }
+        });
+        pc.connectionStateChange.subscribe(() => {
+            (0, util_1.logInfo)(`connectionStateChange: ${pc.connectionState}`);
+            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;
+        });
     }
     createAnswer(offer) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -86,6 +119,11 @@ class PeerConnection {
             return answer;
         });
     }
+    acceptAnswer(answer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.pc.setRemoteDescription(answer);
+        });
+    }
     addIceCandidate(candidate) {
         return this.pc.addIceCandidate(candidate);
     }

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

@@ -1,11 +1,12 @@
 /// <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({ health }: Pick<CameraData, 'health'>): number | null;
 export declare function getSearchQueryString(options: CameraEventOptions | (HistoryOptions & {
     accountId: string;
 })): string;
@@ -14,7 +15,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,26 +22,27 @@ 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;
     get isCharging(): boolean;
     get operatingOnBattery(): boolean;
     get isOffline(): boolean;
+    get isRingEdgeEnabled(): boolean;
     get hasInHomeDoorbell(): boolean;
     doorbotUrl(path?: string): string;
     deviceUrl(path?: string): string;
@@ -52,9 +53,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;
@@ -79,14 +80,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,34 +17,19 @@ 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) {
-        return null;
-    }
-    const batteryLevel = typeof batteryLife === 'number'
-        ? batteryLife
-        : Number.parseFloat(batteryLife);
-    if (isNaN(batteryLevel)) {
-        return null;
-    }
-    return batteryLevel;
-}
 function getStartOfToday() {
     return new Date(new Date().toLocaleDateString()).getTime();
 }
 function getEndOfToday() {
     return getStartOfToday() + fullDayMs - 1;
 }
-function getBatteryLevel(data) {
-    const levels = [
-        parseBatteryLife(data.battery_life),
-        parseBatteryLife(data.battery_life_2),
-    ].filter((level) => level !== null);
-    if (!levels.length) {
+function getBatteryLevel({ health }) {
+    if (!health.battery_percentage && !health.battery_present) {
         return null;
     }
-    return Math.min(...levels);
+    return health.battery_percentage || 0;
 }
 exports.getBatteryLevel = getBatteryLevel;
 function getSearchQueryString(options) {
@@ -64,20 +49,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,26 +100,24 @@ 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';
     }
     get isCharging() {
-        return this.initialData.external_connection;
+        return Boolean(this.data.health.ac_power || this.data.health.ext_power_state);
     }
     get operatingOnBattery() {
         return this.hasBattery && this.data.settings.power_mode !== 'wired';
@@ -145,6 +125,9 @@ class RingCamera extends subscribed_1.Subscribed {
     get isOffline() {
         return this.data.alerts.connection === 'offline';
     }
+    get isRingEdgeEnabled() {
+        return this.data.settings.sheila_settings.local_storage_enabled === true;
+    }
     get hasInHomeDoorbell() {
         const { chime_settings } = this.data.settings;
         return (this.isDoorbot &&
@@ -231,6 +214,10 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     startLiveCall() {
         return __awaiter(this, void 0, void 0, function* () {
+            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',
@@ -249,15 +236,15 @@ class RingCamera extends subscribed_1.Subscribed {
         });
     }
     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 = {}) {
@@ -329,17 +316,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'
@@ -359,15 +348,16 @@ 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}?extras=force`,
+                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',
@@ -378,6 +368,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({

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

@@ -87,7 +87,6 @@ export declare enum RingCameraKind {
     cocoa_doorbell = "cocoa_doorbell",
     stickup_cam_mini = "stickup_cam_mini"
 }
-export declare function isBatteryCameraKind(kind: RingCameraKind): boolean;
 export declare const RingCameraModel: {
     readonly [P in RingCameraKind]: string;
 };
@@ -379,6 +378,13 @@ export interface CameraData {
         live_view_disabled?: boolean;
         motion_detection_enabled?: boolean;
         power_mode?: 'battery' | 'wired';
+        sheila_settings: {
+            cv_processing_enabled: boolean | null;
+            local_storage_enabled: boolean | null;
+        };
+        server_settings: {
+            ring_media_server_enabled: boolean;
+        };
     };
     features: {
         motions_enabled: boolean;
@@ -420,6 +426,44 @@ export interface CameraData {
         ends_at?: string;
         seconds_remaining: number;
     };
+    health: {
+        device_type: RingCameraKind;
+        last_update_time: number;
+        connected: boolean;
+        rss_connected: boolean;
+        vod_enabled: boolean;
+        sidewalk_connection: boolean;
+        floodlight_on: boolean;
+        siren_on?: boolean;
+        white_led_on: boolean;
+        night_mode_on: boolean;
+        hatch_open: boolean;
+        packet_loss: number;
+        packet_loss_category: 'good' | string;
+        rssi: number;
+        battery_voltage: number;
+        wifi_is_ring_network: boolean;
+        supported_rpc_commands: string[];
+        ota_status: 'successful' | string;
+        ext_power_state?: 0 | number;
+        pref_run_mode?: 'low_power' | string;
+        run_mode?: 'low_power' | 'full_power' | string;
+        network_connection_value: 'wifi' | string;
+        ac_power: number;
+        battery_present?: boolean;
+        external_connection: boolean;
+        battery_percentage?: number;
+        battery_percentage_category: 'very_good' | 'unknown' | string;
+        firmware_version: string;
+        rssi_category: 'good' | string;
+        battery_voltage_category: 'very_good' | string;
+        second_battery_voltage_category: 'unknown' | string;
+        second_battery_percentage_category: 'unknown' | string;
+        battery_save: boolean;
+        firmware_version_status: 'Up to Date';
+        tx_rate: number;
+        ptz_connected?: 'penguin';
+    };
 }
 export interface CvDetectionType {
     enabled: boolean;
@@ -663,31 +707,44 @@ export interface RingDeviceHistoryEvent {
     body: any;
 }
 export declare type DingState = 'ringing' | 'connected' | 'timed_out' | 'completed';
-export interface ActiveDing {
-    id: number;
-    id_str: string;
-    state: DingState;
-    protocol: 'sip';
-    doorbot_id: number;
-    doorbot_description: string;
-    device_kind: RingCameraKind;
-    motion: boolean;
-    snapshot_url: '';
-    kind: DingKind;
-    sip_server_ip: string;
-    sip_server_port: number;
-    sip_server_tls: boolean;
-    sip_session_id: string;
-    sip_from: string;
-    sip_to: string;
-    audio_jitter_buffer_ms: number;
-    video_jitter_buffer_ms: number;
-    sip_endpoints: null;
-    expires_in: number;
-    now: number;
-    optimization_level: number;
-    sip_token: string;
-    sip_ding_id: string;
+export declare enum NotificationDetectionType {
+    Human = "human",
+    Loitering = "loitering",
+    Motion = "motion",
+    OtherMotion = "other_motion",
+    NotAvailable = "null",
+    StreamBroken = "stream_broken"
+}
+export declare enum PushNotificationAction {
+    Ding = "com.ring.push.HANDLE_NEW_DING",
+    Motion = "com.ring.push.HANDLE_NEW_motion"
+}
+export interface PushNotification {
+    ding: {
+        streaming_protocol: 'ring_media_server';
+        location_id: string;
+        device_name: string;
+        doorbot_id: number;
+        e2ee_enabled: boolean;
+        streaming_data_hash: string;
+        device_kind: RingCameraKind;
+        detection_type: NotificationDetectionType;
+        human_detected?: boolean;
+        id: number;
+        pod_id: number;
+        request_id: string;
+        image_uuid: string;
+        properties: {
+            active_streaming_profile: 'rms';
+            is_sidewalk: boolean;
+        };
+    };
+    aps: {
+        alert: string;
+        sound: string;
+    };
+    subtype: 'motion' | 'ding' | 'human' | string;
+    action: PushNotificationAction | string;
 }
 export interface LiveCallResponse {
     ding_id: string;

package/lib/api/ring-types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWebSocketSupportedAsset = exports.disabledLocationModes = exports.DispatchSignalType = exports.DoorbellType = exports.ChimeModel = exports.deviceTypesWithVolume = exports.allAlarmStates = exports.RingCameraModel = exports.isBatteryCameraKind = exports.RingCameraKind = exports.RingDeviceCategory = exports.RingDeviceType = void 0;
+exports.isWebSocketSupportedAsset = exports.disabledLocationModes = exports.DispatchSignalType = exports.PushNotificationAction = exports.NotificationDetectionType = exports.DoorbellType = exports.ChimeModel = exports.deviceTypesWithVolume = exports.allAlarmStates = exports.RingCameraModel = exports.RingCameraKind = exports.RingDeviceCategory = exports.RingDeviceType = void 0;
 // eslint-disable-next-line no-shadow
 var RingDeviceType;
 (function (RingDeviceType) {
@@ -95,12 +95,6 @@ var RingCameraKind;
     RingCameraKind["cocoa_doorbell"] = "cocoa_doorbell";
     RingCameraKind["stickup_cam_mini"] = "stickup_cam_mini";
 })(RingCameraKind = exports.RingCameraKind || (exports.RingCameraKind = {}));
-// RegExp taken from ring.com app
-const isWiredCameraRegExp = new RegExp(/(^(lpd|jbox|stickup_cam_elite|stickup_cam_mini|hp_cam|spotlightw|floodlight|doorbell_graham_cracker))/);
-function isBatteryCameraKind(kind) {
-    return !kind.match(isWiredCameraRegExp);
-}
-exports.isBatteryCameraKind = isBatteryCameraKind;
 exports.RingCameraModel = {
     doorbot: 'Doorbell',
     doorbell: 'Doorbell',
@@ -158,6 +152,23 @@ var DoorbellType;
     DoorbellType[DoorbellType["None"] = 2] = "None";
 })(DoorbellType = exports.DoorbellType || (exports.DoorbellType = {}));
 // eslint-disable-next-line no-shadow
+var NotificationDetectionType;
+(function (NotificationDetectionType) {
+    // Note, this list may not be complete
+    NotificationDetectionType["Human"] = "human";
+    NotificationDetectionType["Loitering"] = "loitering";
+    NotificationDetectionType["Motion"] = "motion";
+    NotificationDetectionType["OtherMotion"] = "other_motion";
+    NotificationDetectionType["NotAvailable"] = "null";
+    NotificationDetectionType["StreamBroken"] = "stream_broken";
+})(NotificationDetectionType = exports.NotificationDetectionType || (exports.NotificationDetectionType = {}));
+// eslint-disable-next-line no-shadow
+var PushNotificationAction;
+(function (PushNotificationAction) {
+    PushNotificationAction["Ding"] = "com.ring.push.HANDLE_NEW_DING";
+    PushNotificationAction["Motion"] = "com.ring.push.HANDLE_NEW_motion";
+})(PushNotificationAction = exports.PushNotificationAction || (exports.PushNotificationAction = {}));
+// eslint-disable-next-line no-shadow
 var DispatchSignalType;
 (function (DispatchSignalType) {
     DispatchSignalType["Burglar"] = "user-verified-burglar-xa";

package/lib/api/util.js

@@ -18,7 +18,7 @@ const colors_1 = require("colors");
 const readline_1 = require("readline");
 const uuid_1 = require("uuid");
 const systeminformation_1 = require("systeminformation");
-const debugLogger = (0, debug_1.default)('ring'), uuidNamespace = 'e53ffdc0-e91d-4ce1-bec2-df939d94739c';
+const debugLogger = (0, debug_1.default)('ring'), uuidNamespace = 'e53ffdc0-e91d-4ce1-bec2-df939d94739d';
 let logger = {
     logInfo(message) {
         debugLogger(message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ring-client-api",
-  "version": "10.0.0-beta.1",
+  "version": "10.0.0-beta.4",
   "description": "Unofficial API for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/api/index.js",
   "bin": {
@@ -10,7 +10,7 @@
   "scripts": {
     "start": "concurrently -c yellow,blue --kill-others \"npm:hb\" \"npm:watch:ui\"",
     "watch:ui": "npm start --prefix homebridge-ui",
-    "test": "jest && eslint '**/*.ts'",
+    "test": "eslint '**/*.ts'",
     "watch:tests": "jest --watch",
     "lint": "eslint '**/*.ts' --fix",
     "build": "rm -rf lib && tsc --declaration",
@@ -55,6 +55,7 @@
   "author": "dgreif",
   "license": "MIT",
   "dependencies": {
+    "@eneris/push-receiver": "^3.0.1",
     "@homebridge/camera-utils": "2.1.0",
     "@homebridge/plugin-ui-utils": "0.0.19",
     "@koush/werift": "0.14.5-beta7",

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

@@ -1,26 +0,0 @@
-import { DingKind } from './ring-types';
-export interface LiveCallSession {
-    alexa_port: 18443;
-    app_session_token: string;
-    availability_zone: 'availability-zone';
-    custom_timer: {
-        max_sec: number;
-    };
-    ding_id: string;
-    ding_kind: DingKind;
-    doorbot_id: number;
-    exp: number;
-    ip: string;
-    port: number;
-    private_ip: string;
-    rms_fqdn: string;
-    rms_version: string;
-    rsp_port: number;
-    rtsp_port: number;
-    session_id: string;
-    sip_port: number;
-    webrtc_port: number;
-    webrtc_url: string;
-    wwr_port: number;
-}
-export declare function parseLiveCallSession(sessionId: string): LiveCallSession;

package/lib/api/rtp-utils.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseLiveCallSession = void 0;
-function parseLiveCallSession(sessionId) {
-    const encodedSession = sessionId.split('.')[1], buff = Buffer.from(encodedSession, 'base64'), text = buff.toString('ascii');
-    return JSON.parse(text);
-}
-exports.parseLiveCallSession = parseLiveCallSession;

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

@@ -1 +0,0 @@
-export {};

package/lib/test/api/ring-camera.spec.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const api_1 = require("../../api");
-describe('Ring Camera', () => {
-    describe('battery level', () => {
-        it('should handle string battery life', () => {
-            expect((0, api_1.getBatteryLevel)({ battery_life: '49' })).toEqual(49);
-        });
-        it('should handle null battery life', () => {
-            expect((0, api_1.getBatteryLevel)({ battery_life: null })).toEqual(null);
-        });
-        it('should handle right battery only', () => {
-            expect((0, api_1.getBatteryLevel)({ battery_life: null, battery_life_2: 24 })).toEqual(24);
-        });
-        it('should handle left battery only', () => {
-            expect((0, api_1.getBatteryLevel)({ battery_life: 76, battery_life_2: null })).toEqual(76);
-        });
-        it('should handle dual batteries', () => {
-            expect((0, api_1.getBatteryLevel)({ battery_life: '92', battery_life_2: 84 })).toEqual(84);
-            expect((0, api_1.getBatteryLevel)({ battery_life: '92', battery_life_2: 100 })).toEqual(92);
-        });
-    });
-});