homebridge-ring-secure-video 1.0.0-beta.2 → 1.0.0-beta.4

package/CHANGELOG.md

@@ -1,5 +1,80 @@
 # homebridge-ring-secure-video
 
+## 1.0.0-beta.4 (2026-11-13)
+
+More fixes from the full independent review of 1.0.0-beta.2.
+
+**Changes in behaviour to check after updating:**
+
+- `enableHksv` now means on when it isn't set, as the settings form shows. Configs without it
+  (written by hand, or copied from homebridge-ring) now offer HKSV recording: live view allows
+  one viewer at a time, and recording starts once turned on for the camera in the Home app. Set
+  `"enableHksv": false` to keep the old behaviour.
+- `disableHksvOnBattery` now means on when it isn't set, and looks at whether a camera actually
+  runs on battery: battery models that are wired (power mode wired in the Ring app), like many
+  doorbells, keep HKSV; battery-only cameras don't get it. Configs without the setting therefore
+  lose HKSV on battery-only cameras; set `"disableHksvOnBattery": false` to keep it. Configs
+  saved by the old settings form have it set to true, so their wired battery doorbells now get
+  HKSV.
+- Values the old settings form saved stay until removed: a saved `"media": { "profile":
+  "adaptive" }` still overrides `"hksvPerformanceMode": "rpi"`, and a saved
+  `"hksvVideoBitrateKbps": 3000` still overrides the profile's bitrate. Remove them if you didn't
+  choose them.
+
+**Fixes:**
+
+- One device or location that fails to set up no longer stops the others, the alarm included.
+  A failed device keeps its HomeKit accessory (rooms and automations stay) but shows "No
+  Response"; a location whose devices can't be loaded is logged, and its accessories are kept and
+  show "No Response". If
+  Ring can't be reached when Homebridge starts (an outage, a server error, a sign-in server
+  outage), connecting is retried after 30 s, 1 min, 2 min, ... up to every 10 minutes, with the
+  newest sign-in token and without forcing a new Ring registration.
+- The motion fallback no longer asks Ring for each camera's event history every 20 s all day
+  (about 4,300 requests a day). Once motion events turn out to arrive by push too, it checks every
+  5 minutes as a safety net; a motion event no push reported switches back to frequent checks. A
+  history event counts as pushed if a motion push had its id or came within 90 s of it. If push
+  stops working, it is noticed at the next 5-minute check; a visit found then is only reported if
+  it is at most 3 minutes old, so it can be missed. Remembered events are forgotten an hour after
+  they leave Ring's history.
+- ffmpeg errors no longer end the whole bridge (alarm included): further errors on a process and
+  errors on its output are logged, and a talk-back ffmpeg that fails to start is logged and the
+  live view is reported to HomeKit as not started.
+- A snapshot that can't be refreshed is shown for at most Ring's snapshot lifetime plus 2
+  minutes, as in homebridge-ring, rather than indefinitely.
+- The settings form no longer fills in a bitrate or media profile that overrode the media
+  profile and the older HKSV performance mode.
+- README and settings text: the Raspberry Pi section shows the settings verified on a Pi 4
+  (`lowPower`, `libx264`, with a Ring Video Doorbell 3 Plus); `copy` and `h264_v4l2m2m` are
+  described as not yet verified. Upstream links point to dgreif/ring, and the install commands
+  no longer use `--unsafe-perm`.
+- Development: GitHub Actions and the publishing npm are pinned to exact versions, the GitHub
+  token is kept out of dependency installs, Dependabot is set up, and locked dependencies include
+  the available security fixes.
+
+## 1.0.0-beta.3 (2026-11-13)
+
+Fixes from a full independent review of 1.0.0-beta.2.
+
+- A second visit 30–65 s after the first now turns HomeKit motion on again, so it is recorded and
+  notified. Ring keeps a motion alert active for 65 s and only reports changes, while the plugin
+  turns motion off after 30 s; a new alert in between gave nothing. A repeat of the same alert
+  (Ring's follow-up with the snapshot, a resend) is not a new visit, and the event-history
+  fallback no longer adds its own "no motion" after 65 s, which could cut a later visit short.
+- A media setting the plugin can't use (for example a maximum bitrate below the bitrate, which
+  the settings form allows, or a stray key) no longer stops the plugin's bridge from starting
+  (which took the alarm down with it). It is ignored with a warning naming it, and the older
+  setting or the default is used. Default maximum bitrate and buffer size derived from a high
+  bitrate stay within their limits.
+- After a forced Ring refresh ("Force Ring Push Credential Refresh" or "Force Ring API Session
+  Refresh"), every new Ring token is saved, not only the first; before, the next start
+  registered with Ring again. The force settings are cleared once, and a token that can't be
+  saved is logged.
+- config.json and .ring.json are written to a temporary file and then renamed into place, so a
+  power cut or a full disk during a token renewal can't leave them cut short (Homebridge would not
+  start). Permissions, group and symlinks are kept; where that can't work (a bind-mounted file,
+  a file owned by another user, ...) they are written in place as before.
+
 ## 1.0.0-beta.2 (2026-11-13)
 
 - The Homebridge UI shows the plugin as "Ring Secure Video" (was "Homebridge Ring Secure Video"),

package/README.md

@@ -13,22 +13,22 @@ It is meant to replace `homebridge-ring` on its own: one plugin, one Ring sign-i
 
 ## Origin and Attribution
 
-This project is based on Dustin Greif's original Ring Homebridge ecosystem:
+This project is based on Dusty Greif's original Ring Homebridge ecosystem:
 
-- Upstream plugin: [dgreif/homebridge-ring](https://github.com/dgreif/homebridge-ring)
-- Upstream API library: [dgreif/ring-client-api](https://github.com/dgreif/ring-client-api)
+- Upstream plugin and API library: [dgreif/ring](https://github.com/dgreif/ring)
+  (`homebridge-ring` and `ring-client-api`)
 
 - HKSV fork: [trinityhades/homebridge-ring-hksv](https://github.com/trinityhades/homebridge-ring-hksv), whose history this repository continues
 
-Big thanks to Dustin, trinityhades and all upstream contributors. This plugin reuses and extends that foundation.
+Big thanks to Dusty, trinityhades and all upstream contributors. This plugin reuses and extends that foundation.
 
 ## Important Plugin Options
 
 | Option | Purpose |
 | --- | --- |
-| `enableHksv` | Enables experimental HKSV support for eligible cameras |
-| `enableCameraMotionHistory` | Allows camera motion to fall back to recent Ring event history if live notifications are stale; disable to only trust push-triggered motion |
-| `disableHksvOnBattery` | Disables HKSV on battery cameras to reduce battery/network usage |
+| `enableHksv` | Enables experimental HKSV support for eligible cameras; on by default, set `false` to turn it off |
+| `enableCameraMotionHistory` | Allows camera motion to fall back to recent Ring event history if push notifications don't arrive. The history is checked every `cameraStatusPollingSeconds` until motion events turn out to come by push too, then every 5 minutes as a safety net (and frequently again once a push is missed, so motion can go unreported for up to 5 minutes after push stops working); disable to only trust push-triggered motion |
+| `disableHksvOnBattery` | Disables HKSV on cameras running on battery to reduce battery/network usage; wired battery models keep it. On by default |
 | `hksvPrebufferLengthMs` | HKSV prebuffer duration (minimum 4000ms) |
 | `hksvFragmentLengthMs` | HKSV fragment duration target |
 | `hksvMaxRecordingSeconds` | Optional safety cap for a recording session (default 180 s; 0 disables) |
@@ -61,13 +61,13 @@ normally ends a recording itself when motion stops), or to `0` to disable it.
 If Homebridge is installed globally:
 
 ```bash
-npm i -g --unsafe-perm homebridge-ring-secure-video
+npm i -g homebridge-ring-secure-video
 ```
 
 To try a beta, install the `beta` tag instead:
 
 ```bash
-npm i -g --unsafe-perm homebridge-ring-secure-video@beta
+npm i -g homebridge-ring-secure-video@beta
 ```
 
 If running from source:
@@ -115,7 +115,8 @@ Changing `homeKitAccessoryTag` updates both the exposed accessory name and the g
 
 HKSV support is experimental and actively evolving. Behavior may vary by camera model, wired vs battery power, Ring API changes, and FFmpeg environment.
 
-I currently am able to run 3 cameras with HKSV enabled on a Homebridge instance ran on a M4 Mac Mini 32GB of RAM.
+Verified so far: complete HomeKit clips from a Ring Video Doorbell 3 Plus on a Raspberry Pi 4
+(Node 22, Homebridge 2) with the settings below. The HKSV fork this continues reported 3 cameras on an M4 Mac mini.
 Please report your experience and setup details to help improve support.
 
 Recordings follow the frame rate and audio format HomeKit asks for, and include audio only when
@@ -133,24 +134,23 @@ For fast-motion pixelation or stuttering in HKSV recordings, try increasing
 `cameraVideoCodec: "h264_videotoolbox"` can reduce CPU load by using hardware
 encoding.
 
-For Raspberry Pi 4/5 and other small computers, start with:
+For Raspberry Pi 4/5 and other small computers, start with what has been verified on a Pi 4:
 
 ```json
 {
   "enableHksv": true,
-  "hksvPerformanceMode": "rpi",
-  "cameraVideoCodec": "auto",
-  "hksvMaxConcurrentRecordings": 1
+  "media": {
+    "profile": "lowPower",
+    "recording": { "codec": "libx264", "bitrateKbps": 800 }
+  }
 }
 ```
 
-The `rpi` profile favors remuxing Ring's H.264 video into HomeKit Secure Video
-fragmented MP4 instead of re-encoding it. This is much lighter than libx264, but
-it depends on Ring's current stream being compatible with HomeKit's H.264
-recording requirements. If recording fails in this mode, try
-`cameraVideoCodec: "h264_v4l2m2m"` when your FFmpeg build exposes that encoder,
-or fall back to `cameraVideoCodec: "libx264"` with `hksvVideoPreset:
-"ultrafast"`.
+The `lowPower` profile (also chosen by `"hksvPerformanceMode": "rpi"`) records one clip at a
+time with conservative settings. Lighter codecs exist but complete HomeKit clips with them are
+not verified yet: `copy` (the `lowPower` default for `auto`) remuxes Ring's H.264 without
+re-encoding, which only works when Ring's stream meets HomeKit's recording requirements, and
+`h264_v4l2m2m` uses the Pi's hardware encoder when FFmpeg has it.
 
 ### Minimum specifications for HKSV: 
 [TBD - will be added as more users test and report their setups]

package/config.schema.json

@@ -36,7 +36,7 @@
           "profile": {
             "title": "Media profile",
             "type": "string",
-            "default": "adaptive",
+            "description": "Defaults to the HKSV Performance Mode (rpi gives lowPower, quality gives quality), otherwise adaptive.",
             "oneOf": [
               { "title": "adaptive", "enum": ["adaptive"] },
               { "title": "lowPower", "enum": ["lowPower"] },
@@ -155,13 +155,13 @@
       "enableCameraMotionHistory": {
         "title": "Enable Camera Motion History Fallback",
         "type": "boolean",
-        "description": "If enabled, cameras can synthesize motion from recent Ring event history when live push notifications are missing or stale. Disable this if you only want motion triggered by Ring notifications.",
+        "description": "If enabled, cameras can synthesize motion from recent Ring event history when push notifications don't arrive. The history is checked frequently until push is seen to work, then every 5 minutes as a safety net. Disable this if you only want motion triggered by Ring notifications.",
         "default": true
       },
       "disableHksvOnBattery": {
         "title": "Disable HKSV On Battery Cameras",
         "type": "boolean",
-        "description": "If enabled, HKSV is disabled on battery-powered cameras to reduce battery and network impact.",
+        "description": "If enabled, HKSV is disabled on cameras running on battery, to reduce battery and network impact. Battery models that are wired (power mode wired in the Ring app) keep HKSV.",
         "default": true
       },
       "hksvPrebufferLengthMs": {
@@ -189,7 +189,7 @@
       "hksvPerformanceMode": {
         "title": "HKSV Performance Mode",
         "type": "string",
-        "description": "High-level HKSV tuning profile. Use rpi for Raspberry Pi and other small computers; it favors remuxing, lower advertised recording tiers, and conservative concurrency.",
+        "description": "High-level HKSV tuning profile. Use rpi for Raspberry Pi and other small computers: lower advertised recording tiers, one recording at a time, and remuxing (copy) unless a codec other than auto is set. Verified on a Pi 4 with the codec set to libx264.",
         "default": "balanced",
         "oneOf": [
           {
@@ -225,8 +225,7 @@
         "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."
+        "description": "Target video bitrate for HKSV recording transcodes. Defaults to the media profile's (1000 lowPower, 3000 adaptive, 5000 quality). 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)",
@@ -308,7 +307,7 @@
       "cameraVideoCodec": {
         "title": "Camera Video Codec",
         "type": "string",
-        "description": "Preferred FFmpeg H.264 handling for HKSV recordings. auto chooses the lowest-cost option for the configured performance mode; copy remuxes Ring video without re-encoding.",
+        "description": "Preferred FFmpeg H.264 handling for HKSV recordings. auto chooses the lowest-cost option for the configured performance mode; copy remuxes Ring video without re-encoding. Complete clips are verified with libx264; copy and h264_v4l2m2m are not verified yet.",
         "oneOf": [
           {
             "title": "auto",

package/lib/camera-source.js

@@ -225,46 +225,79 @@ class StreamingSessionWrapper {
                 // deSerialize will sometimes fail, but the errors can be ignored
             }
             return null;
-        }), releaseReturnAudioFfmpeg = hksvRecordingQueue.trackFfmpegProcess(), returnAudioTranscoder = new ReturnAudioTranscoder({
-            prepareStreamRequest: getReturnAudioPrepareStreamRequest(this.prepareStreamRequest),
-            startStreamRequest: request,
-            incomingAudioOptions: {
-                ssrc: this.audioSsrc,
-                rtcpPort: 0, // we don't care about rtcp for incoming audio
-            },
-            outputArgs: [
-                '-acodec',
-                'libopus',
-                '-application',
-                'lowdelay',
-                '-frame_duration',
-                '60',
-                '-flags',
-                '+global_header',
-                '-ar',
-                '48k',
-                '-b:a',
-                '48k',
-                '-bufsize',
-                '192k',
-                '-ac',
-                '2',
-                '-f',
-                'rtp',
-                `rtp://127.0.0.1:${await returnAudioTranscodedSplitter.portPromise}`,
-            ],
-            ffmpegPath: getFfmpegPath(),
-            exitCallback: () => {
-                releaseReturnAudioFfmpeg();
-                this.stop();
-            },
-            logger: {
-                info: logDebug,
-                error: logError,
-            },
-            logLabel: `Return Audio (${this.ringCamera.name})`,
-            returnAudioSplitter: this.audioSplitter,
         });
+        // Port first, so a failure here leaves nothing counted or open.
+        let returnAudioPort;
+        try {
+            returnAudioPort = await returnAudioTranscodedSplitter.portPromise;
+        }
+        catch (e) {
+            returnAudioTranscodedSplitter.close();
+            throw e;
+        }
+        if (this.stopped) {
+            returnAudioTranscodedSplitter.close();
+            throw getLiveStreamAbortError();
+        }
+        const releaseReturnAudioFfmpeg = hksvRecordingQueue.trackFfmpegProcess();
+        let returnAudioTranscoder;
+        try {
+            returnAudioTranscoder = new ReturnAudioTranscoder({
+                prepareStreamRequest: getReturnAudioPrepareStreamRequest(this.prepareStreamRequest),
+                startStreamRequest: request,
+                incomingAudioOptions: {
+                    ssrc: this.audioSsrc,
+                    rtcpPort: 0, // we don't care about rtcp for incoming audio
+                },
+                outputArgs: [
+                    '-acodec',
+                    'libopus',
+                    '-application',
+                    'lowdelay',
+                    '-frame_duration',
+                    '60',
+                    '-flags',
+                    '+global_header',
+                    '-ar',
+                    '48k',
+                    '-b:a',
+                    '48k',
+                    '-bufsize',
+                    '192k',
+                    '-ac',
+                    '2',
+                    '-f',
+                    'rtp',
+                    `rtp://127.0.0.1:${returnAudioPort}`,
+                ],
+                ffmpegPath: getFfmpegPath(),
+                exitCallback: () => {
+                    releaseReturnAudioFfmpeg();
+                    this.stop();
+                },
+                logger: {
+                    info: logDebug,
+                    error: logError,
+                },
+                logLabel: `Return Audio (${this.ringCamera.name})`,
+                returnAudioSplitter: this.audioSplitter,
+            });
+        }
+        catch (e) {
+            releaseReturnAudioFfmpeg();
+            returnAudioTranscodedSplitter.close();
+            throw e;
+        }
+        // @homebridge/camera-utils' ffmpeg has no 'error' listener: a failed start (no ffmpeg, too
+        // many processes) would be an unhandled 'error' event and end the whole bridge, alarm
+        // included. Its spawn errors arrive on the next tick, so listening now is in time.
+        const returnAudioFfmpeg = returnAudioTranscoder.ffmpegProcess?.ff;
+        for (const emitter of [returnAudioFfmpeg, returnAudioFfmpeg?.stdout, returnAudioFfmpeg?.stderr]) {
+            emitter?.on('error', (error) => {
+                logError(`Return Audio (${this.ringCamera.name}): ${error.message}`);
+                this.stop();
+            });
+        }
         this.streamingSession.onCallEnded.pipe(take(1)).subscribe(() => {
             returnAudioTranscoder.stop();
             returnAudioTranscodedSplitter.close();
@@ -277,6 +310,9 @@ class StreamingSessionWrapper {
         });
         this.listenForAudioPackets(request);
         await returnAudioTranscoder.start();
+        // A talk-back ffmpeg that failed to start stopped the stream meanwhile: report it to HomeKit.
+        if (this.stopped)
+            throw getLiveStreamAbortError();
     }
     stop() {
         if (this.stopped) {
@@ -329,10 +365,20 @@ export function getHksvRecordingFormatArguments(configuration, videoArguments, c
 // Raspberry Pi's V4L2 encoder) otherwise leave an empty avcC, and HomeKit can't decode the
 // recording. The first media fragment arrives no later than before.
 export const HKSV_RECORDING_MOVFLAGS = 'frag_keyframe+empty_moov+default_base_moof+delay_moov';
+/**
+ * Whether a camera gets HomeKit Secure Video. Unset settings mean what the settings form shows:
+ * HKSV on, except for cameras running on battery (each recording opens a Ring live call, which
+ * drains it). A battery model that is wired, like many doorbells, counts as wired.
+ */
+export function isHksvEnabled(config, operatingOnBattery) {
+    return (config.enableHksv !== false &&
+        !(config.disableHksvOnBattery !== false && operatingOnBattery));
+}
 export class CameraSource {
     controller;
     sessions = {};
     cachedSnapshot;
+    cachedSnapshotAt = 0;
     ringCamera;
     config;
     mediaIngress;
@@ -345,7 +391,7 @@ export class CameraSource {
         this.ringCamera = ringCamera;
         this.config = config;
         this.mediaIngress = new RingMediaIngress(ringCamera);
-        const enableHksv = config.enableHksv && !(config.disableHksvOnBattery && ringCamera.hasBattery);
+        const enableHksv = isHksvEnabled(config, ringCamera.operatingOnBattery);
         const controllerOptions = {
             cameraStreamCount: enableHksv ? 1 : 10,
             delegate: this,
@@ -512,6 +558,7 @@ export class CameraSource {
         try {
             const previousSnapshot = this.cachedSnapshot, newSnapshot = await this.ringCamera.getSnapshot({ uuid: imageUuid });
             this.cachedSnapshot = newSnapshot;
+            this.cachedSnapshotAt = Date.now();
             logDebug(`Snapshot cached for ${this.ringCamera.name}${imageUuid ? ' by uuid' : ''} (${getDurationSeconds(start)}s)`);
         }
         catch (e) {
@@ -535,7 +582,13 @@ export class CameraSource {
         if (!this.ringCamera.hasSnapshotWithinLifetime) {
             this.loadSnapshot().catch(logError);
         }
-        // may or may not have a snapshot cached
+        // May or may not have a snapshot cached. A failed load keeps the last one for a while, but
+        // not past Ring's snapshot lifetime plus 2 minutes (as upstream): an hours-old image would
+        // look current in the Home app.
+        if (this.cachedSnapshot &&
+            Date.now() - this.cachedSnapshotAt > this.ringCamera.snapshotLifeTime + 2 * 60_000) {
+            return undefined;
+        }
         return this.cachedSnapshot;
     }
     async handleSnapshotRequest(request, callback) {

package/lib/camera.js

@@ -1,11 +1,188 @@
 import { hap } from "./hap.js";
+import { PushNotificationAction } from 'ring-client-api';
 import { BaseDataAccessory } from "./base-data-accessory.js";
-import { catchError, exhaustMap, filter, map, mergeMap, share, switchMap, throttleTime, } from 'rxjs/operators';
+import { catchError, exhaustMap, filter, finalize, map, mergeMap, share, switchMap, throttleTime, } from 'rxjs/operators';
 import { CameraSource } from "./camera-source.js";
 import { TargetValueTimer } from "./target-value-timer.js";
 import { delay, logError, logInfo } from 'ring-client-api/util';
-import { EMPTY, firstValueFrom, from, merge, of, timer } from 'rxjs';
+import { defer, EMPTY, firstValueFrom, merge, of, timer } from 'rxjs';
 export const MOTION_WATCHDOG_MS = 30_000;
+/** How often Ring's event history is checked once its push notifications are known to arrive. */
+export const HISTORY_CHECK_WHILE_PUSH_WORKS_MS = 5 * 60_000;
+/** A push motion this close to a history event's time is taken as that event's notification. */
+export const PUSH_MATCH_WINDOW_MS = 90_000;
+/** After a gap in checking, a history event older than this no longer gives motion. */
+export const HISTORY_MOTION_MAX_AGE_MS = 180_000;
+/** A history event first seen less than this ago may still get its push; judged at a later check. */
+const PUSH_GRACE_MS = 30_000;
+/** Checks in a row that found only pushed events (no misses in between) before push is trusted. */
+const MATCHES_TO_TRUST_PUSH = 2;
+/**
+ * Ids no longer in the history are forgotten after this. Ids still in it are kept, however old:
+ * on a quiet camera the 10 newest events can be days old, and must not count as new again.
+ */
+const ID_MEMORY_MS = 60 * 60_000;
+/**
+ * Motion from Ring's event history, for when its push notifications don't arrive.
+ *
+ * Checking every pollSeconds (20 s by default) costs some 4,300 Ring requests a day per camera,
+ * on the same session as everything else. So the history is checked that often only until motion
+ * events in it (two in a row) turn out to have come by push too; from then on push is trusted
+ * and the history is checked every 5 minutes as a safety net. A motion event no push reported
+ * switches back to frequent checks. While checking frequently every new event gives motion; after
+ * a gap (5-minute checks, a failure) only events from the last 3 minutes do, as one found later
+ * would only record an empty doorway.
+ */
+export function getHistoryMotionEvents(device, pollSeconds) {
+    return defer(() => {
+        const startedAt = Date.now() - 5000, historySeen = new Map(), 
+        // Events that already gave motion from here (a young one is judged again later).
+        shownAsMotion = new Map(), 
+        // When an event not judged yet was first seen in the history (by the Pi's clock).
+        firstSeen = new Map(), pushIds = new Map(), pushMotionTimes = [], baseRetryMs = Math.max(pollSeconds * 1000, 30_000), forget = (ids, now) => {
+            for (const [id, at] of ids) {
+                if (now - at > ID_MEMORY_MS)
+                    ids.delete(id);
+            }
+        };
+        let pushWorks = false, matchedInARow = 0, lastCheckAt = 0, lastSuccessAt = 0, failureCount = 0, nextCheckAt = 0;
+        const notifications = device.onNewNotification.subscribe((notification) => {
+            if (notification.android_config?.category !== PushNotificationAction.Motion)
+                return;
+            const id = notification.data?.event?.ding?.id, now = Date.now();
+            if (id !== undefined)
+                pushIds.set(String(id), now);
+            pushMotionTimes.push(now);
+            if (pushMotionTimes.length > 50)
+                pushMotionTimes.shift();
+        });
+        return timer(pollSeconds * 1000, pollSeconds * 1000).pipe(exhaustMap(() => {
+            const now = Date.now();
+            if (now < nextCheckAt)
+                return EMPTY;
+            if (pushWorks && now - lastCheckAt < HISTORY_CHECK_WHILE_PUSH_WORKS_MS) {
+                return EMPTY;
+            }
+            lastCheckAt = now;
+            // Checked recently and frequently: anything new is recent, whatever the clocks say
+            // (a Pi clock ahead of Ring's would otherwise make every event look too old).
+            const checkedJustBefore = !pushWorks && now - lastSuccessAt <= pollSeconds * 1000 + 30_000;
+            return defer(() => device.getEvents({ limit: 10, kind: 'motion' })).pipe(mergeMap(({ events }) => {
+                const checkedAt = Date.now();
+                failureCount = 0;
+                nextCheckAt = 0;
+                lastSuccessAt = checkedAt;
+                // Still in the history: remembered as long as it stays there.
+                for (const event of events) {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    for (const ids of [historySeen, shownAsMotion, firstSeen, pushIds]) {
+                        if (ids.has(id) && ids !== firstSeen)
+                            ids.set(id, checkedAt);
+                    }
+                }
+                forget(historySeen, checkedAt);
+                forget(shownAsMotion, checkedAt);
+                forget(firstSeen, checkedAt);
+                forget(pushIds, checkedAt);
+                const isPushed = (event) => {
+                    const id = event.ding_id_str || String(event.ding_id), at = Date.parse(event.created_at);
+                    return (pushIds.has(id) ||
+                        pushMotionTimes.some((t) => Math.abs(t - at) <= PUSH_MATCH_WINDOW_MS));
+                };
+                const newEvents = events.filter((event) => {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    return (event.kind === 'motion' &&
+                        Date.parse(event.created_at) >= startedAt &&
+                        !historySeen.has(id));
+                });
+                // Too young to know whether its push is still coming: judged at a later check, but
+                // it can still give motion now (once). Young by when it was first seen here, so a
+                // Pi clock behind Ring's doesn't keep it young.
+                const young = (event) => {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    if (!firstSeen.has(id))
+                        firstSeen.set(id, checkedAt);
+                    return !isPushed(event) && checkedAt - (firstSeen.get(id) ?? checkedAt) < PUSH_GRACE_MS;
+                };
+                const judged = newEvents.filter((event) => !young(event)), missed = judged.filter((event) => !isPushed(event));
+                judged.forEach((event) => {
+                    const id = event.ding_id_str || String(event.ding_id);
+                    historySeen.set(id, checkedAt);
+                    firstSeen.delete(id);
+                });
+                if (pushWorks && judged.length < newEvents.length) {
+                    // An event to judge soon: check again shortly rather than in 5 minutes.
+                    lastCheckAt = checkedAt - HISTORY_CHECK_WHILE_PUSH_WORKS_MS + PUSH_GRACE_MS + 10_000;
+                }
+                if (missed.length) {
+                    matchedInARow = 0;
+                    if (pushWorks) {
+                        pushWorks = false;
+                        logInfo(`${device.name}: Ring event history shows motion no push notification reported; checking it every ${pollSeconds} s again`);
+                    }
+                }
+                else if (judged.length) {
+                    // One per check: a single push can match several events.
+                    matchedInARow += 1;
+                    if (!pushWorks && matchedInARow >= MATCHES_TO_TRUST_PUSH) {
+                        pushWorks = true;
+                        logInfo(`${device.name}: Ring push notifications are arriving; checking Ring event history every ${HISTORY_CHECK_WHILE_PUSH_WORKS_MS / 60_000} minutes instead of every ${pollSeconds} s`);
+                    }
+                }
+                const unpushedNow = newEvents.filter((event) => !isPushed(event)), givesMotion = unpushedNow.some((event) => !shownAsMotion.has(event.ding_id_str || String(event.ding_id)) &&
+                    (checkedJustBefore ||
+                        checkedAt - Date.parse(event.created_at) <= HISTORY_MOTION_MAX_AGE_MS));
+                unpushedNow.forEach((event) => shownAsMotion.set(event.ding_id_str || String(event.ding_id), checkedAt));
+                if (!givesMotion)
+                    return EMPTY;
+                logInfo(`${device.name} Detected Motion from Ring event history fallback`);
+                return of(true);
+            }), catchError(() => {
+                failureCount++;
+                const retryDelayMs = Math.min(5 * 60 * 1000, baseRetryMs * 2 ** Math.min(failureCount - 1, 4));
+                nextCheckAt = Date.now() + retryDelayMs;
+                const nextInMs = pushWorks
+                    ? Math.max(retryDelayMs, lastCheckAt + HISTORY_CHECK_WHILE_PUSH_WORKS_MS - Date.now())
+                    : retryDelayMs;
+                logError(`${device.name} failed to poll Ring event history for motion fallback; retrying in ${Math.ceil(nextInMs / 1000)} seconds`);
+                return EMPTY;
+            }));
+        }), finalize(() => notifications.unsubscribe()));
+    });
+}
+/**
+ * Motion from Ring's push notifications, as HomeKit needs it: true for every new motion alert.
+ *
+ * ring-client-api's onMotionDetected is true while any motion alert is active (each lasts 65 s)
+ * and only reports changes, so a new alert while an earlier one is still active gives nothing.
+ * The watchdog below turns motion off after 30 s, so a second visit 30-65 s after the first
+ * would never turn it on again: no recording and no notification. So every new motion
+ * notification gives a true (restarting the watchdog), and onMotionDetected only adds its
+ * false once all alerts have expired. A notification repeating an alert seen in the last two
+ * minutes (Ring sends a second one with the snapshot; a reconnect can resend) is not a new visit.
+ */
+export const REPEATED_ALERT_WINDOW_MS = 120_000;
+export function getPushMotionEvents(camera) {
+    return defer(() => {
+        const seenAt = new Map();
+        return merge(camera.onMotionDetected.pipe(filter((motion) => !motion)), camera.onNewNotification.pipe(filter((notification) => {
+            if (notification.android_config?.category !== PushNotificationAction.Motion) {
+                return false;
+            }
+            const now = Date.now(), id = notification.data?.event?.ding?.id;
+            for (const [seenId, at] of seenAt) {
+                if (now - at > REPEATED_ALERT_WINDOW_MS)
+                    seenAt.delete(seenId);
+            }
+            if (id === undefined)
+                return true;
+            if (seenAt.has(String(id)))
+                return false;
+            seenAt.set(String(id), now);
+            return true;
+        }), map(() => true)));
+    });
+}
 export function addMotionWatchdog(motionEvents, watchdogMs = MOTION_WATCHDOG_MS) {
     return motionEvents.pipe(switchMap((motion) => {
         if (!motion) {
@@ -183,56 +360,12 @@ export class Camera extends BaseDataAccessory {
         }
     }
     getMotionDetectedObservable() {
-        const pollSeconds = Math.max(this.config.cameraStatusPollingSeconds ?? 20, 10), startedAt = Date.now() - 5000, seenEventIds = new Set(), pushMotionEvents = this.device.onMotionDetected, enableMotionHistoryFallback = this.config.enableCameraMotionHistory !== false;
-        let historyFailureCount = 0;
-        let nextHistoryPollAt = 0;
-        const baseHistoryRetryMs = Math.max(pollSeconds * 1000, 30_000), polledNewMotionEvents = timer(pollSeconds * 1000, pollSeconds * 1000).pipe(exhaustMap(() => {
-            if (Date.now() < nextHistoryPollAt) {
-                return EMPTY;
-            }
-            return from(this.device.getEvents({
-                limit: 10,
-                kind: 'motion',
-            })).pipe(mergeMap(({ events }) => {
-                historyFailureCount = 0;
-                nextHistoryPollAt = 0;
-                const newMotionEvents = events
-                    .filter((event) => {
-                    const eventId = event.ding_id_str || String(event.ding_id);
-                    return (event.kind === 'motion' &&
-                        Date.parse(event.created_at) >= startedAt &&
-                        !seenEventIds.has(eventId));
-                })
-                    .sort((a, b) => Date.parse(a.created_at) - Date.parse(b.created_at));
-                newMotionEvents.forEach((event) => {
-                    seenEventIds.add(event.ding_id_str || String(event.ding_id));
-                });
-                if (!newMotionEvents.length)
-                    return EMPTY;
-                logInfo(`${this.device.name} Detected Motion from Ring event history fallback`);
-                return of(true);
-            }), catchError(() => {
-                historyFailureCount++;
-                const retryDelayMs = Math.min(5 * 60 * 1000, baseHistoryRetryMs * 2 ** Math.min(historyFailureCount - 1, 4));
-                nextHistoryPollAt = Date.now() + retryDelayMs;
-                logError(`${this.device.name} failed to poll Ring event history for motion fallback; retrying in ${Math.ceil(retryDelayMs / 1000)} seconds`);
-                return EMPTY;
-            }));
-        }), 
-        // The false timer below has a second subscriber. Sharing keeps one
-        // history request per poll instead of duplicating Ring API traffic.
-        share()), polledMotionEvents = merge(polledNewMotionEvents, polledNewMotionEvents.pipe(switchMap(() => timer(65000).pipe(map(() => false)))));
-        if (enableMotionHistoryFallback) {
-            this.device.onNewNotification.subscribe((notification) => {
-                const dingId = notification.data?.event?.ding?.id;
-                if (dingId) {
-                    seenEventIds.add(String(dingId));
-                }
-            });
+        const pushMotionEvents = getPushMotionEvents(this.device);
+        if (this.config.enableCameraMotionHistory === false) {
+            return addMotionWatchdog(pushMotionEvents);
         }
-        return addMotionWatchdog(enableMotionHistoryFallback
-            ? merge(pushMotionEvents, polledMotionEvents)
-            : pushMotionEvents);
+        const pollSeconds = Math.max(this.config.cameraStatusPollingSeconds ?? 20, 10);
+        return addMotionWatchdog(merge(pushMotionEvents, getHistoryMotionEvents(this.device, pollSeconds)));
     }
     async loadSnapshotForEvent(eventDescription, characteristicValue) {
         let imageUuid = this.device.latestNotificationSnapshotUuid;