homebridge-ring 9.25.0-beta.0 → 9.25.0-beta.1

package/CHANGELOG.md

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

package/lib/api/live-call.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 LiveCall extends Subscribed {
+    private sessionId;
+    private camera;
+    private readonly ws;
+    private readonly onWsOpen;
+    private readonly onMessage;
+    private readonly pc;
+    readonly onCallAnswered: ReplaySubject<void>;
+    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>;
+    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 sendMessage;
+    private callEnded;
+    stop(): void;
+    sendAudioPacket(rtp: RtpPacket): void;
+}
+export {};

package/lib/api/live-call.js

@@ -0,0 +1,201 @@
+"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();
+                    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];
+        });
+    }
+    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({
+                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.onCallEnded.subscribe(() => ff.stop());
+            ff.writeStdin(inputSdpLines.filter((x) => Boolean(x)).join('\n'));
+            // 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/ring-camera.d.ts

@@ -7,6 +7,7 @@ import { DeepPartial } from './util';
 import { FfmpegOptions, SipSession } from './sip-session';
 import { SipOptions } from './sip-call';
 import { Subscribed } from './subscribed';
+import { 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;
@@ -54,6 +55,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>;
     startVideoOnDemand(): Promise<("" | ActiveDing) & import("./rest-client").ExtendedResponse>;
     private pollForActiveDing;
     private expiredDingIds;

package/lib/api/ring-camera.js

@@ -18,6 +18,7 @@ const camera_utils_1 = require("@homebridge/camera-utils");
 const util_1 = require("./util");
 const sip_session_1 = require("./sip-session");
 const subscribed_1 = require("./subscribed");
+const live_call_1 = require("./live-call");
 const maxSnapshotRefreshSeconds = 15, fullDayMs = 24 * 60 * 60 * 1000;
 function parseBatteryLife(batteryLife) {
     if (batteryLife === null || batteryLife === undefined) {
@@ -231,6 +232,25 @@ class RingCamera extends subscribed_1.Subscribed {
             return response.device_health;
         });
     }
+    startLiveCall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const liveCall = yield this.restClient
+                .request({
+                method: 'POST',
+                url: this.doorbotUrl('live_call'),
+            })
+                .catch((e) => {
+                var _a;
+                if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 403) {
+                    const errorMessage = `Camera ${this.name} returned 403 when starting a live stream.  This usually indicates that live streaming is blocked by Modes settings.  Check your Ring app and verify that you are able to stream from this camera with the current Modes settings.`;
+                    (0, util_1.logError)(errorMessage);
+                    throw new Error(errorMessage);
+                }
+                throw e;
+            });
+            return new live_call_1.LiveCall(liveCall.data.session_id, this);
+        });
+    }
     startVideoOnDemand() {
         return this.restClient
             .request({
@@ -439,10 +459,11 @@ class RingCamera extends subscribed_1.Subscribed {
     }
     recordToFile(outputPath, duration = 30) {
         return __awaiter(this, void 0, void 0, function* () {
-            const sipSession = yield this.streamVideo({
+            const liveCall = yield this.startLiveCall();
+            yield liveCall.startTranscoding({
                 output: ['-t', duration.toString(), outputPath],
             });
-            yield (0, rxjs_1.firstValueFrom)(sipSession.onCallEnded);
+            yield (0, rxjs_1.firstValueFrom)(liveCall.onCallEnded);
         });
     }
     streamVideo(ffmpegOptions) {

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

@@ -688,6 +688,21 @@ export interface ActiveDing {
     sip_token: string;
     sip_ding_id: string;
 }
+export interface LiveCallResponse {
+    ding_id: string;
+    ding_kind: DingKind;
+    device_id: number;
+    device_kind: RingCameraKind;
+    device_description: string;
+    state: DingState;
+    protocol: 'ring_media_server' | unknown;
+    now: number;
+    video_jitter_buffer_ms: number;
+    audio_jitter_buffer_ms: number;
+    data: {
+        session_id: string;
+    };
+}
 export interface AuthTokenResponse {
     access_token: string;
     expires_in: number;

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

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { RtpSplitter, SrtpOptions } from '@homebridge/camera-utils';
+import { DingKind } from './ring-types';
 export interface RtpStreamOptions extends SrtpOptions {
     port: number;
     rtcpPort: number;
@@ -27,3 +28,28 @@ export declare function sendStunBindingRequest({ rtpDescription, rtpSplitter, rt
     type: 'video' | 'audio';
 }): void;
 export declare function createStunResponder(rtpSplitter: RtpSplitter): void;
+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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStunResponder = exports.sendStunBindingRequest = exports.isStunMessage = void 0;
+exports.parseLiveCallSession = exports.createStunResponder = exports.sendStunBindingRequest = exports.isStunMessage = void 0;
 const util_1 = require("./util");
 const stun = require('stun');
 const stunMagicCookie = 0x2112a442; // https://tools.ietf.org/html/rfc5389#section-6
@@ -54,3 +54,8 @@ function createStunResponder(rtpSplitter) {
     });
 }
 exports.createStunResponder = createStunResponder;
+function parseLiveCallSession(sessionId) {
+    const encodedSession = sessionId.split('.')[1], buff = new Buffer(encodedSession, 'base64'), text = buff.toString('ascii');
+    return JSON.parse(text);
+}
+exports.parseLiveCallSession = parseLiveCallSession;

package/lib/homebridge/camera-source.d.ts

@@ -12,5 +12,5 @@ export declare class CameraSource implements CameraStreamingDelegate {
     private getCurrentSnapshot;
     handleSnapshotRequest(request: SnapshotRequest, callback: SnapshotRequestCallback): Promise<void>;
     prepareStream(request: PrepareStreamRequest, callback: PrepareStreamCallback): Promise<void>;
-    handleStreamRequest(request: StreamingRequest, callback: StreamRequestCallback): void;
+    handleStreamRequest(request: StreamingRequest, callback: StreamRequestCallback): Promise<void>;
 }

package/lib/homebridge/camera-source.js

@@ -17,12 +17,220 @@ const operators_1 = require("rxjs/operators");
 const rxjs_1 = require("rxjs");
 const fs_1 = require("fs");
 const util_2 = require("util");
-const rtp_utils_1 = require("../api/rtp-utils");
 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) {
     return (Date.now() - start) / 1000;
 }
+function getSessionConfig(srtpOptions) {
+    return {
+        keys: {
+            localMasterKey: srtpOptions.srtpKey,
+            localMasterSalt: srtpOptions.srtpSalt,
+            remoteMasterKey: srtpOptions.srtpKey,
+            remoteMasterSalt: srtpOptions.srtpSalt,
+        },
+        profile: 1,
+    };
+}
+class StreamingSession {
+    constructor(liveCall, prepareStreamRequest, ringCamera, start) {
+        this.liveCall = liveCall;
+        this.prepareStreamRequest = prepareStreamRequest;
+        this.ringCamera = ringCamera;
+        this.start = start;
+        this.audioSsrc = hap_1.hap.CameraController.generateSynchronisationSource();
+        this.videoSsrc = hap_1.hap.CameraController.generateSynchronisationSource();
+        this.audioSrtp = (0, camera_utils_1.generateSrtpOptions)();
+        this.videoSrtp = (0, camera_utils_1.generateSrtpOptions)();
+        this.audioSplitter = new camera_utils_1.RtpSplitter();
+        this.videoSplitter = new camera_utils_1.RtpSplitter();
+        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
+        // This can happen if the user force-quits the Home app
+        this.videoSplitter.addMessageHandler(() => {
+            // return packet from HomeKit
+            onReturnPacketReceived.next(null);
+            return null;
+        });
+        this.audioSplitter.addMessageHandler(() => {
+            // return packet from HomeKit
+            onReturnPacketReceived.next(null);
+            return null;
+        });
+        liveCall.addSubscriptions((0, rxjs_1.merge)((0, rxjs_1.of)(true).pipe((0, operators_1.delay)(15000)), onReturnPacketReceived)
+            .pipe((0, operators_1.debounceTime)(5000))
+            .subscribe(() => {
+            (0, util_1.logInfo)(`Live stream for ${this.ringCamera.name} appears to be inactive. (${getDurationSeconds(start)}s)`);
+            liveCall.stop();
+        }));
+        // Periodically send a blank RTCP packet to the HomeKit video port
+        // Without this, HomeKit assumes the stream is dead after 30 second and sends a stop request
+        liveCall.addSubscriptions((0, rxjs_1.interval)(500).subscribe(() => {
+            const senderInfo = new werift_1.RtcpSenderInfo({
+                ntpTimestamp: BigInt(0),
+                packetCount: 0,
+                octetCount: 0,
+                rtpTimestamp: 0,
+            }), senderReport = new werift_1.RtcpSrPacket({
+                ssrc: this.videoSsrc,
+                senderInfo: senderInfo,
+            }), message = videoSrtcpSession.encrypt(senderReport.serialize());
+            this.videoSplitter
+                .send(message, {
+                port: videoPort,
+                address: targetAddress,
+            })
+                .catch(util_1.logError);
+        }));
+    }
+    activate(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let sentVideo = false;
+            const { targetAddress, audio: { port: audioPort, srtp_key: remoteAudioSrtpKey, srtp_salt: remoteAudioSrtpSalt, }, video: { port: videoPort }, } = this.prepareStreamRequest, 
+            // use to encrypt Ring video to HomeKit
+            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;
+                header.payloadType = request.video.pt;
+                const encryptedPacket = videoSrtpSession.encrypt(payload, header);
+                if (!sentVideo) {
+                    sentVideo = true;
+                    (0, util_1.logInfo)(`Received stream data from ${this.ringCamera.name} (${getDurationSeconds(this.start)}s)`);
+                }
+                this.videoSplitter
+                    .send(encryptedPacket, {
+                    port: videoPort,
+                    address: targetAddress,
+                })
+                    .catch(util_1.logError);
+            }));
+            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',
+                    1,
+                    '-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() {
+        this.audioSplitter.close();
+        this.videoSplitter.close();
+        this.liveCall.stop();
+    }
+}
 class CameraSource {
     constructor(ringCamera) {
         this.ringCamera = ringCamera;
@@ -142,213 +350,23 @@ class CameraSource {
             const start = Date.now();
             (0, util_1.logInfo)(`Preparing Live Stream for ${this.ringCamera.name}`);
             try {
-                const { sessionID, targetAddress, audio: { port: audioPort, srtp_key: audioSrtpKey, srtp_salt: audioSrtpSalt, }, video: { port: videoPort, srtp_key: videoSrtpKey, srtp_salt: videoSrtpSalt, }, } = request, ffmpegPath = (0, ffmpeg_1.getFfmpegPath)(), [sipSession, libfdkAacInstalled] = yield Promise.all([
-                    this.ringCamera.createSipSession({
-                        audio: {
-                            srtpKey: audioSrtpKey,
-                            srtpSalt: audioSrtpSalt,
-                        },
-                        video: {
-                            srtpKey: videoSrtpKey,
-                            srtpSalt: videoSrtpSalt,
-                        },
-                        skipFfmpegCheck: true,
-                    }),
-                    (0, camera_utils_1.doesFfmpegSupportCodec)('libfdk_aac', ffmpegPath)
-                        .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;
-                    }),
-                ]), onReturnPacketReceived = new rxjs_1.Subject();
-                sipSession.addSubscriptions((0, rxjs_1.merge)((0, rxjs_1.of)(true).pipe((0, operators_1.delay)(15000)), onReturnPacketReceived)
-                    .pipe((0, operators_1.debounceTime)(5000))
-                    .subscribe(() => {
-                    (0, util_1.logInfo)(`Live stream for ${this.ringCamera.name} appears to be inactive. (${getDurationSeconds(start)}s)`);
-                    sipSession.stop();
-                }));
-                this.sessions[sessionID] = sipSession;
-                const audioSsrc = hap_1.hap.CameraController.generateSynchronisationSource(), incomingAudioRtcpPort = yield sipSession.reservePort(), videoSsrcPromise = (0, rxjs_1.firstValueFrom)(sipSession.videoSplitter.onMessage.pipe((0, operators_1.filter)(({ info }) => info.address !== targetAddress), // Ignore return packets from HomeKit
-                (0, operators_1.map)((m) => (0, camera_utils_1.getSsrc)(m.message)), (0, operators_1.filter)((ssrc) => ssrc !== null))).catch(() => 0), ringRtpDescription = yield sipSession.start(libfdkAacInstalled
-                    ? {
-                        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',
-                            1,
-                            '-ar',
-                            '16k',
-                            '-b:a',
-                            '24k',
-                            '-bufsize',
-                            '24k',
-                            '-payload_type',
-                            110,
-                            '-ssrc',
-                            audioSsrc,
-                            '-f',
-                            'rtp',
-                            '-srtp_out_suite',
-                            'AES_CM_128_HMAC_SHA1_80',
-                            '-srtp_out_params',
-                            (0, camera_utils_1.encodeSrtpOptions)(sipSession.rtpOptions.audio),
-                            `srtp://${targetAddress}:${audioPort}?localrtcpport=${incomingAudioRtcpPort}&pkt_size=188`,
-                        ],
-                        video: false,
-                        output: [],
-                    }
-                    : undefined);
-                let videoPacketReceived = false;
-                sipSession.videoSplitter.addMessageHandler(({ info, message, isRtpMessage }) => {
-                    if (info.address === targetAddress) {
-                        // return packet from HomeKit
-                        onReturnPacketReceived.next(null);
-                        if (!isRtpMessage) {
-                            // Only need to handle RTCP packets.  We really shouldn't receive RTP, but check just in case
-                            sipSession.videoRtcpSplitter
-                                .send(message, {
-                                port: ringRtpDescription.video.rtcpPort,
-                                address: ringRtpDescription.address,
-                            })
-                                .catch(util_1.logError);
-                        }
-                        // don't need to forward it along from the RTP splitter since it's only RTCP we care about
-                        return null;
-                    }
-                    if ((0, rtp_utils_1.isStunMessage)(message) || !isRtpMessage) {
-                        // we don't need to forward stun messages to HomeKit since they are for connection establishment purposes only
-                        // if not rtp, probably rtcp which will be handled from rtcp splitter
-                        return null;
-                    }
-                    if (!videoPacketReceived) {
-                        videoPacketReceived = true;
-                        (0, util_1.logInfo)(`Received stream data from ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
-                    }
-                    return {
-                        port: videoPort,
-                        address: targetAddress,
-                    };
-                });
-                sipSession.videoRtcpSplitter.addMessageHandler(({ message, info, isRtpMessage }) => {
-                    // for ICE connections, Rtcp splitter is the same as Rtp splitter, so we need to filter other messages out
-                    if ((0, rtp_utils_1.isStunMessage)(message) ||
-                        isRtpMessage ||
-                        info.address === targetAddress) {
-                        return null;
-                    }
-                    sipSession.videoSplitter
-                        .send(message, {
-                        port: videoPort,
-                        address: targetAddress,
-                    })
-                        .catch(util_1.logError);
-                    return null;
-                });
-                let returnAudioPort = null;
-                if (libfdkAacInstalled) {
-                    let cameraSpeakerActive = false;
-                    const ringAudioLocation = {
-                        address: ringRtpDescription.address,
-                        port: ringRtpDescription.audio.port,
-                    }, returnAudioTranscodedSplitter = new camera_utils_1.RtpSplitter((description) => {
-                        if (!cameraSpeakerActive) {
-                            cameraSpeakerActive = true;
-                            sipSession.activateCameraSpeaker().catch(util_1.logError);
-                        }
-                        sipSession.audioSplitter
-                            .send(description.message, ringAudioLocation)
-                            .catch(util_1.logError);
-                        return null;
-                    }), returnAudioTranscoder = new camera_utils_1.ReturnAudioTranscoder({
-                        prepareStreamRequest: request,
-                        incomingAudioOptions: {
-                            ssrc: audioSsrc,
-                            rtcpPort: incomingAudioRtcpPort,
-                        },
-                        outputArgs: [
-                            '-acodec',
-                            'pcm_mulaw',
-                            '-flags',
-                            '+global_header',
-                            '-ac',
-                            1,
-                            '-ar',
-                            '8k',
-                            '-f',
-                            'rtp',
-                            '-srtp_out_suite',
-                            'AES_CM_128_HMAC_SHA1_80',
-                            '-srtp_out_params',
-                            (0, camera_utils_1.encodeSrtpOptions)(sipSession.rtpOptions.audio),
-                            `srtp://127.0.0.1:${yield returnAudioTranscodedSplitter.portPromise}?pkt_size=188`,
-                        ],
-                        ffmpegPath,
-                        logger: {
-                            info: util_1.logDebug,
-                            error: util_1.logError,
-                        },
-                        logLabel: `Return Audio (${this.ringCamera.name})`,
-                    });
-                    sipSession.onCallEnded.pipe((0, operators_1.take)(1)).subscribe(() => {
-                        returnAudioTranscoder.stop();
-                        returnAudioTranscodedSplitter.close();
-                    });
-                    returnAudioPort = yield returnAudioTranscoder.start();
-                }
-                let videoSsrc = ringRtpDescription.video.ssrc;
-                if (videoSsrc) {
-                    // Server supported ICE, which means response SDP included SSRC
-                    (0, util_1.logInfo)(`Stream Prepared for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
-                }
-                else {
-                    // Server uses RTP latching.  Need to wait for first packet to determine SSRC
-                    // NOTE: we could avoid this if we want to decrypt/re-encrypt each packets with a new SSRC
-                    (0, util_1.logInfo)(`Waiting for stream data from ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
-                    videoSsrc = yield videoSsrcPromise;
-                }
-                if (!videoSsrc) {
-                    // failed to get video packet
-                    (0, util_1.logInfo)(`Stream was closed before it was ready for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
-                    return callback(undefined);
-                }
+                const liveCall = yield this.ringCamera.startLiveCall(), session = new StreamingSession(liveCall, request, this.ringCamera, start);
+                this.sessions[request.sessionID] = session;
+                (0, util_1.logInfo)(`Stream Prepared for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
                 callback(undefined, {
                     // SOMEDAY: remove address as it is not needed after homebridge 1.1.3
                     address: yield (0, camera_utils_1.getDefaultIpAddress)(request.addressVersion === 'ipv6'),
                     audio: {
-                        // if audio isn't supported, pipe rtcp to incomingAudioRtcpPort which will not actually be bound
-                        port: returnAudioPort || incomingAudioRtcpPort,
-                        ssrc: audioSsrc,
-                        srtp_key: audioSrtpKey,
-                        srtp_salt: audioSrtpSalt,
+                        port: yield session.audioSplitter.portPromise,
+                        ssrc: session.audioSsrc,
+                        srtp_key: session.audioSrtp.srtpKey,
+                        srtp_salt: session.audioSrtp.srtpSalt,
                     },
                     video: {
-                        port: yield sipSession.videoSplitter.portPromise,
-                        ssrc: videoSsrc,
-                        srtp_key: ringRtpDescription.video.srtpKey,
-                        srtp_salt: ringRtpDescription.video.srtpSalt,
+                        port: yield session.videoSplitter.portPromise,
+                        ssrc: session.videoSsrc,
+                        srtp_key: session.videoSrtp.srtpKey,
+                        srtp_salt: session.videoSrtp.srtpSalt,
                     },
                 });
             }
@@ -360,22 +378,24 @@ class CameraSource {
         });
     }
     handleStreamRequest(request, callback) {
-        const sessionID = request.sessionID, session = this.sessions[sessionID], requestType = request.type;
-        if (!session) {
-            callback(new Error('Cannot find session for stream ' + sessionID));
-            return;
-        }
-        if (requestType === 'start') {
-            (0, util_1.logInfo)(`Streaming active for ${this.ringCamera.name}`);
-            // sip/rtp already started at this point, but request a key frame so that HomeKit for sure has one
-            session.requestKeyFrame().catch(rxjs_1.noop);
-        }
-        else if (requestType === 'stop') {
-            (0, util_1.logInfo)(`Stopped Live Stream for ${this.ringCamera.name}`);
-            session.stop();
-            delete this.sessions[sessionID];
-        }
-        callback();
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessionID = request.sessionID, session = this.sessions[sessionID], requestType = request.type;
+            if (!session) {
+                callback(new Error('Cannot find session for stream ' + sessionID));
+                return;
+            }
+            if (requestType === 'start') {
+                (0, util_1.logInfo)(`Activating stream for ${this.ringCamera.name} (${getDurationSeconds(session.start)}s)`);
+                yield session.activate(request);
+                (0, util_1.logInfo)(`Streaming active for ${this.ringCamera.name} (${getDurationSeconds(session.start)}s)`);
+            }
+            else if (requestType === 'stop') {
+                (0, util_1.logInfo)(`Stopped Live Stream for ${this.ringCamera.name}`);
+                session.stop();
+                delete this.sessions[sessionID];
+            }
+            callback();
+        });
     }
 }
 exports.CameraSource = CameraSource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-ring",
-  "version": "9.25.0-beta.0",
+  "version": "9.25.0-beta.1",
   "description": "Homebridge plugin for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/homebridge/index.js",
   "bin": {
@@ -39,8 +39,9 @@
   "author": "dgreif",
   "license": "MIT",
   "dependencies": {
-    "@homebridge/camera-utils": "2.0.4",
+    "@homebridge/camera-utils": "2.1.0",
     "@homebridge/plugin-ui-utils": "0.0.19",
+    "@koush/werift": "0.14.5-beta5",
     "@types/socket.io-client": "1.4.36",
     "colors": "1.4.0",
     "debug": "4.3.3",
@@ -50,18 +51,21 @@
     "socket.io-client": "2.4.0",
     "stun": "2.1.0",
     "systeminformation": "5.10.7",
-    "uuid": "8.3.2"
+    "uuid": "8.3.2",
+    "ws": "8.4.2"
   },
   "devDependencies": {
     "@types/debug": "4.1.7",
     "@types/jest": "27.4.0",
     "@types/node": "17.0.10",
     "@types/uuid": "8.3.4",
+    "@types/ws": "^8.2.2",
     "@typescript-eslint/eslint-plugin": "5.10.0",
     "@typescript-eslint/parser": "5.10.0",
     "concurrently": "^7.0.0",
     "conventional-github-releaser": "3.1.5",
     "dotenv": "14.2.0",
+    "esbuild": "^0.14.19",
     "eslint": "8.7.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-plugin-jest": "25.7.0",