homebridge-ring 9.25.0-beta.1 → 10.0.0-beta.2

package/CHANGELOG.md

@@ -2,6 +2,55 @@
 
 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.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)
+
+
+### ⚠ BREAKING CHANGES
+
+* **homebridge:** For anyone who updated to the 10.0 beta and had their cameras reset in HomeKit, this change will cause another reset.  This moves the audio codecs back to what they were before the 10.0 beta, which means anyone upgrading directly from v9 will _not_ experience a reset of the cameras.  Using native Opus was an experimental feature, which ultimately lead to a degraded user experience.
+
+### Bug Fixes
+
+* allow video transcoding to be skipped ([1ef8cdd](https://github.com/dgreif/ring/commit/1ef8cdd54d1f118a8fdcfd28f6970d9c8b7c65f9))
+* **homebridge:** switch back to aac-eld from opus ([7dcd2a0](https://github.com/dgreif/ring/commit/7dcd2a087da7c1b24cc9bdd3c3919af5e6fb7997))
+
+## [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)
 
 

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

@@ -10,29 +10,29 @@ export interface FfmpegOptions {
     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<void>;
+    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>;
-    constructor(sessionId: string, camera: RingCamera);
+    private readonly onOfferSent;
+    constructor(authToken: string, camera: RingCamera);
+    private initiateCall;
+    private sessionId;
     private handleMessage;
     reservePort(bufferPorts?: number): Promise<number>;
-    prepareTranscoder(transcodeVideoStream: boolean, ffmpegInputOptions: SpawnInput[] | undefined, audioPort: number, videoPort: number, sdpInput: string): {
-        ffmpegInputArguments: SpawnInput[];
-        inputSdpLines: string[];
-    };
     startTranscoding(ffmpegOptions: FfmpegOptions): Promise<void>;
     activated: boolean;
     activate(): Promise<void>;
     activateCameraSpeaker(): Promise<void>;
+    private sendSessionMessage;
     private sendMessage;
     private callEnded;
     stop(): void;

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");
@@ -19,23 +18,45 @@ 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 LiveCall extends subscribed_1.Subscribed {
-    constructor(sessionId, camera) {
+    constructor(authToken, camera) {
         super();
-        this.sessionId = sessionId;
         this.camera = camera;
+        this.onSessionId = new rxjs_1.ReplaySubject(1);
         this.onCallAnswered = new rxjs_1.ReplaySubject(1);
         this.onCallEnded = new rxjs_1.ReplaySubject(1);
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
+        this.onOfferSent = new rxjs_1.ReplaySubject(1);
+        this.sessionId = null;
         this.activated = false;
-        const liveCallSession = (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}/`, {
+        this.ws = new ws_1.WebSocket('wss://api.prod.signalling.ring.devices.a2z.com:443/ws', {
             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',
+                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;
@@ -49,28 +70,109 @@ class LiveCall extends subscribed_1.Subscribed {
         }))
             .subscribe(), this.onWsOpen.subscribe(() => {
             (0, util_1.logDebug)(`WebSocket connected for ${this.camera.name}`);
+            this.initiateCall().catch((e) => {
+                (0, util_1.logError)(e);
+                this.callEnded();
+            });
         }), onError.subscribe((e) => {
             (0, util_1.logError)(e);
             this.callEnded();
         }), onClose.subscribe(() => {
             this.callEnded();
+        }), this.onCallAnswered
+            .pipe((0, operators_1.switchMap)(() => (0, rxjs_1.interval)(5000)))
+            .subscribe(() => {
+            if (!this.sessionId) {
+                return;
+            }
+            this.sendSessionMessage('ping');
+        }), this.pc.onIceCandidate.subscribe((iceCandidate) => __awaiter(this, void 0, void 0, function* () {
+            yield (0, rxjs_1.firstValueFrom)(this.onOfferSent);
+            this.sendMessage({
+                method: 'ice',
+                body: {
+                    doorbot_id: this.camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: 0,
+                },
+            });
+            // HACK: send ice candidate with both mline indexes to convince ring edge to connect both audio and video
+            // Without this, only audio will connect unless you connect from the network of the Ring Edge router
+            this.sendMessage({
+                method: 'ice',
+                body: {
+                    doorbot_id: this.camera.id,
+                    ice: iceCandidate.candidate,
+                    mlineindex: 1,
+                },
+            });
+        })), this.pc.onConnectionState.subscribe((state) => {
+            if (state === 'failed') {
+                (0, util_1.logError)('Stream connection failed');
+                this.callEnded();
+            }
+            if (state === 'closed') {
+                (0, util_1.logDebug)('Stream connection closed');
+                this.callEnded();
+            }
         }));
     }
+    initiateCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const offer = yield this.pc.createOffer();
+            offer.sdp = offer.sdp.replace('\na=group:BUNDLE 0 1', '');
+            this.sendMessage({
+                method: 'live_view',
+                body: {
+                    doorbot_id: this.camera.id,
+                    stream_options: { audio_enabled: true, video_enabled: true },
+                    sdp: offer.sdp,
+                },
+            });
+            this.onOfferSent.next();
+        });
+    }
     handleMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (message.body.doorbot_id !== this.camera.id) {
+                // ignore messages for other cameras
+                return;
+            }
+            if (['session_created', 'session_started'].includes(message.method) &&
+                'session_id' in message.body &&
+                !this.sessionId) {
+                this.sessionId = message.body.session_id;
+                this.onSessionId.next(this.sessionId);
+            }
+            if (message.body.session_id && message.body.session_id !== this.sessionId) {
+                // ignore messages for other sessions
+                return;
+            }
             switch (message.method) {
+                case 'session_created':
+                case 'session_started':
+                    // session already stored above
+                    return;
                 case 'sdp':
-                    const answer = yield this.pc.createAnswer(message);
-                    this.sendMessage(Object.assign({ method: 'sdp' }, answer));
-                    this.onCallAnswered.next();
+                    yield this.pc.acceptAnswer(message.body);
+                    this.onCallAnswered.next(message.body.sdp);
                     return;
                 case 'ice':
                     yield this.pc.addIceCandidate({
-                        candidate: message.ice,
-                        sdpMLineIndex: message.mlineindex,
+                        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) {
@@ -79,57 +181,22 @@ class LiveCall extends subscribed_1.Subscribed {
             return ports[0];
         });
     }
-    prepareTranscoder(transcodeVideoStream, ffmpegInputOptions, audioPort, videoPort, sdpInput) {
-        const ffmpegInputArguments = [
-            '-hide_banner',
-            '-protocol_whitelist',
-            'pipe,udp,rtp,file,crypto',
-            '-acodec',
-            'libopus',
-            '-f',
-            'sdp',
-            ...(ffmpegInputOptions || []),
-            '-i',
-            sdpInput,
-        ], inputSdpLines = [
-            'v=0',
-            'o=105202070 3747 461 IN IP4 127.0.0.1',
-            's=Talk',
-            'c=IN IP4 127.0.0.1',
-            'b=AS:380',
-            't=0 0',
-            'a=rtcp-xr:rcvr-rtt=all:10000 stat-summary=loss,dup,jitt,TTL voip-metrics',
-            `m=audio ${audioPort} RTP/SAVP 101`,
-            'a=rtpmap:101 OPUS/48000/2',
-            'a=rtcp-fb:101 nack pli',
-            'a=fmtp:101 useinbandfec=1;sprop-stereo=0',
-            'a=rtcp-mux',
-        ];
-        if (transcodeVideoStream) {
-            inputSdpLines.push(`m=video ${videoPort} RTP/SAVP 96`, 'a=rtpmap:96 H264/90000', 'a=rtcp-fb:96 nack', 'a=rtcp-fb:96 nack pli', 'a=fmtp:96 packetization-mode=1;profile-level-id=640029;level-asymmetry-allowed=1', 'a=rtcp-mux');
-            this.addSubscriptions(this.onVideoRtp
-                .pipe((0, operators_1.concatMap)((rtp) => {
-                return this.videoSplitter.send(rtp.serialize(), {
-                    port: videoPort,
-                });
-            }))
-                .subscribe());
-        }
-        this.addSubscriptions(this.onAudioRtp
-            .pipe((0, operators_1.concatMap)((rtp) => {
-            return this.audioSplitter.send(rtp.serialize(), {
-                port: audioPort,
-            });
-        }))
-            .subscribe());
-        return {
-            ffmpegInputArguments,
-            inputSdpLines,
-        };
-    }
     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, inputSdpLines } = this.prepareTranscoder(transcodeVideoStream, ffmpegOptions.input, audioPort, videoPort, 'pipe:'), ff = new camera_utils_1.FfmpegProcess({
+            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 || [])),
@@ -141,8 +208,24 @@ class LiveCall extends subscribed_1.Subscribed {
                     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(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
+            ff.writeStdin(inputSdp);
             // Activate the stream now that ffmpeg is ready to receive
             yield this.activate();
         });
@@ -153,32 +236,42 @@ class LiveCall extends subscribed_1.Subscribed {
                 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',
-            });
+            yield (0, rxjs_1.firstValueFrom)(this.pc.onConnectionState.pipe((0, operators_1.filter)((state) => state === 'connected')));
+            (0, util_1.logInfo)('Activating Session');
+            this.sendSessionMessage('activate_session');
         });
     }
     activateCameraSpeaker() {
         return __awaiter(this, void 0, void 0, function* () {
             yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered);
-            this.sendMessage({
+            this.sendSessionMessage('camera_options', {
                 stealth_mode: false,
-                method: 'camera_options',
             });
         });
     }
+    sendSessionMessage(method, body = {}) {
+        const message = {
+            method,
+            body: Object.assign(Object.assign({}, body), { doorbot_id: this.camera.id, session_id: this.sessionId }),
+        };
+        if (this.sessionId) {
+            // Send immediately if we already have a session id
+            // This is needed to send `close` before closing the websocket
+            this.sendMessage(message);
+        }
+        else {
+            (0, rxjs_1.firstValueFrom)(this.onSessionId)
+                .then(() => this.sendMessage(message))
+                .catch((e) => (0, util_1.logError)(e));
+        }
+    }
     sendMessage(message) {
         this.ws.send(JSON.stringify(message));
     }
     callEnded() {
         try {
-            this.sendMessage({
-                reason: { code: 0, text: '' },
-                method: 'close',
+            this.sendSessionMessage('close', {
+                reason: { code: CloseReasonCode.NormalClose, text: '' },
             });
             this.ws.close();
         }

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

@@ -1,17 +1,20 @@
 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();
-    createAnswer(offer: {
-        type: 'offer';
+    createOffer(): Promise<import("@koush/werift").RTCSessionDescription>;
+    acceptAnswer(answer: {
+        type: 'answer';
         sdp: string;
-    }): Promise<import("@koush/werift").RTCSessionDescription>;
+    }): Promise<void>;
     addIceCandidate(candidate: RTCIceCandidate): Promise<void>;
     close(): void;
 }

package/lib/api/peer-connection.js

@@ -20,6 +20,8 @@ class PeerConnection {
         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,7 +43,7 @@ class PeerConnection {
                             { type: 'nack', parameter: 'pli' },
                             { type: 'goog-remb' },
                         ],
-                        parameters: 'level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f',
+                        parameters: 'profile-level-id=42801F',
                     }),
                 ],
             },
@@ -77,13 +79,30 @@ 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) {
+    acceptAnswer(answer) {
         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;
+            yield this.pc.setRemoteDescription(answer);
         });
     }
     addIceCandidate(candidate) {

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

@@ -2,12 +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 { LiveCall } from './live-call';
+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;
@@ -45,6 +42,7 @@ export declare class RingCamera extends Subscribed {
     get isCharging(): boolean;
     get operatingOnBattery(): boolean;
     get isOffline(): boolean;
+    get isRingEdgeEnabled(): boolean;
     get hasInHomeDoorbell(): boolean;
     doorbotUrl(path?: string): string;
     deviceUrl(path?: string): string;
@@ -56,10 +54,6 @@ export declare class RingCamera extends Subscribed {
     setInHomeDoorbell(enable: boolean): Promise<boolean>;
     getHealth(): Promise<CameraHealth>;
     startLiveCall(): Promise<LiveCall>;
-    startVideoOnDemand(): Promise<("" | ActiveDing) & import("./rest-client").ExtendedResponse>;
-    private pollForActiveDing;
-    private expiredDingIds;
-    getSipConnectionDetails(): Promise<ActiveDing>;
     private removeDingById;
     processActiveDing(ding: ActiveDing): void;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -92,15 +86,8 @@ export declare class RingCamera extends Subscribed {
         maxWaitMs?: number;
         force?: boolean;
     }): Promise<Buffer & import("./rest-client").ExtendedResponse>;
-    getSipOptions(): Promise<SipOptions>;
-    getUpdatedSipOptions(expiredDingId: string): Promise<SipOptions>;
-    createSipSession(options?: {
-        audio?: SrtpOptions;
-        video?: SrtpOptions;
-        skipFfmpegCheck?: boolean;
-    }): Promise<SipSession>;
     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>;