homebridge-ring 9.23.0 → 10.0.0-beta.0

package/CHANGELOG.md

@@ -2,6 +2,61 @@
 
 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.0](https://github.com/dgreif/ring/compare/v9.25.0-beta.1...v10.0.0-beta.0) (2022-02-18)
+
+
+### ⚠ BREAKING CHANGES
+
+* `ring-client-api` only (homebridge not impacted) - All streaming will now be done using the new Ring api via WebRTC + WebSockets.  For those using `camera.streamVideo`, you should not notice any difference.  Anyone directly interacting with sip sessions, you will need to migrate to the new `LiveCall` api.  It's fairly similar, and should be more reliable long term.  A number of other sip-specific methods have been removed from the `RingCamera` api as well.
+* Node 10 is no longer officially supported.  It may still work, but could break without warning in the future.
+* **homebridge:** The minimum supported homebridge version for this plugin is now 1.4.0
+* **homebridge:** This change will break all existing automations related to cameras, and will likely move them back to the default room in HomeKit.  Once updated, you will have to set up your automations again manually.  This is necessary to get camera audio working again after the switch to Opus
+* **homebridge:** Switching to Opus requires the camera to be removed and re-added to HomeKit.  Until this is done, you will not receive audio from your cameras.
+
+### Features
+
+* add floodlight pro ([f749d38](https://github.com/dgreif/ring/commit/f749d38e0528e631864bf20819692a466744e1f2)), closes [#889](https://github.com/dgreif/ring/issues/889)
+* **homebridge:** stream opus audio without ffmpeg for transcoding ([ee142bc](https://github.com/dgreif/ring/commit/ee142bc0eee9dcfda41d162b2105535b8fdcbf9a))
+
+
+### Bug Fixes
+
+* drop support for node 10 ([509d556](https://github.com/dgreif/ring/commit/509d55670b3dd4efee1be968618f6bc6b142ae2b))
+* **homebridge:** force cameras to be recreated in HomeKit ([94a1520](https://github.com/dgreif/ring/commit/94a15204f4a9ccbe94968be8db05add6baa5fcfa))
+* **homebridge:** increase minimum homebridge version to 1.4.0 ([d5be74a](https://github.com/dgreif/ring/commit/d5be74aae45a3e353bcaba4fc42fa25c6b2fa37e))
+* remove sip calling in favor of live calls ([7aeae37](https://github.com/dgreif/ring/commit/7aeae37e6e93b68747e14983cea9c0a9229faec6))
+* use Buffer.from ([2b28d90](https://github.com/dgreif/ring/commit/2b28d9028fc7f2c2e11b11cf3b27cc03f097eab2))
+
+## [9.25.0-beta.1](https://github.com/dgreif/ring/compare/v9.25.0-beta.0...v9.25.0-beta.1) (2022-02-14)
+
+
+### Features
+
+* use new WebRTC endpoint for live calls ([6e7779f](https://github.com/dgreif/ring/commit/6e7779feef9789583921fc44bab32c099f3026d2))
+
+## [9.25.0-beta.0](https://github.com/dgreif/ring/compare/v9.24.0...v9.25.0-beta.0) (2022-01-29)
+
+
+### Features
+
+* **api:** decouple ffmpeg prep from execution ([#859](https://github.com/dgreif/ring/issues/859)) ([e3cc9d1](https://github.com/dgreif/ring/commit/e3cc9d15584377bf2be94a9d457efc3dfcb4bd8b))
+* handle new camera types with no battery ([11ae286](https://github.com/dgreif/ring/commit/11ae28697d8cb0e2da71e880c82e1883f04047b9))
+* slightly faster snapshots via new endpoint ([b840471](https://github.com/dgreif/ring/commit/b840471bc6b7b66e5873370251bd57c1a35b267a))
+
+## [9.24.0](https://github.com/dgreif/ring/compare/v9.23.0...v9.24.0) (2022-01-22)
+
+
+### Features
+
+* support glassbreak sensor ([98271f9](https://github.com/dgreif/ring/commit/98271f91f13aaae051fccaab7165cd17f2a2377c))
+
+
+### Bug Fixes
+
+* allow process to exit when RingApi.disconnect() is called ([#851](https://github.com/dgreif/ring/issues/851)) ([8ef25ac](https://github.com/dgreif/ring/commit/8ef25acca66c533873b7fd43c7c899e34b4a7617))
+* avoid error when ring terminates video stream ([7717d5e](https://github.com/dgreif/ring/commit/7717d5eaa40afed3d34f0e8e6eea1402e21afef7)), closes [#853](https://github.com/dgreif/ring/issues/853)
+* update dependencies ([c80d052](https://github.com/dgreif/ring/commit/c80d052f9eaf4c0a50a495166177daa40299ffa7))
+
 ## [9.23.0](https://github.com/dgreif/ring/compare/v9.22.1...v9.23.0) (2021-10-17)
 
 

package/README.md

@@ -165,6 +165,10 @@ If you are having issues with your cameras in the Home app, please see the [Came
     * Detect water leak
     * Tamper status
     * Battery status
+  * Glassbreak Sensor (**untested**)
+    * Detect glass breaking
+    * Tamper status
+    * Battery status
   * Ring Smart Lights (Motion Detector, Flood/Path/Step/Spot Lights, Bulbs, Transformer, Outdoor Smart Plug, Mailbox Sensor)
     * On/Off
     * Brightness Level

package/lib/api/api.js

@@ -24,7 +24,8 @@ class RingApi extends subscribed_1.Subscribed {
         super();
         this.options = options;
         this.restClient = new rest_client_1.RingRestClient(this.options);
-        this.onRefreshTokenUpdated = this.restClient.onRefreshTokenUpdated.asObservable();
+        this.onRefreshTokenUpdated =
+            this.restClient.onRefreshTokenUpdated.asObservable();
         if (options.debug) {
             (0, util_1.enableDebug)();
         }
@@ -169,6 +170,7 @@ class RingApi extends subscribed_1.Subscribed {
             .catch((e) => {
             (0, util_1.logError)(e);
         });
+        this.restClient.clearTimeouts();
     }
 }
 exports.RingApi = RingApi;

package/lib/api/index.d.ts

@@ -4,4 +4,3 @@ export * from './ring-camera';
 export * from './ring-chime';
 export * from './ring-device';
 export * from './ring-types';
-export * from './sip-session';

package/lib/api/index.js

@@ -16,4 +16,3 @@ __exportStar(require("./ring-camera"), exports);
 __exportStar(require("./ring-chime"), exports);
 __exportStar(require("./ring-device"), exports);
 __exportStar(require("./ring-types"), exports);
-__exportStar(require("./sip-session"), exports);

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

@@ -0,0 +1,37 @@
+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 LiveCall extends Subscribed {
+    private sessionId;
+    private camera;
+    private readonly ws;
+    private readonly onWsOpen;
+    private readonly onMessage;
+    private readonly pc;
+    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>;
+    constructor(sessionId: string, camera: RingCamera);
+    private handleMessage;
+    reservePort(bufferPorts?: number): Promise<number>;
+    startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
+    activated: boolean;
+    activate(): Promise<void>;
+    activateCameraSpeaker(): Promise<void>;
+    private sendMessage;
+    private callEnded;
+    stop(): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+}
+export {};

package/lib/api/live-call.js

@@ -0,0 +1,182 @@
+"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.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");
+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");
+class LiveCall extends subscribed_1.Subscribed {
+    constructor(sessionId, camera) {
+        super();
+        this.sessionId = sessionId;
+        this.camera = camera;
+        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.activated = false;
+        const liveCallSession = (0, rtp_utils_1.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',
+            },
+        });
+        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}`);
+        }), onError.subscribe((e) => {
+            (0, util_1.logError)(e);
+            this.callEnded();
+        }), onClose.subscribe(() => {
+            this.callEnded();
+        }));
+    }
+    handleMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (message.method) {
+                case 'sdp':
+                    const answer = yield this.pc.createAnswer(message);
+                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
+                    this.onCallAnswered.next(message.sdp);
+                    return;
+                case 'ice':
+                    yield this.pc.addIceCandidate({
+                        candidate: message.ice,
+                        sdpMLineIndex: message.mlineindex,
+                    });
+                    return;
+            }
+        });
+    }
+    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:',
+            ], inputSdp = (yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered))
+                .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);
+            this.sendMessage({ method: 'activate_session' });
+            this.sendMessage({
+                video_enabled: true,
+                audio_enabled: true,
+                method: 'stream_options',
+            });
+        });
+    }
+    activateCameraSpeaker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
+            this.sendMessage({
+                stealth_mode: false,
+                method: 'camera_options',
+            });
+        });
+    }
+    sendMessage(message) {
+        this.ws.send(JSON.stringify(message));
+    }
+    callEnded() {
+        try {
+            this.sendMessage({
+                reason: { code: 0, text: '' },
+                method: 'close',
+            });
+            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.LiveCall = LiveCall;

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

@@ -0,0 +1,17 @@
+import { MediaStreamTrack, RTCIceCandidate, RTCPeerConnection, RtcpPacket, RtpPacket } from '@koush/werift';
+import { Subject } from 'rxjs';
+export declare class PeerConnection {
+    pc: RTCPeerConnection;
+    onAudioRtp: Subject<RtpPacket>;
+    onAudioRtcp: Subject<RtcpPacket>;
+    onVideoRtp: Subject<RtpPacket>;
+    onVideoRtcp: Subject<RtcpPacket>;
+    returnAudioTrack: MediaStreamTrack;
+    constructor();
+    createAnswer(offer: {
+        type: 'offer';
+        sdp: string;
+    }): Promise<import("@koush/werift").RTCSessionDescription>;
+    addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
+    close(): void;
+}

package/lib/api/peer-connection.js

@@ -0,0 +1,96 @@
+"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.PeerConnection = void 0;
+const werift_1 = require("@koush/werift");
+const rxjs_1 = require("rxjs");
+const util_1 = require("./util");
+const debug = false;
+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.returnAudioTrack = new werift_1.MediaStreamTrack({ kind: 'audio' });
+        const pc = (this.pc = new werift_1.RTCPeerConnection({
+            codecs: {
+                audio: [
+                    new werift_1.RTCRtpCodecParameters({
+                        mimeType: 'audio/opus',
+                        clockRate: 48000,
+                        channels: 2,
+                    }),
+                ],
+                video: [
+                    new werift_1.RTCRtpCodecParameters({
+                        mimeType: 'video/H264',
+                        clockRate: 90000,
+                        rtcpFeedback: [
+                            { type: 'transport-cc' },
+                            { type: 'ccm', parameter: 'fir' },
+                            { type: 'nack' },
+                            { type: 'nack', parameter: 'pli' },
+                            { type: 'goog-remb' },
+                        ],
+                        parameters: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
+                    }),
+                ],
+            },
+        })), audioTransceiver = pc.addTransceiver(this.returnAudioTrack, {
+            direction: 'sendrecv',
+        }), videoTransceiver = pc.addTransceiver('video', {
+            direction: 'recvonly',
+        });
+        audioTransceiver.onTrack.subscribe((track) => {
+            track.onReceiveRtp.subscribe((rtp) => {
+                this.onAudioRtp.next(rtp);
+            });
+            track.onReceiveRtcp.subscribe((rtcp) => {
+                this.onAudioRtcp.next(rtcp);
+            });
+            if (debug) {
+                track.onReceiveRtp.once(() => {
+                    (0, util_1.logInfo)('received first audio packet');
+                });
+            }
+        });
+        videoTransceiver.onTrack.subscribe((track) => {
+            track.onReceiveRtp.subscribe((rtp) => {
+                this.onVideoRtp.next(rtp);
+            });
+            track.onReceiveRtcp.subscribe((rtcp) => {
+                this.onVideoRtcp.next(rtcp);
+            });
+            track.onReceiveRtp.once(() => {
+                if (debug) {
+                    (0, util_1.logInfo)('received first video packet');
+                }
+                setInterval(() => videoTransceiver.receiver.sendRtcpPLI(track.ssrc), 2000);
+            });
+        });
+    }
+    createAnswer(offer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.pc.setRemoteDescription(offer);
+            const answer = yield this.pc.createAnswer();
+            yield this.pc.setLocalDescription(answer);
+            return answer;
+        });
+    }
+    addIceCandidate(candidate) {
+        return this.pc.addIceCandidate(candidate);
+    }
+    close() {
+        this.pc.close().catch(util_1.logError);
+    }
+}
+exports.PeerConnection = PeerConnection;

package/lib/api/rest-client.d.ts

@@ -6,6 +6,7 @@ export declare function deviceApi(path: string): string;
 export declare function appApi(path: string): string;
 export interface ExtendedResponse {
     responseTimestamp: number;
+    timeMillis: number;
 }
 export interface EmailAuth {
     email: string;
@@ -24,6 +25,7 @@ export declare class RingRestClient {
     refreshToken: string | undefined;
     private hardwareIdPromise;
     private _authPromise;
+    private timeouts;
     private clearPreviousAuth;
     private get authPromise();
     private sessionPromise?;
@@ -44,4 +46,5 @@ export declare class RingRestClient {
         url: string;
     }): Promise<T & ExtendedResponse>;
     getCurrentAuth(): Promise<AuthTokenResponse>;
+    clearTimeouts(): void;
 }

package/lib/api/rest-client.js

@@ -44,8 +44,13 @@ function requestWithRetry(requestOptions) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const options = Object.assign(Object.assign({}, defaultRequestOptions), requestOptions), { headers, body } = (yield (0, got_1.default)(options)), data = body;
-            if (data !== null && typeof data === 'object' && headers.date) {
-                data.responseTimestamp = new Date(headers.date).getTime();
+            if (data !== null && typeof data === 'object') {
+                if (headers.date) {
+                    data.responseTimestamp = new Date(headers.date).getTime();
+                }
+                if (headers['x-time-millis']) {
+                    data.timeMillis = Number(headers['x-time-millis']);
+                }
             }
             return data;
         }
@@ -66,12 +71,15 @@ function requestWithRetry(requestOptions) {
 class RingRestClient {
     constructor(authOptions) {
         this.authOptions = authOptions;
-        // prettier-ignore
-        this.refreshToken = ('refreshToken' in this.authOptions ? this.authOptions.refreshToken : undefined);
-        this.hardwareIdPromise = (0, util_1.getHardwareId)(this.authOptions.systemId);
+        this.timeouts = [];
         this.sessionPromise = undefined;
         this.using2fa = false;
         this.onRefreshTokenUpdated = new rxjs_1.ReplaySubject(1);
+        this.refreshToken =
+            'refreshToken' in this.authOptions
+                ? this.authOptions.refreshToken
+                : undefined;
+        this.hardwareIdPromise = (0, util_1.getHardwareId)(this.authOptions.systemId);
     }
     clearPreviousAuth() {
         this._authPromise = undefined;
@@ -83,11 +91,12 @@ class RingRestClient {
             authPromise
                 .then(({ expires_in }) => {
                 // clear the existing auth promise 1 minute before it expires
-                setTimeout(() => {
+                const timeout = setTimeout(() => {
                     if (this._authPromise === authPromise) {
                         this.clearPreviousAuth();
                     }
                 }, ((expires_in || 3600) - 60) * 1000);
+                this.timeouts.push(timeout);
             })
                 .catch(() => {
                 // ignore these errors here, they should be handled by the function making a rest request
@@ -288,5 +297,8 @@ class RingRestClient {
     getCurrentAuth() {
         return this.authPromise;
     }
+    clearTimeouts() {
+        this.timeouts.forEach(clearTimeout);
+    }
 }
 exports.RingRestClient = RingRestClient;

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

@@ -2,11 +2,9 @@
 import { ActiveDing, CameraData, CameraDeviceSettingsData, CameraEventOptions, CameraEventResponse, CameraHealth, HistoryOptions, PeriodicFootageResponse, VideoSearchResponse } from './ring-types';
 import { RingRestClient } from './rest-client';
 import { BehaviorSubject, Subject } from 'rxjs';
-import { SrtpOptions } from '@homebridge/camera-utils';
 import { DeepPartial } from './util';
-import { FfmpegOptions, SipSession } from './sip-session';
-import { SipOptions } from './sip-call';
 import { Subscribed } from './subscribed';
+import { FfmpegOptions, LiveCall } from './live-call';
 export declare function getBatteryLevel(data: Pick<CameraData, 'battery_life' | 'battery_life_2'>): number | null;
 export declare function getSearchQueryString(options: CameraEventOptions | (HistoryOptions & {
     accountId: string;
@@ -23,7 +21,6 @@ export declare class RingCamera extends Subscribed {
     onData: BehaviorSubject<CameraData>;
     hasLight: boolean;
     hasSiren: boolean;
-    hasBattery: boolean;
     onRequestUpdate: Subject<unknown>;
     onRequestActiveDings: Subject<unknown>;
     onNewDing: Subject<ActiveDing>;
@@ -40,6 +37,7 @@ export declare class RingCamera extends Subscribed {
     get name(): string;
     get activeDings(): ActiveDing[];
     get batteryLevel(): number | null;
+    get hasBattery(): boolean;
     get hasLowBattery(): boolean;
     get isCharging(): boolean;
     get operatingOnBattery(): boolean;
@@ -54,10 +52,7 @@ export declare class RingCamera extends Subscribed {
     getDeviceSettings(): Promise<CameraDeviceSettingsData & import("./rest-client").ExtendedResponse>;
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
-    startVideoOnDemand(): Promise<("" | ActiveDing) & import("./rest-client").ExtendedResponse>;
-    private pollForActiveDing;
-    private expiredDingIds;
-    getSipConnectionDetails(): Promise<ActiveDing>;
+    startLiveCall(): Promise<LiveCall>;
     private removeDingById;
     processActiveDing(ding: ActiveDing): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -75,27 +70,23 @@ export declare class RingCamera extends Subscribed {
     }): Promise<string>;
     private isTimestampInLifeTime;
     get snapshotsAreBlocked(): boolean;
-    private getSnapshotTimestamp;
-    private refreshSnapshotInProgress?;
     get snapshotLifeTime(): number;
+    private lastSnapshotTimestamp;
     private lastSnapshotTimestampLocal;
     private lastSnapshotPromise?;
     get currentTimestampAge(): number;
-    get currentTimestampExpiresIn(): number;
     get hasSnapshotWithinLifetime(): boolean;
     private checkIfSnapshotsAreBlocked;
-    private requestSnapshotUpdate;
-    private refreshSnapshot;
-    getSnapshot(): Promise<Buffer | undefined>;
-    getSipOptions(): Promise<SipOptions>;
-    getUpdatedSipOptions(expiredDingId: string): Promise<SipOptions>;
-    createSipSession(options?: {
-        audio?: SrtpOptions;
-        video?: SrtpOptions;
-        skipFfmpegCheck?: boolean;
-    }): Promise<SipSession>;
+    private shouldUseExistingSnapshotPromise;
+    private fetchingSnapshot;
+    getSnapshot(): Promise<Buffer>;
+    getNextSnapshot({ afterMs, maxWaitMs, force, }: {
+        afterMs?: number;
+        maxWaitMs?: number;
+        force?: boolean;
+    }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
     recordToFile(outputPath: string, duration?: number): Promise<void>;
-    streamVideo(ffmpegOptions: FfmpegOptions): Promise<SipSession>;
+    streamVideo(ffmpegOptions: FfmpegOptions): Promise<LiveCall>;
     subscribeToDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     unsubscribeFromDingEvents(): Promise<void & import("./rest-client").ExtendedResponse>;
     subscribeToMotionEvents(): Promise<void & import("./rest-client").ExtendedResponse>;