homebridge-ring-hksv 14.3.4 → 14.3.6

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Patch Changes
+
+- Prevent lock accessories from reporting invalid `LockTargetState` values when Ring reports a jammed or unknown current state. This removes repeated Homebridge warnings while preserving the correct current lock state in HomeKit.
+
 ## 14.3.4
 
 ### Patch Changes

package/README.md

@@ -31,6 +31,9 @@ Big thanks to Dustin and all upstream contributors. This fork reuses and extends
 | `hksvPrebufferLengthMs` | HKSV prebuffer duration (minimum 4000ms) |
 | `hksvFragmentLengthMs` | HKSV fragment duration target |
 | `hksvMaxRecordingSeconds` | Optional safety cap for a recording session |
+| `hksvVideoBitrateKbps` / `hksvVideoMaxBitrateKbps` / `hksvVideoBufferSizeKbps` | HKSV recording bitrate controls for improving fast-motion quality |
+| `hksvVideoCrf` / `hksvVideoPreset` | Optional libx264 quality and CPU tuning controls |
+| `hksvVideoKeyframeInterval` | HKSV recording keyframe interval |
 | `homeKitAccessoryTag` | Appends a tag to accessory names and HomeKit IDs so the same Ring device can be exposed as a distinct HomeKit accessory for debugging/testing |
 | `cameraVideoCodec` | Preferred H.264 encoder (`h264_videotoolbox` or `libx264`) |
 | `hideDoorbellSwitch` / `hideCameraMotionSensor` / `hideCameraSirenSwitch` | Hides specific HomeKit-exposed services |
@@ -86,6 +89,12 @@ HKSV support is experimental and actively evolving. Behavior may vary by camera
 I currently am able to run 3 cameras with HKSV enabled on a Homebridge instance ran on a M4 Mac Mini 32GB of RAM.
 Please report your experience and setup details to help improve support.
 
+For fast-motion pixelation or stuttering in HKSV recordings, try increasing
+`hksvVideoBitrateKbps` first. On Apple Silicon Macs,
+`cameraVideoCodec: "h264_videotoolbox"` can reduce CPU load by using hardware
+encoding. A good starting point is 4000-6000 kbps target bitrate, 8000-12000
+kbps max bitrate, and the default keyframe interval of 30.
+
 ### Minimum specifications for HKSV: 
 [TBD - will be added as more users test and report their setups]
 

package/config.schema.json

@@ -53,6 +53,86 @@
         "maximum": 300,
         "description": "Optional safety cap for a single HKSV recording stream duration."
       },
+      "hksvVideoBitrateKbps": {
+        "title": "HKSV Video Bitrate (kbps)",
+        "type": "integer",
+        "minimum": 256,
+        "maximum": 12000,
+        "default": 3000,
+        "description": "Target video bitrate for HKSV recording transcodes. Increase this first if fast motion becomes blocky or pixelated. 4000-6000 is a good starting range for wired cameras."
+      },
+      "hksvVideoMaxBitrateKbps": {
+        "title": "HKSV Max Video Bitrate (kbps)",
+        "type": "integer",
+        "minimum": 256,
+        "maximum": 20000,
+        "description": "Maximum burst bitrate for HKSV recording transcodes. Defaults to 2x the target bitrate. A practical starting range is 8000-12000 when target bitrate is 4000-6000."
+      },
+      "hksvVideoBufferSizeKbps": {
+        "title": "HKSV Video Buffer Size (kbps)",
+        "type": "integer",
+        "minimum": 256,
+        "maximum": 40000,
+        "description": "FFmpeg VBV buffer size for HKSV recording transcodes. Defaults to 2x the max video bitrate. Leave unset unless you are tuning bitrate stability."
+      },
+      "hksvVideoCrf": {
+        "title": "HKSV x264 Quality (CRF)",
+        "type": "integer",
+        "minimum": 18,
+        "maximum": 35,
+        "description": "Optional libx264 quality value. Lower values improve quality and use more bitrate/CPU. Try 20-23 if you stay on libx264. Ignored when using VideoToolbox."
+      },
+      "hksvVideoKeyframeInterval": {
+        "title": "HKSV Keyframe Interval",
+        "type": "integer",
+        "minimum": 5,
+        "maximum": 240,
+        "default": 30,
+        "description": "Maximum number of frames between video keyframes in HKSV recordings. 30 is the recommended default. Shorter intervals can improve fragmenting at the cost of bitrate."
+      },
+      "hksvVideoPreset": {
+        "title": "HKSV x264 Preset",
+        "type": "string",
+        "description": "libx264 speed/quality preset for HKSV recordings. veryfast is the recommended default. Move toward fast or medium for quality, or superfast for lower CPU. Ignored when using VideoToolbox.",
+        "oneOf": [
+          {
+            "title": "ultrafast",
+            "enum": ["ultrafast"]
+          },
+          {
+            "title": "superfast",
+            "enum": ["superfast"]
+          },
+          {
+            "title": "veryfast",
+            "enum": ["veryfast"]
+          },
+          {
+            "title": "faster",
+            "enum": ["faster"]
+          },
+          {
+            "title": "fast",
+            "enum": ["fast"]
+          },
+          {
+            "title": "medium",
+            "enum": ["medium"]
+          },
+          {
+            "title": "slow",
+            "enum": ["slow"]
+          },
+          {
+            "title": "slower",
+            "enum": ["slower"]
+          },
+          {
+            "title": "veryslow",
+            "enum": ["veryslow"]
+          }
+        ]
+      },
       "homeKitAccessoryTag": {
         "title": "HomeKit Accessory Tag",
         "type": "string",
@@ -61,7 +141,7 @@
       "cameraVideoCodec": {
         "title": "Camera Video Codec",
         "type": "string",
-        "description": "Preferred ffmpeg H.264 encoder for camera paths.",
+        "description": "Preferred FFmpeg H.264 encoder for HKSV recording transcodes. On Apple Silicon or newer Intel Macs, h264_videotoolbox is the recommended first choice because it uses hardware acceleration.",
         "oneOf": [
           {
             "title": "h264_videotoolbox",
@@ -215,6 +295,12 @@
         "hksvPrebufferLengthMs",
         "hksvFragmentLengthMs",
         "hksvMaxRecordingSeconds",
+        "hksvVideoBitrateKbps",
+        "hksvVideoMaxBitrateKbps",
+        "hksvVideoBufferSizeKbps",
+        "hksvVideoCrf",
+        "hksvVideoKeyframeInterval",
+        "hksvVideoPreset",
         "homeKitAccessoryTag",
         "cameraVideoCodec",
         "hideLightGroups",

package/lib/camera-source.js

@@ -23,6 +23,12 @@ function getSessionConfig(srtpOptions) {
         profile: 1,
     };
 }
+function getIntegerConfigValue(value, defaultValue, min, max) {
+    if (!Number.isFinite(value)) {
+        return defaultValue;
+    }
+    return Math.min(Math.max(Math.round(value), min), max);
+}
 function* parseMp4Boxes(data) {
     let offset = 0;
     while (offset + 8 <= data.length) {
@@ -254,6 +260,7 @@ export class CameraSource {
     sessions = {};
     cachedSnapshot;
     ringCamera;
+    config;
     recordingActive = false;
     recordingConfiguration;
     closedRecordingStreams = new Set();
@@ -261,6 +268,7 @@ export class CameraSource {
     activeRecordingSessions = new Map();
     constructor(ringCamera, config) {
         this.ringCamera = ringCamera;
+        this.config = config;
         const enableHksv = config.enableHksv && !(config.disableHksvOnBattery && ringCamera.hasBattery);
         const controllerOptions = {
             cameraStreamCount: enableHksv ? 1 : 10,
@@ -358,6 +366,33 @@ export class CameraSource {
         }
         this.controller = new hap.CameraController(controllerOptions);
     }
+    getHksvVideoArguments() {
+        const { cameraVideoCodec = 'libx264', hksvVideoCrf, hksvVideoPreset = 'veryfast', } = this.config, bitrateKbps = getIntegerConfigValue(this.config.hksvVideoBitrateKbps, 3000, 256, 12000), maxBitrateKbps = getIntegerConfigValue(this.config.hksvVideoMaxBitrateKbps, bitrateKbps * 2, bitrateKbps, 20000), bufferSizeKbps = getIntegerConfigValue(this.config.hksvVideoBufferSizeKbps, maxBitrateKbps * 2, maxBitrateKbps, 40000), keyframeInterval = getIntegerConfigValue(this.config.hksvVideoKeyframeInterval, 30, 5, 240), videoArguments = [
+            '-vcodec',
+            cameraVideoCodec,
+            '-b:v',
+            `${bitrateKbps}k`,
+            '-maxrate',
+            `${maxBitrateKbps}k`,
+            '-bufsize',
+            `${bufferSizeKbps}k`,
+            '-pix_fmt',
+            'yuv420p',
+            '-profile:v',
+            'baseline',
+            '-level:v',
+            '3.1',
+            '-g',
+            `${keyframeInterval}`,
+        ];
+        if (cameraVideoCodec === 'libx264') {
+            videoArguments.push('-preset', hksvVideoPreset, '-tune', 'zerolatency', '-keyint_min', `${keyframeInterval}`, '-sc_threshold', '0');
+            if (Number.isFinite(hksvVideoCrf)) {
+                videoArguments.push('-crf', `${getIntegerConfigValue(hksvVideoCrf, 23, 18, 35)}`);
+            }
+        }
+        return videoArguments;
+    }
     previousLoadSnapshotPromise;
     async loadSnapshot(imageUuid) {
         // cache a promise of the snapshot load
@@ -399,7 +434,7 @@ export class CameraSource {
             this.cachedSnapshot = undefined;
             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')) {
+            if (e.message && e.message.includes('Snapshot')) {
                 logDebug(e.message);
             }
         }
@@ -533,32 +568,21 @@ export class CameraSource {
         this.activeRecordingSessions.set(streamId, closeSession);
         let liveCall;
         let keyFrameTimer;
+        let maxRecordingTimer;
         try {
             liveCall = await this.ringCamera.startLiveCall();
             liveCall.onCallEnded.pipe(take(1)).subscribe(() => {
                 closeSession();
             });
+            const maxRecordingSeconds = getIntegerConfigValue(this.config.hksvMaxRecordingSeconds, 0, 0, 300);
+            if (maxRecordingSeconds) {
+                maxRecordingTimer = setTimeout(() => {
+                    logInfo(`HKSV recording stream reached max duration for ${this.ringCamera.name} (streamId=${streamId}, maxSeconds=${maxRecordingSeconds})`);
+                    closeSession();
+                }, maxRecordingSeconds * 1000);
+            }
             await liveCall.startTranscoding({
-                video: [
-                    '-vcodec',
-                    'libx264',
-                    '-preset',
-                    'veryfast',
-                    '-tune',
-                    'zerolatency',
-                    '-pix_fmt',
-                    'yuv420p',
-                    '-profile:v',
-                    'baseline',
-                    '-level:v',
-                    '3.1',
-                    '-g',
-                    '30',
-                    '-keyint_min',
-                    '30',
-                    '-sc_threshold',
-                    '0',
-                ],
+                video: this.getHksvVideoArguments(),
                 output: [
                     '-movflags',
                     'frag_keyframe+empty_moov+default_base_moof',
@@ -650,6 +674,9 @@ export class CameraSource {
             if (keyFrameTimer) {
                 clearInterval(keyFrameTimer);
             }
+            if (maxRecordingTimer) {
+                clearTimeout(maxRecordingTimer);
+            }
             if (liveCall) {
                 liveCall.stop();
             }

package/lib/intercom.js

@@ -1,7 +1,125 @@
+import { RingCamera } from 'ring-client-api';
 import { hap } from "./hap.js";
 import { BaseDataAccessory } from "./base-data-accessory.js";
 import { logError, logInfo } from 'ring-client-api/util';
-import { map, throttleTime } from 'rxjs/operators';
+import { filter, map, share, switchMap, throttleTime } from 'rxjs/operators';
+import { interval, merge, Subject } from 'rxjs';
+import { CameraSource } from "./camera-source.js";
+/**
+ * Creates a RingCamera-compatible proxy for a Ring Intercom Video device.
+ * Ring Intercom Video is classified as RingIntercom by ring-client-api but has a
+ * real camera. We use Object.create(RingCamera.prototype) so that startLiveCall()
+ * and createStreamingConnection() are inherited and work with the intercom's
+ * restClient and device id (Ring's signalling server uses the same doorbot_id
+ * scheme for video intercoms as for cameras).
+ */
+function createIntercomVideoProxy(device) {
+    const proxy = Object.create(RingCamera.prototype);
+    const defineValue = (key, value) => Object.defineProperty(proxy, key, {
+        value,
+        writable: true,
+        configurable: true,
+        enumerable: true,
+    });
+    const defineGetter = (key, get) => Object.defineProperty(proxy, key, {
+        get,
+        configurable: true,
+        enumerable: true,
+    });
+    defineValue('id', device.id);
+    defineGetter('name', () => device.name);
+    defineGetter('deviceType', () => device.deviceType);
+    defineGetter('data', () => ({
+        ...device.data,
+        kind: device.deviceType,
+        device_id: String(device.id),
+        metadata: device.data.metadata ?? {},
+        settings: {
+            live_view_disabled: false,
+            motion_detection_enabled: true,
+            ...device.data.settings,
+        },
+    }));
+    // restClient is technically private in TypeScript but public in compiled JS
+    defineValue('restClient', device.restClient);
+    defineGetter('isRingEdgeEnabled', () => false);
+    defineGetter('hasBattery', () => device.batteryLevel !== null);
+    defineGetter('isOffline', () => device.isOffline);
+    defineGetter('snapshotsAreBlocked', () => false);
+    defineGetter('canTakeSnapshotWhileRecording', () => false);
+    defineGetter('latestNotificationSnapshotUuid', () => undefined);
+    defineValue('onNewNotification', new Subject());
+    defineValue('onMotionDetected', new Subject());
+    defineValue('onDoorbellPressed', device.onDing);
+    defineValue('onBatteryLevel', device.onBatteryLevel);
+    defineValue('onInHomeDoorbellStatus', new Subject());
+    defineGetter('hasLowBattery', () => Boolean(device.data.alerts?.battery === 'low'));
+    defineGetter('isCharging', () => false);
+    defineValue('isDoorbot', true);
+    defineValue('hasLight', false);
+    defineValue('hasSiren', false);
+    defineValue('hasInHomeDoorbell', false);
+    defineValue('model', 'Ring Intercom Video');
+    defineValue('snapshotLifeTime', 55000); // camera stays active ~1 min after a ring
+    // Pre-warm support: start the WebRTC call the moment a ding is detected so
+    // the camera is already streaming when HKSV requests the recording.
+    let preWarmedCall = null;
+    let preWarmCleanup = null;
+    let lastSnapshotAt = 0;
+    const realStartLiveCall = () => RingCamera.prototype.startLiveCall.call(proxy);
+    defineValue('startLiveCall', () => {
+        if (preWarmedCall) {
+            const call = preWarmedCall;
+            preWarmedCall = null;
+            if (preWarmCleanup) {
+                clearTimeout(preWarmCleanup);
+                preWarmCleanup = null;
+            }
+            logInfo(`${device.name}: using pre-warmed camera session for recording`);
+            return call;
+        }
+        return realStartLiveCall();
+    });
+    defineValue('preWarmCamera', () => {
+        if (preWarmedCall)
+            return;
+        logInfo(`${device.name}: pre-warming camera connection`);
+        preWarmedCall = realStartLiveCall();
+        // Clean up if HKSV doesn't claim it within 20 seconds
+        preWarmCleanup = setTimeout(async () => {
+            if (preWarmedCall) {
+                try {
+                    const session = await preWarmedCall;
+                    session.stop();
+                }
+                catch (e) {
+                    logError(`Failed to stop pre-warmed camera session for ${device.name}`);
+                    logError(e);
+                }
+                finally {
+                    preWarmedCall = null;
+                    preWarmCleanup = null;
+                }
+            }
+        }, 20000);
+    });
+    // Override getSnapshot: intercom uses the same doorbots snapshot endpoint as cameras.
+    defineGetter('hasSnapshotWithinLifetime', () => Date.now() - lastSnapshotAt < proxy.snapshotLifeTime);
+    defineValue('getSnapshot', async (_options) => {
+        try {
+            const snapshot = await device.restClient.request({
+                url: device.doorbotUrl('snapshot'),
+                responseType: 'buffer',
+            });
+            lastSnapshotAt = Date.now();
+            return snapshot;
+        }
+        catch {
+            throw new Error(`Snapshot not available for ${device.name}`);
+        }
+    });
+    return proxy;
+}
 export class Intercom extends BaseDataAccessory {
     unlocking = false;
     unlockTimeout;
@@ -13,7 +131,64 @@ export class Intercom extends BaseDataAccessory {
         this.device = device;
         this.accessory = accessory;
         this.config = config;
-        const { Characteristic, Service } = hap, lockService = this.getService(Service.LockMechanism), { LockCurrentState, LockTargetState, ProgrammableSwitchEvent } = Characteristic, programableSwitchService = this.getService(Service.StatelessProgrammableSwitch), onDoorbellPressed = device.onDing.pipe(throttleTime(15000), map(() => ProgrammableSwitchEvent.SINGLE_PRESS)), syncLockState = () => {
+        const { Characteristic, Service } = hap, isIntercomVideo = device.deviceType === 'intercom_handset_video';
+        // Set up camera streaming for Ring Intercom Video before other services
+        let intercomVideoProxy = null;
+        if (isIntercomVideo) {
+            const cameraProxy = createIntercomVideoProxy(device);
+            intercomVideoProxy = cameraProxy;
+            const cameraSource = new CameraSource(cameraProxy, config);
+            accessory.configureController(cameraSource.controller);
+            this.registerCharacteristic({
+                characteristicType: Characteristic.Mute,
+                serviceType: Service.Microphone,
+                getValue: () => false,
+            });
+            this.registerCharacteristic({
+                characteristicType: Characteristic.Mute,
+                serviceType: Service.Speaker,
+                getValue: () => false,
+            });
+            logInfo(`Camera streaming enabled for Ring Intercom Video: ${device.name}`);
+        }
+        const lockService = this.getService(Service.LockMechanism), { LockCurrentState, LockTargetState, ProgrammableSwitchEvent } = Characteristic, 
+        // Ring Intercom Video ding events may arrive as camera-style FCM push
+        // notifications (different category than RingIntercom.onDing expects),
+        // so onDing never fires. Poll Ring's active-dings endpoint as a reliable
+        // fallback — it reflects the current ring in real time (unlike the history
+        // endpoint which can lag by ~60 seconds).
+        onDingDetected = (() => {
+            if (!isIntercomVideo) {
+                return device.onDing.pipe(share());
+            }
+            let lastDingId;
+            const polled = interval(3000).pipe(switchMap(async () => {
+                try {
+                    const active = await device.restClient.request({
+                        url: 'https://api.ring.com/clients_api/dings/active',
+                    });
+                    return Array.isArray(active) ? active : [];
+                }
+                catch {
+                    return [];
+                }
+            }), filter((active) => {
+                const ding = active.find((d) => String(d.doorbot_id) === String(device.id) &&
+                    d.kind === 'ding');
+                if (!ding)
+                    return false;
+                if (String(ding.id) === lastDingId)
+                    return false;
+                lastDingId = String(ding.id);
+                return true;
+            }), map(() => undefined));
+            // share() makes this hot: one polling interval, one lastDingId,
+            // emission fans out to all subscribers that rely on ding events.
+            return merge(device.onDing, polled).pipe(throttleTime(3000), share());
+        })(), onDoorbellPressed = onDingDetected.pipe(throttleTime(15000), map(() => {
+            logInfo(`Doorbell pressed on ${device.name} — sending HomeKit event`);
+            return ProgrammableSwitchEvent.SINGLE_PRESS;
+        })), syncLockState = () => {
             const state = this.getLockState();
             lockService
                 .getCharacteristic(Characteristic.LockCurrentState)
@@ -68,25 +243,42 @@ export class Intercom extends BaseDataAccessory {
                 }
             },
         });
-        lockService.setPrimaryService(true);
+        // For audio-only intercom the lock is the main function; for video intercom
+        // the camera controller owns the primary-service role so HomeKit routes
+        // doorbell events (and HomePod chimes) correctly.
+        if (!isIntercomVideo) {
+            lockService.setPrimaryService(true);
+        }
+        // Pre-warm the camera WebRTC connection on every ding so HKSV recording
+        // gets live video instead of black frames.
+        if (intercomVideoProxy) {
+            const proxy = intercomVideoProxy;
+            onDingDetected.subscribe(() => {
+                ;
+                proxy.preWarmCamera?.();
+            });
+        }
         // Doorbell Service
         this.registerObservableCharacteristic({
             characteristicType: ProgrammableSwitchEvent,
             serviceType: Service.Doorbell,
             onValue: onDoorbellPressed,
         });
-        // Programmable Switch Service
-        this.registerObservableCharacteristic({
-            characteristicType: ProgrammableSwitchEvent,
-            serviceType: programableSwitchService,
-            onValue: onDoorbellPressed,
-        });
-        // Hide long and double press events by setting max value
-        programableSwitchService
-            .getCharacteristic(ProgrammableSwitchEvent)
-            .setProps({
-            maxValue: ProgrammableSwitchEvent.SINGLE_PRESS,
-        });
+        // Programmable Switch Service — only for audio-only intercom; the video
+        // variant already exposes Service.Doorbell which covers this.
+        if (!isIntercomVideo) {
+            const programableSwitchService = this.getService(Service.StatelessProgrammableSwitch);
+            this.registerObservableCharacteristic({
+                characteristicType: ProgrammableSwitchEvent,
+                serviceType: programableSwitchService,
+                onValue: onDoorbellPressed,
+            });
+            programableSwitchService
+                .getCharacteristic(ProgrammableSwitchEvent)
+                .setProps({
+                maxValue: ProgrammableSwitchEvent.SINGLE_PRESS,
+            });
+        }
         // Battery Service
         if (device.batteryLevel !== null) {
             this.registerObservableCharacteristic({
@@ -107,7 +299,7 @@ export class Intercom extends BaseDataAccessory {
         this.registerCharacteristic({
             characteristicType: Characteristic.Model,
             serviceType: Service.AccessoryInformation,
-            getValue: () => 'Intercom Handset Audio',
+            getValue: () => isIntercomVideo ? 'Ring Intercom Video' : 'Ring Intercom',
         });
         this.registerCharacteristic({
             characteristicType: Characteristic.SerialNumber,

package/lib/lock.js

@@ -55,6 +55,15 @@ export class Lock extends BaseDeviceAccessory {
         return this.device.sendCommand(`lock.${command}`);
     }
     getTargetState(data) {
-        return this.targetState || getCurrentState(data);
+        if (this.targetState !== undefined) {
+            return this.targetState;
+        }
+        const { Characteristic: { LockCurrentState, LockTargetState }, } = hap;
+        const currentState = getCurrentState(data);
+        if (currentState === LockCurrentState.JAMMED ||
+            currentState === LockCurrentState.UNKNOWN) {
+            return LockTargetState.SECURED;
+        }
+        return currentState;
     }
 }

package/lib/ring-platform.js

@@ -170,10 +170,17 @@ export class RingPlatform {
         });
         await Promise.all(locations.map(async (location) => {
             const devices = await location.getDevices(), { cameras, chimes, intercoms } = location, allDevices = [...devices, ...cameras, ...chimes, ...intercoms], securityPanel = devices.find((x) => x.deviceType === RingDeviceType.SecurityPanel), debugPrefix = debug ? 'TEST ' : '', hapDevices = allDevices.map((device) => {
-                const isCamera = device instanceof RingCamera, cameraIdentitySalt = isCamera && config.externalCameraIdSalt
+                const isCamera = device instanceof RingCamera, isIntercomVideo = device instanceof RingIntercom &&
+                    device.deviceType === 'intercom_handset_video', cameraIdentitySalt = isCamera && config.externalCameraIdSalt
                     ? `-${config.externalCameraIdSalt}`
-                    : '', cameraIdDifferentiator = isCamera ? 'camera' : '', // this forces bridged cameras from old version of the plugin to be seen as "stale"
-                AccessoryClass = (device instanceof RingCamera
+                    : '', 
+                // 'camera' forces bridged cameras from old plugin version to be seen as "stale"
+                // 'intercam' gives Ring Intercom Video a distinct external-accessory UUID
+                cameraIdDifferentiator = isCamera
+                    ? 'camera'
+                    : isIntercomVideo
+                        ? 'intercam'
+                        : '', AccessoryClass = (device instanceof RingCamera
                     ? Camera
                     : device instanceof RingChime
                         ? Chime
@@ -184,6 +191,7 @@ export class RingPlatform {
                     deviceType: device.deviceType,
                     device: device,
                     isCamera,
+                    isIntercomVideo,
                     id: device.id.toString() +
                         cameraIdDifferentiator +
                         cameraIdentitySalt +
@@ -199,6 +207,7 @@ export class RingPlatform {
                     deviceType: securityPanel.deviceType,
                     device: securityPanel,
                     isCamera: false,
+                    isIntercomVideo: false,
                     id: securityPanel.id.toString() + 'panic' + accessoryIdSuffix,
                     name: 'Panic Buttons' + accessoryNameSuffix,
                     AccessoryClass: PanicButtons,
@@ -210,13 +219,14 @@ export class RingPlatform {
                     deviceType: 'location.mode',
                     device: location,
                     isCamera: false,
+                    isIntercomVideo: false,
                     id: location.id + 'mode' + accessoryIdSuffix,
                     name: location.name + ' Mode' + accessoryNameSuffix,
                     AccessoryClass: LocationModeSwitch,
                 });
             }
             logInfo(`Configuring ${cameras.length} cameras and ${hapDevices.length} devices for location "${location.name}" - locationId: ${location.id}`);
-            hapDevices.forEach(({ deviceType, device, isCamera, id, name, AccessoryClass }) => {
+            hapDevices.forEach(({ deviceType, device, isCamera, isIntercomVideo, id, name, AccessoryClass, }) => {
                 const uuid = hap.uuid.generate(debugPrefix + id), displayName = debugPrefix + name;
                 if (!AccessoryClass ||
                     (config.hideLightGroups &&
@@ -237,13 +247,20 @@ export class RingPlatform {
                     delete this.homebridgeAccessories[uuid];
                 }
                 const createHomebridgeAccessory = () => {
-                    const accessory = new api.platformAccessory(displayName, uuid, isCamera
+                    const category = isCamera
                         ? 17 /* hap.Categories.CAMERA */
-                        : 11 /* hap.Categories.SECURITY_SYSTEM */);
+                        : isIntercomVideo
+                            ? 18 /* hap.Categories.VIDEO_DOORBELL */
+                            : 11 /* hap.Categories.SECURITY_SYSTEM */;
+                    const accessory = new api.platformAccessory(displayName, uuid, category);
                     if (isCamera) {
                         logInfo(`Configured camera ${uuid} ${deviceType} ${displayName}`);
                         externalAccessories.push(accessory);
                     }
+                    else if (isIntercomVideo) {
+                        logInfo(`Configured Ring Intercom Video ${uuid} ${deviceType} ${displayName}`);
+                        externalAccessories.push(accessory);
+                    }
                     else {
                         logInfo(`Adding new accessory ${uuid} ${deviceType} ${displayName}`);
                         platformAccessories.push(accessory);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "homebridge-ring-hksv",
   "displayName": "Homebridge Ring HKSV",
-  "version": "14.3.4",
+  "version": "14.3.6",
   "description": "Homebridge plugin for Ring devices with HomeKit Secure Video support",
   "type": "module",
   "main": "./lib/index.js",