homebridge-ring 10.0.0-beta.3 → 10.0.0-beta.6

package/CHANGELOG.md

@@ -2,6 +2,52 @@
 
 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.6](https://github.com/dgreif/ring/compare/v10.0.0-beta.5...v10.0.0-beta.6) (2022-05-06)
+
+
+### Features
+
+* **api:** allow custom peer connections for streaming ([3e9e784](https://github.com/dgreif/ring/commit/3e9e78458afe2849a8c414a6b50eec8718bf77cc))
+
+
+### Bug Fixes
+
+* update dependencies ([4b25595](https://github.com/dgreif/ring/commit/4b255950bcfbf94486192d55cfc90d966cd79d24))
+
+## [10.0.0-beta.5](https://github.com/dgreif/ring/compare/v10.0.0-beta.4...v10.0.0-beta.5) (2022-04-10)
+
+
+### Bug Fixes
+
+* **cameras:** wait to activate session until connected ([9a49389](https://github.com/dgreif/ring/commit/9a49389aa434cc5df4cfb4ba039bad0f2a30f756))
+* handle push notification for unknown camera ([cc8fc2a](https://github.com/dgreif/ring/commit/cc8fc2a6377084515d3b169a85644b2a2b13235e))
+* hide ECONNRESET errors from push receiver ([1196d96](https://github.com/dgreif/ring/commit/1196d96e67e26952f18dfbe75103419a7261bd1e))
+* restore dual battery level calculations ([26fa84d](https://github.com/dgreif/ring/commit/26fa84dbd4bbcea8208fd0ade81c54c407aabf63))
+* update dependencies ([4b97fb3](https://github.com/dgreif/ring/commit/4b97fb33623248147997944bab3de4ea3c2e5ee2))
+
+## [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)
 
 

package/README.md

@@ -68,7 +68,6 @@ Only include an optional parameter if you actually need it.  Default behavior wi
   "avoidSnapshotBatteryDrain": true,
   "treatKnockAsDing": true,
   "cameraStatusPollingSeconds": 20,
-  "cameraDingsPollingSeconds": 2,
   "locationModePollingSeconds": 20,
   "locationIds": ["488e4800-fcde-4493-969b-d1a06f683102", "4bbed7a7-06df-4f18-b3af-291c89854d60"]
 }
@@ -92,9 +91,7 @@ Option | Default | Explanation
 `showPanicButtons` | `false` | Creates a new `Panic Buttons` device in HomeKit with `Burglar Alarm` and `Fire Alarm` switches.  **Use these at your own risk.  I do not guarantee functionality in case of emergency, nor do I take responsibility for any false alarms**.  These function just like the SOS sliders in the Ring app.
 `nightModeBypassFor` | no Night Mode | Allows you to use Night mode to "Bypass and Arm" a Ring Alarm.  Can be set to `all` for Away or `some` for Home.  If set and Night mode is activated from HomeKit, any open contact sensors will automatically be bypassed.
 `avoidSnapshotBatteryDrain` | false | Causes snapshots for battery cameras to be fetched at a minimum 10 minute interval to avoid draining the battery.
-`treatKnockAsDing` | false | When someone knocks on your door, it will be recognized as a doorbell press in HomeKit.  Limited to select camera models (Peephole Cam).
 `cameraStatusPollingSeconds` | `20` | 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` | `2` | How frequently to poll for new events from your cameras.  These include motion and doorbell presses.
 `locationModePollingSeconds` | `20` | 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.  Will hide Location Mode switch if set to `0`
 `locationIds` | All Locations | Use this option if you only want a subset of your locations to appear in HomeKit. If this option is not included, all of your locations will be added to HomeKit (which is what most users will want to do).
 `onlyDeviceTypes` | All Device Types | A subset of device types to be shown.  If set, all other device types will be hidden in HomeKit.

package/config.schema.json

@@ -86,11 +86,6 @@
         "type": "boolean",
         "description": "Causes snapshots for battery cameras to be fetched at a minimum 10 minute interval to avoid draining the battery.  This is useful if have the Home app open constantly, causing frequent snapshot requests."
       },
-      "treatKnockAsDing": {
-        "title": "Treat Knock as Ding",
-        "type": "boolean",
-        "description": "When someone knocks on your door, it will be recognized as a doorbell press in HomeKit.  Limited to select camera models (Peephole Cam)"
-      },
       "sendCameraMotionNotificationsToTv": {
         "title": "Create a 'Doorbell' accessory triggered by non-doorbell camera motion alerts for tvOS 14 notification support",
         "type": "boolean"
@@ -118,13 +113,6 @@
         "placeholder": "Get camera status every __ seconds",
         "description": "Camera/Chime status (such as light/siren/volume/snooze state) does not update live and must be fetched periodically.  By default this is done every 20 seconds"
       },
-      "cameraDingsPollingSeconds": {
-        "title": "Camera Event Polling",
-        "type": "integer",
-        "minimum": 1,
-        "placeholder": "Get camera events every __ seconds",
-        "description": "Camera motion and ding events does not update live and must be fetched periodically.  By default this is done every 2 seconds"
-      },
       "locationModePollingSeconds": {
         "title": "Location Mode Polling",
         "type": "integer",
@@ -179,13 +167,11 @@
         "showPanicButtons",
         "nightModeBypassFor",
         "avoidSnapshotBatteryDrain",
-        "treatKnockAsDing",
         "sendCameraMotionNotificationsToTv",
         "sendDoorbellMotionNotificationsToTv",
         "beamDurationSeconds",
         "debug",
         "cameraStatusPollingSeconds",
-        "cameraDingsPollingSeconds",
         "locationModePollingSeconds",
         {
           "key": "hideDeviceIds",

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, _b;
+                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;
+                    }
+                    (_b = camerasById[notification.ding.doorbot_id]) === null || _b === void 0 ? void 0 : _b.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/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

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

@@ -1,12 +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';
-import { LiveCallRingEdge } from './live-call-ring-edge';
-export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'>): number | null;
+import { FfmpegOptions, StreamingSession } from './streaming/streaming-session';
+import { StreamingConnectionOptions } from './streaming/streaming-connection-base';
+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;
@@ -15,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;
@@ -23,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;
@@ -54,9 +55,10 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
-    startLiveCall(): Promise<LiveCall | LiveCallRingEdge>;
+    private createStreamingConnection;
+    startLiveCall(options?: StreamingConnectionOptions): Promise<StreamingSession>;
     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;
@@ -81,14 +83,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 | LiveCallRingEdge>;
+    streamVideo(ffmpegOptions: FfmpegOptions): Promise<StreamingSession>;
     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

@@ -16,8 +16,9 @@ const rxjs_1 = require("rxjs");
 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 webrtc_connection_1 = require("./streaming/webrtc-connection");
+const ring_edge_connection_1 = require("./streaming/ring-edge-connection");
+const streaming_session_1 = require("./streaming/streaming-session");
 const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -41,8 +42,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);
@@ -65,20 +67,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;
@@ -119,20 +118,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';
@@ -233,11 +230,11 @@ class RingCamera extends subscribed_1.Subscribed {
             return response.device_health;
         });
     }
-    startLiveCall() {
+    createStreamingConnection(options) {
         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);
+                return new ring_edge_connection_1.RingEdgeConnection(auth.access_token, this, options);
             }
             const liveCall = yield this.restClient
                 .request({
@@ -253,19 +250,25 @@ class RingCamera extends subscribed_1.Subscribed {
                 }
                 throw e;
             });
-            return new live_call_1.LiveCall(liveCall.data.session_id, this);
+            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);
         });
     }
     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 = {}) {
@@ -337,17 +340,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'
@@ -367,7 +372,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}`,
@@ -376,6 +381,7 @@ class RingCamera extends subscribed_1.Subscribed {
                     'after-ms': afterMs,
                     'max-wait-ms': maxWaitMs,
                     extras: force ? 'force' : undefined,
+                    uuid,
                 },
                 headers: {
                     accept: 'image/jpeg',
@@ -386,6 +392,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({