homebridge-ring 11.5.0 → 11.5.2

package/lib/camera-source.js

@@ -1,23 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CameraSource", {
-    enumerable: true,
-    get: ()=>CameraSource
-});
-const _hap = require("./hap");
-const _cameraUtils = require("@homebridge/camera-utils");
-const _homebridge = require("homebridge");
-const _util = require("ring-client-api/util");
-const _operators = require("rxjs/operators");
-const _rxjs = require("rxjs");
-const _fs = require("fs");
-const _util1 = require("util");
-const _ffmpeg = require("ring-client-api/ffmpeg");
-const _werift = require("werift");
-const _opusRepacketizer = require("./opus-repacketizer");
-const readFileAsync = (0, _util1.promisify)(_fs.readFile), cameraOfflinePath = require.resolve('../media/camera-offline.jpg'), snapshotsBlockedPath = require.resolve('../media/snapshots-blocked.jpg');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraSource = void 0;
+const hap_1 = require("./hap");
+const camera_utils_1 = require("@homebridge/camera-utils");
+const util_1 = require("ring-client-api/util");
+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("ring-client-api/ffmpeg");
+const werift_1 = require("werift");
+const opus_repacketizer_1 = require("./opus-repacketizer");
+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;
 }
@@ -27,22 +21,87 @@ function getSessionConfig(srtpOptions) {
             localMasterKey: srtpOptions.srtpKey,
             localMasterSalt: srtpOptions.srtpSalt,
             remoteMasterKey: srtpOptions.srtpKey,
-            remoteMasterSalt: srtpOptions.srtpSalt
+            remoteMasterSalt: srtpOptions.srtpSalt,
         },
-        profile: 1
+        profile: 1,
     };
 }
 class StreamingSessionWrapper {
+    constructor(streamingSession, prepareStreamRequest, ringCamera, start) {
+        this.streamingSession = streamingSession;
+        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.repacketizeAudioSplitter = 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;
+        });
+        streamingSession.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)`);
+            streamingSession.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
+        streamingSession.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);
+        }));
+    }
     listenForAudioPackets(startStreamRequest) {
-        const { targetAddress , audio: { port: audioPort  }  } = this.prepareStreamRequest, { audio: { codec: audioCodec , sample_rate: audioSampleRate  }  } = startStreamRequest, // Repacketize the audio stream after it's been transcoded
-        opusRepacketizer = new _opusRepacketizer.OpusRepacketizer(1), audioIntervalScale = audioSampleRate / 8, audioSrtpSession = new _werift.SrtpSession(getSessionConfig(this.audioSrtp));
+        const { targetAddress, audio: { port: audioPort }, } = this.prepareStreamRequest, { audio: { codec: audioCodec, sample_rate: audioSampleRate }, } = startStreamRequest, 
+        // Repacketize the audio stream after it's been transcoded
+        opusRepacketizer = new opus_repacketizer_1.OpusRepacketizer(1), audioIntervalScale = audioSampleRate / 8, audioSrtpSession = new werift_1.SrtpSession(getSessionConfig(this.audioSrtp));
         let firstTimestamp, audioPacketCount = 0;
-        this.repacketizeAudioSplitter.addMessageHandler(({ message  })=>{
-            let rtp = _werift.RtpPacket.deSerialize(message);
-            if (audioCodec === _homebridge.AudioStreamingCodecType.OPUS) {
+        this.repacketizeAudioSplitter.addMessageHandler(({ message }) => {
+            let rtp = werift_1.RtpPacket.deSerialize(message);
+            if (audioCodec === "OPUS" /* AudioStreamingCodecType.OPUS */) {
                 // borrowed from scrypted
                 // Original source: https://github.com/koush/scrypted/blob/c13ba09889c3e0d9d3724cb7d49253c9d787fb97/plugins/homekit/src/types/camera/camera-streaming-srtp-sender.ts#L124-L143
-                rtp = opusRepacketizer.repacketize(_werift.RtpPacket.deSerialize(message));
+                rtp = opusRepacketizer.repacketize(werift_1.RtpPacket.deSerialize(message));
                 if (!rtp) {
                     return null;
                 }
@@ -63,63 +122,70 @@ class StreamingSessionWrapper {
                 // audio will work so long as the rtp timestamps are created properly: which is a construct of the sample rate
                 // HAP requests, and the packet time is respected,
                 // opus 48khz will work just fine.
-                rtp.header.timestamp = (firstTimestamp + audioPacketCount * 180 * audioIntervalScale) % 0xffffffff;
+                rtp.header.timestamp =
+                    (firstTimestamp + audioPacketCount * 180 * audioIntervalScale) %
+                        0xffffffff;
                 audioPacketCount++;
             }
             // encrypt the packet
             const encryptedPacket = audioSrtpSession.encrypt(rtp.payload, rtp.header);
             // send the encrypted packet to HomeKit
-            this.audioSplitter.send(encryptedPacket, {
+            this.audioSplitter
+                .send(encryptedPacket, {
                 port: audioPort,
-                address: targetAddress
-            }).catch(_util.logError);
+                address: targetAddress,
+            })
+                .catch(util_1.logError);
             return null;
         });
     }
     async activate(request) {
         let sentVideo = false;
-        const { targetAddress , audio: { srtp_key: remoteAudioSrtpKey , srtp_salt: remoteAudioSrtpSalt  } , video: { port: videoPort  }  } = this.prepareStreamRequest, // use to encrypt Ring video to HomeKit
-        videoSrtpSession = new _werift.SrtpSession(getSessionConfig(this.videoSrtp));
+        const { targetAddress, audio: { 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.streamingSession.addSubscriptions(this.streamingSession.onVideoRtp.subscribe(({ header , payload  })=>{
+        this.streamingSession.addSubscriptions(this.streamingSession.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.logInfo)(`Received stream data from ${this.ringCamera.name} (${getDurationSeconds(this.start)}s)`);
+                (0, util_1.logInfo)(`Received stream data from ${this.ringCamera.name} (${getDurationSeconds(this.start)}s)`);
             }
-            this.videoSplitter.send(encryptedPacket, {
+            this.videoSplitter
+                .send(encryptedPacket, {
                 port: videoPort,
-                address: targetAddress
-            }).catch(_util.logError);
+                address: targetAddress,
+            })
+                .catch(util_1.logError);
         }));
         const shouldTranscodeAudio = await this.libfdkAacInstalledPromise;
         if (!shouldTranscodeAudio) {
             return this.streamingSession.requestKeyFrame();
         }
         const transcodingPromise = this.streamingSession.startTranscoding({
-            input: [
-                '-vn'
-            ],
+            input: ['-vn'],
             audio: [
                 '-map',
                 '0:a',
-                ...request.audio.codec === _homebridge.AudioStreamingCodecType.OPUS ? [
-                    // OPUS specific - it works, but audio is very choppy
-                    '-acodec',
-                    'libopus',
-                    '-frame_duration',
-                    request.audio.packet_time,
-                    '-application',
-                    'lowdelay'
-                ] : [
-                    // AAC-eld specific
-                    '-acodec',
-                    'libfdk_aac',
-                    '-profile:a',
-                    'aac_eld'
-                ],
+                ...(request.audio.codec === "OPUS" /* AudioStreamingCodecType.OPUS */
+                    ? [
+                        // OPUS specific - it works, but audio is very choppy
+                        '-acodec',
+                        'libopus',
+                        '-frame_duration',
+                        request.audio.packet_time,
+                        '-application',
+                        'lowdelay',
+                    ]
+                    : [
+                        // AAC-eld specific
+                        '-acodec',
+                        'libfdk_aac',
+                        '-profile:a',
+                        'aac_eld',
+                    ]),
                 // Shared options
                 '-flags',
                 '+global_header',
@@ -137,68 +203,60 @@ class StreamingSessionWrapper {
                 this.audioSsrc,
                 '-f',
                 'rtp',
-                `rtp://127.0.0.1:${await this.repacketizeAudioSplitter.portPromise}?pkt_size=188`
+                `rtp://127.0.0.1:${await this.repacketizeAudioSplitter
+                    .portPromise}?pkt_size=188`,
             ],
             video: false,
-            output: []
+            output: [],
         });
         let cameraSpeakerActive = false;
         // used to decrypt return audio from HomeKit to Ring
         const remoteAudioSrtpOptions = {
             srtpKey: remoteAudioSrtpKey,
-            srtpSalt: remoteAudioSrtpSalt
-        }, audioSrtpSession = new _werift.SrtpSession(getSessionConfig(remoteAudioSrtpOptions)), returnAudioTranscodedSplitter = new _cameraUtils.RtpSplitter(({ message  })=>{
+            srtpSalt: remoteAudioSrtpSalt,
+        }, audioSrtpSession = new werift_1.SrtpSession(getSessionConfig(remoteAudioSrtpOptions)), returnAudioTranscodedSplitter = new camera_utils_1.RtpSplitter(({ message }) => {
             if (!cameraSpeakerActive) {
                 cameraSpeakerActive = true;
                 this.streamingSession.activateCameraSpeaker();
             }
             // decrypt the message
             try {
-                const rtp = _werift.RtpPacket.deSerialize(message);
+                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.streamingSession.sendAudioPacket(rtp);
-            } catch (_) {
-            // deSerialize will sometimes fail, but the errors can be ignored
+            }
+            catch (_) {
+                // deSerialize will sometimes fail, but the errors can be ignored
             }
             return null;
-        }), isRingUsingOpus = await this.streamingSession.isUsingOpus, returnAudioTranscoder = new _cameraUtils.ReturnAudioTranscoder({
+        }), isRingUsingOpus = await this.streamingSession.isUsingOpus, returnAudioTranscoder = new camera_utils_1.ReturnAudioTranscoder({
             prepareStreamRequest: this.prepareStreamRequest,
             startStreamRequest: request,
             incomingAudioOptions: {
                 ssrc: this.audioSsrc,
-                rtcpPort: 0
+                rtcpPort: 0, // we don't care about rtcp for incoming audio
             },
             outputArgs: [
                 '-acodec',
-                ...isRingUsingOpus ? [
-                    'libopus',
-                    '-ac',
-                    2,
-                    '-ar',
-                    '48k'
-                ] : [
-                    'pcm_mulaw',
-                    '-ac',
-                    1,
-                    '-ar',
-                    '8k'
-                ],
+                ...(isRingUsingOpus
+                    ? ['libopus', '-ac', 2, '-ar', '48k']
+                    : ['pcm_mulaw', '-ac', 1, '-ar', '8k']),
                 '-flags',
                 '+global_header',
                 '-f',
                 'rtp',
-                `rtp://127.0.0.1:${await returnAudioTranscodedSplitter.portPromise}`
+                `rtp://127.0.0.1:${await returnAudioTranscodedSplitter.portPromise}`,
             ],
-            ffmpegPath: (0, _ffmpeg.getFfmpegPath)(),
+            ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
             logger: {
-                info: _util.logDebug,
-                error: _util.logError
+                info: util_1.logDebug,
+                error: util_1.logError,
             },
             logLabel: `Return Audio (${this.ringCamera.name})`,
-            returnAudioSplitter: this.audioSplitter
+            returnAudioSplitter: this.audioSplitter,
         });
-        this.streamingSession.onCallEnded.pipe((0, _operators.take)(1)).subscribe(()=>{
+        this.streamingSession.onCallEnded.pipe((0, operators_1.take)(1)).subscribe(() => {
             returnAudioTranscoder.stop();
             returnAudioTranscodedSplitter.close();
         });
@@ -212,65 +270,62 @@ class StreamingSessionWrapper {
         this.videoSplitter.close();
         this.streamingSession.stop();
     }
-    constructor(streamingSession, prepareStreamRequest, ringCamera, start){
-        this.streamingSession = streamingSession;
-        this.prepareStreamRequest = prepareStreamRequest;
+}
+class CameraSource {
+    constructor(ringCamera, useOpus = false) {
         this.ringCamera = ringCamera;
-        this.start = start;
-        this.audioSsrc = _hap.hap.CameraController.generateSynchronisationSource();
-        this.videoSsrc = _hap.hap.CameraController.generateSynchronisationSource();
-        this.audioSrtp = (0, _cameraUtils.generateSrtpOptions)();
-        this.videoSrtp = (0, _cameraUtils.generateSrtpOptions)();
-        this.audioSplitter = new _cameraUtils.RtpSplitter();
-        this.videoSplitter = new _cameraUtils.RtpSplitter();
-        this.repacketizeAudioSplitter = new _cameraUtils.RtpSplitter();
-        this.libfdkAacInstalledPromise = (0, _cameraUtils.doesFfmpegSupportCodec)('libfdk_aac', (0, _ffmpeg.getFfmpegPath)()).then((supported)=>{
-            if (!supported) {
-                (0, _util.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.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.SrtcpSession(getSessionConfig(this.videoSrtp)), onReturnPacketReceived = new _rxjs.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;
+        this.useOpus = useOpus;
+        this.controller = new hap_1.hap.CameraController({
+            cameraStreamCount: 10,
+            delegate: this,
+            streamingOptions: {
+                supportedCryptoSuites: [0 /* SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80 */],
+                video: {
+                    resolutions: [
+                        [1280, 720, 30],
+                        [1024, 768, 30],
+                        [640, 480, 30],
+                        [640, 360, 30],
+                        [480, 360, 30],
+                        [480, 270, 30],
+                        [320, 240, 30],
+                        [320, 240, 15],
+                        [320, 180, 30],
+                    ],
+                    codec: {
+                        profiles: [0 /* H264Profile.BASELINE */],
+                        levels: [0 /* H264Level.LEVEL3_1 */],
+                    },
+                },
+                audio: {
+                    codecs: this.useOpus
+                        ? [
+                            {
+                                type: "OPUS" /* AudioStreamingCodecType.OPUS */,
+                                // required by watch
+                                samplerate: 8 /* AudioStreamingSamplerate.KHZ_8 */,
+                            },
+                            {
+                                type: "OPUS" /* AudioStreamingCodecType.OPUS */,
+                                samplerate: 16 /* AudioStreamingSamplerate.KHZ_16 */,
+                            },
+                            {
+                                type: "OPUS" /* AudioStreamingCodecType.OPUS */,
+                                samplerate: 24 /* AudioStreamingSamplerate.KHZ_24 */,
+                            },
+                        ]
+                        : [
+                            {
+                                type: "AAC-eld" /* AudioStreamingCodecType.AAC_ELD */,
+                                samplerate: 16 /* AudioStreamingSamplerate.KHZ_16 */,
+                            },
+                        ],
+                },
+            },
         });
-        streamingSession.addSubscriptions((0, _rxjs.merge)((0, _rxjs.of)(true).pipe((0, _operators.delay)(15000)), onReturnPacketReceived).pipe((0, _operators.debounceTime)(5000)).subscribe(()=>{
-            (0, _util.logInfo)(`Live stream for ${this.ringCamera.name} appears to be inactive. (${getDurationSeconds(start)}s)`);
-            streamingSession.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
-        streamingSession.addSubscriptions((0, _rxjs.interval)(500).subscribe(()=>{
-            const senderInfo = new _werift.RtcpSenderInfo({
-                ntpTimestamp: BigInt(0),
-                packetCount: 0,
-                octetCount: 0,
-                rtpTimestamp: 0
-            }), senderReport = new _werift.RtcpSrPacket({
-                ssrc: this.videoSsrc,
-                senderInfo: senderInfo
-            }), message = videoSrtcpSession.encrypt(senderReport.serialize());
-            this.videoSplitter.send(message, {
-                port: videoPort,
-                address: targetAddress
-            }).catch(_util.logError);
-        }));
+        this.sessions = {};
+        this.fn = 1;
     }
-}
-class CameraSource {
     async loadSnapshot(imageUuid) {
         // cache a promise of the snapshot load
         // This prevents multiple concurrent requests for snapshot from pilling up and creating lots of logs
@@ -280,37 +335,38 @@ class CameraSource {
         this.previousLoadSnapshotPromise = this.loadAndCacheSnapshot(imageUuid);
         try {
             await this.previousLoadSnapshotPromise;
-        } catch (_) {
-        // ignore errors
-        } finally{
+        }
+        catch (_) {
+            // ignore errors
+        }
+        finally {
             // clear so another request can be made
             this.previousLoadSnapshotPromise = undefined;
         }
     }
     async loadAndCacheSnapshot(imageUuid) {
         const start = Date.now();
-        (0, _util.logDebug)(`Loading new snapshot into cache for ${this.ringCamera.name}${imageUuid ? ' by uuid' : ''}`);
+        (0, util_1.logDebug)(`Loading new snapshot into cache for ${this.ringCamera.name}${imageUuid ? ' by uuid' : ''}`);
         try {
-            const previousSnapshot = this.cachedSnapshot, newSnapshot = await this.ringCamera.getSnapshot({
-                uuid: imageUuid
-            });
+            const previousSnapshot = this.cachedSnapshot, newSnapshot = await this.ringCamera.getSnapshot({ uuid: imageUuid });
             this.cachedSnapshot = newSnapshot;
             if (previousSnapshot !== newSnapshot) {
                 // Keep the snapshots in cache 2 minutes longer than their lifetime
                 // This allows users on LTE with wired camera to get snapshots each 60 second pull even though the cached snapshot is out of date
-                setTimeout(()=>{
+                setTimeout(() => {
                     if (this.cachedSnapshot === newSnapshot) {
                         this.cachedSnapshot = undefined;
                     }
                 }, this.ringCamera.snapshotLifeTime + 2 * 60 * 1000);
             }
-            (0, _util.logDebug)(`Snapshot cached for ${this.ringCamera.name}${imageUuid ? ' by uuid' : ''} (${getDurationSeconds(start)}s)`);
-        } catch (e) {
+            (0, util_1.logDebug)(`Snapshot cached for ${this.ringCamera.name}${imageUuid ? ' by uuid' : ''} (${getDurationSeconds(start)}s)`);
+        }
+        catch (e) {
             this.cachedSnapshot = undefined;
-            (0, _util.logDebug)(`Failed to cache snapshot for ${this.ringCamera.name} (${getDurationSeconds(start)}s), The camera currently reports that it is ${this.ringCamera.isOffline ? 'offline' : 'online'}`);
+            (0, util_1.logDebug)(`Failed to cache snapshot for ${this.ringCamera.name} (${getDurationSeconds(start)}s), The camera currently reports that it is ${this.ringCamera.isOffline ? 'offline' : 'online'}`);
             // log additioanl snapshot error message if one is present
             if (e.message.includes('Snapshot')) {
-                (0, _util.logDebug)(e.message);
+                (0, util_1.logDebug)(e.message);
             }
         }
     }
@@ -321,9 +377,9 @@ class CameraSource {
         if (this.ringCamera.snapshotsAreBlocked) {
             return readFileAsync(snapshotsBlockedPath);
         }
-        (0, _util.logDebug)(`${this.cachedSnapshot ? 'Used cached snapshot' : 'No snapshot cached'} for ${this.ringCamera.name}`);
+        (0, util_1.logDebug)(`${this.cachedSnapshot ? 'Used cached snapshot' : 'No snapshot cached'} for ${this.ringCamera.name}`);
         if (!this.ringCamera.hasSnapshotWithinLifetime) {
-            this.loadSnapshot().catch(_util.logError);
+            this.loadSnapshot().catch(util_1.logError);
         }
         // may or may not have a snapshot cached
         return this.cachedSnapshot;
@@ -338,36 +394,38 @@ class CameraSource {
             // Not currently resizing the image.
             // HomeKit does a good job of resizing and doesn't seem to care if it's not right
             callback(undefined, snapshot);
-        } catch (e) {
-            (0, _util.logError)(`Error fetching snapshot for ${this.ringCamera.name}`);
-            (0, _util.logError)(e);
+        }
+        catch (e) {
+            (0, util_1.logError)(`Error fetching snapshot for ${this.ringCamera.name}`);
+            (0, util_1.logError)(e);
             callback(e);
         }
     }
     async prepareStream(request, callback) {
         const start = Date.now();
-        (0, _util.logInfo)(`Preparing Live Stream for ${this.ringCamera.name}`);
+        (0, util_1.logInfo)(`Preparing Live Stream for ${this.ringCamera.name}`);
         try {
             const liveCall = await this.ringCamera.startLiveCall(), session = new StreamingSessionWrapper(liveCall, request, this.ringCamera, start);
             this.sessions[request.sessionID] = session;
-            (0, _util.logInfo)(`Stream Prepared for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
+            (0, util_1.logInfo)(`Stream Prepared for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
             callback(undefined, {
                 audio: {
                     port: await session.audioSplitter.portPromise,
                     ssrc: session.audioSsrc,
                     srtp_key: session.audioSrtp.srtpKey,
-                    srtp_salt: session.audioSrtp.srtpSalt
+                    srtp_salt: session.audioSrtp.srtpSalt,
                 },
                 video: {
                     port: await session.videoSplitter.portPromise,
                     ssrc: session.videoSsrc,
                     srtp_key: session.videoSrtp.srtpKey,
-                    srtp_salt: session.videoSrtp.srtpSalt
-                }
+                    srtp_salt: session.videoSrtp.srtpSalt,
+                },
             });
-        } catch (e) {
-            (0, _util.logError)(`Failed to prepare stream for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
-            (0, _util.logError)(e);
+        }
+        catch (e) {
+            (0, util_1.logError)(`Failed to prepare stream for ${this.ringCamera.name} (${getDurationSeconds(start)}s)`);
+            (0, util_1.logError)(e);
             callback(e);
         }
     }
@@ -378,108 +436,16 @@ class CameraSource {
             return;
         }
         if (requestType === 'start') {
-            (0, _util.logInfo)(`Activating stream for ${this.ringCamera.name} (${getDurationSeconds(session.start)}s)`);
+            (0, util_1.logInfo)(`Activating stream for ${this.ringCamera.name} (${getDurationSeconds(session.start)}s)`);
             await session.activate(request);
-            (0, _util.logInfo)(`Streaming active for ${this.ringCamera.name} (${getDurationSeconds(session.start)}s)`);
-        } else if (requestType === 'stop') {
-            (0, _util.logInfo)(`Stopped Live Stream for ${this.ringCamera.name}`);
+            (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();
     }
-    constructor(ringCamera, useOpus = false){
-        this.ringCamera = ringCamera;
-        this.useOpus = useOpus;
-        this.controller = new _hap.hap.CameraController({
-            cameraStreamCount: 10,
-            delegate: this,
-            streamingOptions: {
-                supportedCryptoSuites: [
-                    _homebridge.SRTPCryptoSuites.AES_CM_128_HMAC_SHA1_80
-                ],
-                video: {
-                    resolutions: [
-                        [
-                            1280,
-                            720,
-                            30
-                        ],
-                        [
-                            1024,
-                            768,
-                            30
-                        ],
-                        [
-                            640,
-                            480,
-                            30
-                        ],
-                        [
-                            640,
-                            360,
-                            30
-                        ],
-                        [
-                            480,
-                            360,
-                            30
-                        ],
-                        [
-                            480,
-                            270,
-                            30
-                        ],
-                        [
-                            320,
-                            240,
-                            30
-                        ],
-                        [
-                            320,
-                            240,
-                            15
-                        ],
-                        [
-                            320,
-                            180,
-                            30
-                        ]
-                    ],
-                    codec: {
-                        profiles: [
-                            _homebridge.H264Profile.BASELINE
-                        ],
-                        levels: [
-                            _homebridge.H264Level.LEVEL3_1
-                        ]
-                    }
-                },
-                audio: {
-                    codecs: this.useOpus ? [
-                        {
-                            type: _homebridge.AudioStreamingCodecType.OPUS,
-                            // required by watch
-                            samplerate: _homebridge.AudioStreamingSamplerate.KHZ_8
-                        },
-                        {
-                            type: _homebridge.AudioStreamingCodecType.OPUS,
-                            samplerate: _homebridge.AudioStreamingSamplerate.KHZ_16
-                        },
-                        {
-                            type: _homebridge.AudioStreamingCodecType.OPUS,
-                            samplerate: _homebridge.AudioStreamingSamplerate.KHZ_24
-                        }
-                    ] : [
-                        {
-                            type: _homebridge.AudioStreamingCodecType.AAC_ELD,
-                            samplerate: _homebridge.AudioStreamingSamplerate.KHZ_16
-                        }
-                    ]
-                }
-            }
-        });
-        this.sessions = {};
-        this.fn = 1;
-    }
 }
+exports.CameraSource = CameraSource;