homebridge-ring-hksv 14.3.6 → 14.3.7

package/lib/camera-source.js

@@ -434,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 && e.message.includes('Snapshot')) {
+            if (e.message.includes('Snapshot')) {
                 logDebug(e.message);
             }
         }

package/lib/intercom.js

@@ -1,125 +1,7 @@
-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 { 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;
-}
+import { map, throttleTime } from 'rxjs/operators';
 export class Intercom extends BaseDataAccessory {
     unlocking = false;
     unlockTimeout;
@@ -131,64 +13,7 @@ export class Intercom extends BaseDataAccessory {
         this.device = device;
         this.accessory = accessory;
         this.config = config;
-        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 { 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 state = this.getLockState();
             lockService
                 .getCharacteristic(Characteristic.LockCurrentState)
@@ -243,42 +68,25 @@ export class Intercom extends BaseDataAccessory {
                 }
             },
         });
-        // 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?.();
-            });
-        }
+        lockService.setPrimaryService(true);
         // Doorbell Service
         this.registerObservableCharacteristic({
             characteristicType: ProgrammableSwitchEvent,
             serviceType: Service.Doorbell,
             onValue: onDoorbellPressed,
         });
-        // 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,
-            });
-        }
+        // 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,
+        });
         // Battery Service
         if (device.batteryLevel !== null) {
             this.registerObservableCharacteristic({
@@ -299,7 +107,7 @@ export class Intercom extends BaseDataAccessory {
         this.registerCharacteristic({
             characteristicType: Characteristic.Model,
             serviceType: Service.AccessoryInformation,
-            getValue: () => isIntercomVideo ? 'Ring Intercom Video' : 'Ring Intercom',
+            getValue: () => 'Intercom Handset Audio',
         });
         this.registerCharacteristic({
             characteristicType: Characteristic.SerialNumber,

package/lib/ring-platform.js

@@ -170,17 +170,10 @@ 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, isIntercomVideo = device instanceof RingIntercom &&
-                    device.deviceType === 'intercom_handset_video', cameraIdentitySalt = isCamera && config.externalCameraIdSalt
+                const isCamera = device instanceof RingCamera, cameraIdentitySalt = isCamera && config.externalCameraIdSalt
                     ? `-${config.externalCameraIdSalt}`
-                    : '', 
-                // '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
+                    : '', cameraIdDifferentiator = isCamera ? 'camera' : '', // this forces bridged cameras from old version of the plugin to be seen as "stale"
+                AccessoryClass = (device instanceof RingCamera
                     ? Camera
                     : device instanceof RingChime
                         ? Chime
@@ -191,7 +184,6 @@ export class RingPlatform {
                     deviceType: device.deviceType,
                     device: device,
                     isCamera,
-                    isIntercomVideo,
                     id: device.id.toString() +
                         cameraIdDifferentiator +
                         cameraIdentitySalt +
@@ -207,7 +199,6 @@ export class RingPlatform {
                     deviceType: securityPanel.deviceType,
                     device: securityPanel,
                     isCamera: false,
-                    isIntercomVideo: false,
                     id: securityPanel.id.toString() + 'panic' + accessoryIdSuffix,
                     name: 'Panic Buttons' + accessoryNameSuffix,
                     AccessoryClass: PanicButtons,
@@ -219,14 +210,13 @@ 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, isIntercomVideo, id, name, AccessoryClass, }) => {
+            hapDevices.forEach(({ deviceType, device, isCamera, id, name, AccessoryClass }) => {
                 const uuid = hap.uuid.generate(debugPrefix + id), displayName = debugPrefix + name;
                 if (!AccessoryClass ||
                     (config.hideLightGroups &&
@@ -247,20 +237,13 @@ export class RingPlatform {
                     delete this.homebridgeAccessories[uuid];
                 }
                 const createHomebridgeAccessory = () => {
-                    const category = isCamera
+                    const accessory = new api.platformAccessory(displayName, uuid, isCamera
                         ? 17 /* hap.Categories.CAMERA */
-                        : isIntercomVideo
-                            ? 18 /* hap.Categories.VIDEO_DOORBELL */
-                            : 11 /* hap.Categories.SECURITY_SYSTEM */;
-                    const accessory = new api.platformAccessory(displayName, uuid, category);
+                        : 11 /* hap.Categories.SECURITY_SYSTEM */);
                     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.6",
+  "version": "14.3.7",
   "description": "Homebridge plugin for Ring devices with HomeKit Secure Video support",
   "type": "module",
   "main": "./lib/index.js",