fix: improved snapshot timing for battery cameras

Author: dgreif

api/ring-camera.ts

@@ -1,10 +1,10 @@
 import {
   ActiveDing,
+  batteryCameraKinds,
   CameraData,
   CameraHealth,
   HistoricalDingGlobal,
   RingCameraModel,
-  batteryCameraKinds,
   SnapshotTimestamp
 } from './ring-types'
 import { clientApi, RingRestClient } from './rest-client'
@@ -20,7 +20,7 @@ import {
 } from 'rxjs/operators'
 import { createSocket } from 'dgram'
 import { bindToRandomPort, getPublicIp } from './rtp-utils'
-import { delay, logError } from './util'
+import { delay, logError, logInfo } from './util'
 import { SipSession, SrtpOptions } from './sip-session'
 
 const getPort = require('get-port')
@@ -204,7 +204,11 @@ export class RingCamera {
     return response.url
   }
 
-  private async getTimestampAge() {
+  private isTimestampInLifeTime(timestampAge: number) {
+    return timestampAge < this.snapshotLifeTime
+  }
+
+  private async getSnapshotTimestamp() {
     const { timestamps, responseTimestamp } = await this.restClient.request<{
         timestamps: SnapshotTimestamp[]
       }>({
@@ -216,34 +220,44 @@ export class RingCamera {
         json: true
       }),
       deviceTimestamp = timestamps[0],
-      timestamp = deviceTimestamp ? deviceTimestamp.timestamp : 0
-
-    return Math.abs(responseTimestamp - timestamp)
-  }
-
-  private refreshSnapshotInProgress?: Promise<void>
-  private snapshotLifeTime = (this.hasBattery ? 600 : 30) * 1000 // battery cams only refresh timestamp every 10 minutes
+      timestamp = deviceTimestamp ? deviceTimestamp.timestamp : 0,
+      timestampAge = Math.abs(responseTimestamp - timestamp)
 
-  private async refreshSnapshot(allowStale: boolean) {
-    const initialTimestampAge = await this.getTimestampAge(),
-      snapshotInLifeTime = initialTimestampAge < this.snapshotLifeTime
+    this.lastSnapshotTimestampLocal = timestamp ? Date.now() - timestampAge : 0
 
-    if (allowStale && (this.hasBattery || snapshotInLifeTime)) {
-      // battery cameras take a long time to refresh snapshots.  Just return the stale one immediately.
-      // for non battery, stale snapshots can be used if they are within the last 30 seconds
-      return
+    return {
+      timestamp,
+      inLifeTime: this.isTimestampInLifeTime(timestampAge)
     }
+  }
 
-    if (snapshotInLifeTime) {
-      // not allowing stale, so wait until a new snapshot should be available
-      await delay(this.snapshotLifeTime - initialTimestampAge)
+  private refreshSnapshotInProgress?: Promise<boolean>
+  private snapshotLifeTime = (this.hasBattery ? 600 : 30) * 1000 // battery cams only refresh timestamp every 10 minutes
+  private lastSnapshotTimestampLocal = 0
+  private lastSnapshotPromise?: Promise<Buffer>
+
+  private async refreshSnapshot() {
+    const currentTimestampAge = Date.now() - this.lastSnapshotTimestampLocal
+    if (this.isTimestampInLifeTime(currentTimestampAge)) {
+      logInfo(
+        `Snapshot for ${
+          this.name
+        } is still within it's life time (${currentTimestampAge / 1000}s old)`
+      )
+      return true
     }
 
     for (let i = 0; i < maxSnapshotRefreshAttempts; i++) {
-      const timestampAge = await this.getTimestampAge()
+      const { timestamp, inLifeTime } = await this.getSnapshotTimestamp()
 
-      if (timestampAge < initialTimestampAge) {
-        return
+      if (!timestamp && this.isOffline) {
+        throw new Error(
+          `No snapshot available and device ${this.name} is offline`
+        )
+      }
+
+      if (inLifeTime) {
+        return false
       }
 
       await delay(snapshotRefreshDelay)
@@ -256,23 +270,35 @@ export class RingCamera {
 
   async getSnapshot(allowStale = false) {
     this.refreshSnapshotInProgress =
-      this.refreshSnapshotInProgress || this.refreshSnapshot(allowStale)
+      this.refreshSnapshotInProgress || this.refreshSnapshot()
 
     try {
-      await this.refreshSnapshotInProgress
+      const useLastSnapshot = await this.refreshSnapshotInProgress
+
+      if (useLastSnapshot && this.lastSnapshotPromise) {
+        this.refreshSnapshotInProgress = undefined
+        return this.lastSnapshotPromise
+      }
     } catch (e) {
+      logError(e.message)
       if (!allowStale) {
-        logError(e)
         throw e
       }
     }
 
     this.refreshSnapshotInProgress = undefined
 
-    return this.restClient.request<Buffer>({
+    this.lastSnapshotPromise = this.restClient.request<Buffer>({
       url: clientApi(`snapshots/image/${this.id}`),
       responseType: 'arraybuffer'
     })
+
+    this.lastSnapshotPromise.catch(() => {
+      // snapshot request failed, don't use it again
+      this.lastSnapshotPromise = undefined
+    })
+
+    return this.lastSnapshotPromise
   }
 
   sipUsedDingIds: string[] = []

homebridge/README.md

@@ -98,19 +98,18 @@ Walk through the setup pages and when you are done, you should see several devic
 
   * Camera Feed
     * Shows a snapshot from the camera while viewing the room in Home
-    * (**NEW**) Shows a live feed from the camera if you click on it.  This still has some kinks to work out, like lack of sound and only staying active for about 30 seconds.  I will be tweaking live feeds over the coming weeks.
+    * Shows a live feed from the camera if you click on it.  The feed is **video only** and may not work on some networks with strict NAT settings.
   * Motion Sensor
     * Can be hidden with `hideCameraMotionSensor`
- * Light (if camera is equipped)
+  * Light (if camera is equipped)
   * Siren Switch (if camera is equipped)
     * Can be hidden with `hideCameraSirenSwitch`
   * Programmable switch for doorbells (triggers `Single Press` actions)
     * Note: doorbell event notifications should be configured via settings on the camera feed
     * Can be hidden with `hideDoorbellSwitch`
 
-**Battery Camera Limitations** - Ring cameras that have batteries (even if they are wired) only refresh their snapshot image every 10 minutes (vs 30 seconds for wired cameras).
-Because of this limitation, most snapshots for these cameras will be stale (meaning they could have been taken minutes or hours in the past).
-This is limitation of the Ring api does not have a good workaround at this point.
+**Battery Camera Limitations** - Ring cameras that have batteries (even if they are plugged in or using solar) only refresh their snapshot image every 10 minutes (vs 30 seconds for wired cameras).
+Because of this limitation, snapshots from these cameras may be up to 10 minutes old.  This is a limitation of the Ring api and there is no way to work around it.
 
 If you turn on notifications for the motion sensors, or for any doorbell camera, you will get rich notifications from
 HomeKit with a snapshot from the camera

homebridge/camera-source.ts

@@ -75,20 +75,12 @@ export class CameraSource {
   ) {
     const start = Date.now()
     try {
-      this.logger.info(`Snapshot Requested for ${this.ringCamera.name}`)
-
-      if (this.ringCamera.isOffline) {
-        this.logger.error(
-          `Cannot retrieve snapshot because ${this.ringCamera.name} is offline.  Make sure it has power and a good wifi connection.`
-        )
-        callback(new Error('Offline'))
-        return
-      }
+      this.logger.info(`Snapshot for ${this.ringCamera.name} Requested`)
 
       const snapshot = await this.ringCamera.getSnapshot(true),
         duration = (Date.now() - start) / 1000
       this.logger.info(
-        `Snapshot Received for ${this.ringCamera.name} (${getDurationSeconds(
+        `Snapshot for ${this.ringCamera.name} Received (${getDurationSeconds(
           start
         )}s)`
       )
@@ -101,7 +93,7 @@ export class CameraSource {
           this.ringCamera.name
         } (${getDurationSeconds(
           start
-        )}s).  Make sure the camera has power and a good wifi connection. The camera currently reports that is it ${
+        )}s).  The camera currently reports that is it ${
           this.ringCamera.isOffline ? 'offline' : 'online'
         }`
       )