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

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 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.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)
+
+
+### ⚠ 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)
 
 

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.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.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");
@@ -19,6 +18,18 @@ const operators_1 = require("rxjs/operators");
 const subscribed_1 = require("./subscribed");
 const camera_utils_1 = require("@homebridge/camera-utils");
 const ffmpeg_1 = require("./ffmpeg");
+function getCleanSdp(sdp, includeVideo) {
+    return sdp
+        .split('\nm=')
+        .slice(1)
+        .map((section) => 'm=' + section)
+        .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();
@@ -29,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;
@@ -92,7 +103,7 @@ class LiveCall extends subscribed_1.Subscribed {
                 ...(ffmpegOptions.input || []),
                 '-i',
                 'pipe:',
-            ], inputSdp = (yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered))
+            ], 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

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

@@ -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: 'packetization-mode=1;profile-level-id=42801F;level-asymmetry-allowed=1',
                     }),
                 ],
             },
@@ -77,6 +79,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 +108,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

@@ -5,6 +5,7 @@ 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;
 export declare function getSearchQueryString(options: CameraEventOptions | (HistoryOptions & {
     accountId: string;
@@ -42,6 +43,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;
@@ -52,7 +54,7 @@ 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;
     getEvents(options?: CameraEventOptions): Promise<CameraEventResponse & import("./rest-client").ExtendedResponse>;
@@ -86,7 +88,7 @@ export declare class RingCamera extends Subscribed {
         force?: boolean;
     }): 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,6 +17,7 @@ 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) {
@@ -145,6 +146,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 +235,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',
@@ -362,7 +370,7 @@ class RingCamera extends subscribed_1.Subscribed {
     getNextSnapshot({ afterMs, maxWaitMs, force, }) {
         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,

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

@@ -379,6 +379,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;

package/lib/homebridge/camera-source.js

@@ -17,6 +17,7 @@ const operators_1 = require("rxjs/operators");
 const rxjs_1 = require("rxjs");
 const fs_1 = require("fs");
 const util_2 = require("util");
+const ffmpeg_1 = require("../api/ffmpeg");
 const werift_1 = require("@koush/werift");
 const readFileAsync = (0, util_2.promisify)(fs_1.readFile), cameraOfflinePath = require.resolve('../../media/camera-offline.jpg'), snapshotsBlockedPath = require.resolve('../../media/snapshots-blocked.jpg');
 function getDurationSeconds(start) {
@@ -45,13 +46,18 @@ class StreamingSession {
         this.videoSrtp = (0, camera_utils_1.generateSrtpOptions)();
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
-        this.cameraSpeakerActive = false;
-        const { targetAddress, audio: { srtp_key: remoteAudioSrtpKey, srtp_salt: remoteAudioSrtpSalt }, video: { port: videoPort }, } = prepareStreamRequest, 
-        // used to decrypt return audio from HomeKit
-        returnAudioSrtpSession = new werift_1.SrtpSession(getSessionConfig({
-            srtpKey: remoteAudioSrtpKey,
-            srtpSalt: remoteAudioSrtpSalt,
-        })), 
+        this.libfdkAacInstalledPromise = (0, camera_utils_1.doesFfmpegSupportCodec)('libfdk_aac', (0, ffmpeg_1.getFfmpegPath)())
+            .then((supported) => {
+            if (!supported) {
+                (0, util_1.logError)('Streaming video only - found ffmpeg, but libfdk_aac is not installed. See https://github.com/dgreif/ring/wiki/FFmpeg for details.');
+            }
+            return supported;
+        })
+            .catch(() => {
+            (0, util_1.logError)('Streaming video only - ffmpeg was not found. See https://github.com/dgreif/ring/wiki/FFmpeg for details.');
+            return false;
+        });
+        const { targetAddress, video: { port: videoPort }, } = prepareStreamRequest, 
         // used to encrypt rtcp to HomeKit for keepalive
         videoSrtcpSession = new werift_1.SrtcpSession(getSessionConfig(this.videoSrtp)), onReturnPacketReceived = new rxjs_1.Subject();
         // Watch return packets to detect a dead stream from the HomeKit side
@@ -61,21 +67,9 @@ class StreamingSession {
             onReturnPacketReceived.next(null);
             return null;
         });
-        this.audioSplitter.addMessageHandler(({ message, isRtpMessage }) => {
-            if (!isRtpMessage) {
-                return null;
-            }
+        this.audioSplitter.addMessageHandler(() => {
             // return packet from HomeKit
             onReturnPacketReceived.next(null);
-            // Make sure the external speaker on the camera is active since we will be sending packets to it
-            if (!this.cameraSpeakerActive) {
-                this.cameraSpeakerActive = true;
-                this.liveCall.activateCameraSpeaker().catch(util_1.logError);
-            }
-            // decrypt the packet
-            const decryptedMessage = returnAudioSrtpSession.decrypt(message), rtp = werift_1.RtpPacket.deSerialize(decryptedMessage);
-            // send to Ring - werift will handle encryption and other header params
-            this.liveCall.sendAudioPacket(rtp);
             return null;
         });
         liveCall.addSubscriptions((0, rxjs_1.merge)((0, rxjs_1.of)(true).pipe((0, operators_1.delay)(15000)), onReturnPacketReceived)
@@ -107,27 +101,9 @@ class StreamingSession {
     activate(request) {
         return __awaiter(this, void 0, void 0, function* () {
             let sentVideo = false;
-            const { targetAddress, audio: { port: audioPort }, video: { port: videoPort }, } = this.prepareStreamRequest, 
+            const { targetAddress, audio: { port: audioPort, srtp_key: remoteAudioSrtpKey, srtp_salt: remoteAudioSrtpSalt, }, video: { port: videoPort }, } = this.prepareStreamRequest, 
             // use to encrypt Ring video to HomeKit
-            audioSrtpSession = new werift_1.SrtpSession(getSessionConfig(this.audioSrtp)), videoSrtpSession = new werift_1.SrtpSession(getSessionConfig(this.videoSrtp));
-            let firstTimestamp = 0, packetCount = 0;
-            // Set up packet forwarding for audio stream
-            this.liveCall.addSubscriptions(this.liveCall.onAudioRtp.subscribe(({ header, payload }) => {
-                if (!firstTimestamp) {
-                    firstTimestamp = header.timestamp;
-                }
-                header.ssrc = this.audioSsrc;
-                header.payloadType = request.audio.pt;
-                header.timestamp = firstTimestamp + packetCount * 3 * 160;
-                packetCount++;
-                const encryptedPacket = audioSrtpSession.encrypt(payload, header);
-                this.audioSplitter
-                    .send(encryptedPacket, {
-                    port: audioPort,
-                    address: targetAddress,
-                })
-                    .catch(util_1.logError);
-            }));
+            videoSrtpSession = new werift_1.SrtpSession(getSessionConfig(this.videoSrtp));
             // Set up packet forwarding for video stream
             this.liveCall.addSubscriptions(this.liveCall.onVideoRtp.subscribe(({ header, payload }) => {
                 header.ssrc = this.videoSsrc;
@@ -144,7 +120,109 @@ class StreamingSession {
                 })
                     .catch(util_1.logError);
             }));
-            yield this.liveCall.activate();
+            const shouldTranscodeAudio = yield this.libfdkAacInstalledPromise;
+            if (!shouldTranscodeAudio) {
+                return this.liveCall.activate();
+            }
+            const transcodingPromise = this.liveCall.startTranscoding({
+                input: ['-vn'],
+                audio: [
+                    '-map',
+                    '0:a',
+                    // OPUS specific - it works, but audio is very choppy
+                    // '-acodec',
+                    // 'libopus',
+                    // '-vbr',
+                    // 'on',
+                    // '-frame_duration',
+                    // 20,
+                    // '-application',
+                    // 'lowdelay',
+                    // AAC-eld specific
+                    '-acodec',
+                    'libfdk_aac',
+                    '-profile:a',
+                    'aac_eld',
+                    // Shared options
+                    '-flags',
+                    '+global_header',
+                    '-ac',
+                    `${request.audio.channel}`,
+                    '-ar',
+                    `${request.audio.sample_rate}k`,
+                    '-b:a',
+                    `${request.audio.max_bit_rate}k`,
+                    '-bufsize',
+                    `${request.audio.max_bit_rate * 4}k`,
+                    '-payload_type',
+                    request.audio.pt,
+                    '-ssrc',
+                    this.audioSsrc,
+                    '-f',
+                    'rtp',
+                    '-srtp_out_suite',
+                    'AES_CM_128_HMAC_SHA1_80',
+                    '-srtp_out_params',
+                    (0, camera_utils_1.encodeSrtpOptions)(this.audioSrtp),
+                    `srtp://${targetAddress}:${audioPort}?pkt_size=188`,
+                ],
+                video: false,
+                output: [],
+            });
+            let cameraSpeakerActive = false;
+            // used to decrypt return audio from HomeKit to Ring
+            const remoteAudioSrtpOptions = {
+                srtpKey: remoteAudioSrtpKey,
+                srtpSalt: remoteAudioSrtpSalt,
+            }, audioSrtpSession = new werift_1.SrtpSession(getSessionConfig(remoteAudioSrtpOptions)), returnAudioTranscodedSplitter = new camera_utils_1.RtpSplitter(({ message }) => {
+                if (!cameraSpeakerActive) {
+                    cameraSpeakerActive = true;
+                    this.liveCall.activateCameraSpeaker().catch(util_1.logError);
+                }
+                // decrypt the message
+                try {
+                    const rtp = werift_1.RtpPacket.deSerialize(message);
+                    rtp.payload = audioSrtpSession.decrypt(rtp.payload);
+                    // send to Ring - werift will handle encryption and other header params
+                    this.liveCall.sendAudioPacket(rtp);
+                }
+                catch (_) {
+                    // deSerialize will sometimes fail, but the errors can be ignored
+                }
+                return null;
+            }), returnAudioTranscoder = new camera_utils_1.ReturnAudioTranscoder({
+                prepareStreamRequest: this.prepareStreamRequest,
+                incomingAudioOptions: {
+                    ssrc: this.audioSsrc,
+                    rtcpPort: 0, // we don't care about rtcp for incoming audio
+                },
+                outputArgs: [
+                    '-acodec',
+                    'libopus',
+                    '-flags',
+                    '+global_header',
+                    '-ac',
+                    2,
+                    '-ar',
+                    '48k',
+                    '-f',
+                    'rtp',
+                    `rtp://127.0.0.1:${yield returnAudioTranscodedSplitter.portPromise}`,
+                ],
+                ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
+                logger: {
+                    info: util_1.logDebug,
+                    error: util_1.logError,
+                },
+                logLabel: `Return Audio (${this.ringCamera.name})`,
+                returnAudioSplitter: this.audioSplitter,
+            });
+            this.liveCall.onCallEnded.pipe((0, operators_1.take)(1)).subscribe(() => {
+                returnAudioTranscoder.stop();
+                returnAudioTranscodedSplitter.close();
+            });
+            yield returnAudioTranscoder.start();
+            yield transcodingPromise;
         });
     }
     stop() {
@@ -181,8 +259,8 @@ class CameraSource {
                 audio: {
                     codecs: [
                         {
-                            type: "OPUS" /* OPUS */,
-                            samplerate: 24 /* KHZ_24 */,
+                            type: "AAC-eld" /* AAC_ELD */,
+                            samplerate: 16 /* KHZ_16 */,
                         },
                     ],
                 },

package/lib/homebridge/ring-platform.js

@@ -211,8 +211,7 @@ class RingPlatform {
                 }
                 this.log.info(`Configuring ${cameras.length} cameras and ${hapDevices.length} devices for location "${location.name}" - locationId: ${location.id}`);
                 hapDevices.forEach(({ deviceType, device, isCamera, id, name, AccessoryClass }) => {
-                    // the opus qualifier is used to force new camera accessories to be created that support opus instead of aac
-                    const cameraOpusQualifier = isCamera ? 'opus' : '', uuid = hap_1.hap.uuid.generate(debugPrefix + id + cameraOpusQualifier), displayName = debugPrefix + name;
+                    const uuid = hap_1.hap.uuid.generate(debugPrefix + id), displayName = debugPrefix + name;
                     if (!AccessoryClass ||
                         (config.hideLightGroups &&
                             deviceType === api_1.RingDeviceType.BeamsLightGroupSwitch) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-ring",
-  "version": "10.0.0-beta.0",
+  "version": "10.0.0-beta.3",
   "description": "Homebridge plugin for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/homebridge/index.js",
   "bin": {

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;