Refactor Frigate specific details out of ViewMediaBase.

src/camera/frigate/engine-frigate.ts

@@ -6,8 +6,7 @@ import { CAMERA_BIRDSEYE } from '../../const';
 import { CameraConfig, RecordingSegment } from '../../types';
 import { MediaQueriesResults } from '../../view/media-queries-results';
 import { MediaQueriesClassifier } from '../../view/media-queries-classifier';
-import { ViewMedia, ViewMediaFactory } from '../../view/media';
-import { ViewMediaClassifier } from '../../view/media-classifier';
+import { ViewMedia } from '../../view/media';
 import { RecordingSegmentsCache } from '../cache';
 import {
   CameraManagerEngine,
@@ -45,6 +44,9 @@ import throttle from 'lodash-es/throttle';
 import { runWhenIdleIfSupported } from '../../utils/basic';
 import { fromUnixTime } from 'date-fns';
 import { sum } from 'lodash-es';
+import { FrigateViewMediaClassifier } from './media-classifier';
+import { ViewMediaClassifier } from '../../view/media-classifier';
+import { FrigateViewMediaFactory } from './media';
 
 const EVENT_REQUEST_CACHE_MAX_AGE_SECONDS = 60;
 const RECORDING_SUMMARY_REQUEST_CACHE_MAX_AGE_SECONDS = 60;
@@ -93,13 +95,13 @@ export class FrigateCameraManagerEngine implements CameraManagerEngine {
     media: ViewMedia,
   ): string | null {
     let path: string | null = null;
-    if (ViewMediaClassifier.isFrigateEvent(media)) {
+    if (FrigateViewMediaClassifier.isFrigateEvent(media)) {
       path =
         `/api/frigate/${cameraConfig.frigate.client_id}` +
         `/notifications/${media.getID()}/` +
         `${ViewMediaClassifier.isClip(media) ? 'clip.mp4' : 'snapshot.jpg'}` +
         `?download=true`;
-    } else if (ViewMediaClassifier.isFrigateRecording(media)) {
+    } else if (FrigateViewMediaClassifier.isFrigateRecording(media)) {
       path =
         `/api/frigate/${cameraConfig.frigate.client_id}` +
         `/recording/${cameraConfig.frigate.camera_name}` +
@@ -160,7 +162,7 @@ export class FrigateCameraManagerEngine implements CameraManagerEngine {
     favorite: boolean,
   ): Promise<void> {
     const clientID = cameraConfig.frigate.client_id;
-    if (!ViewMediaClassifier.isFrigateEvent(media)) {
+    if (!FrigateViewMediaClassifier.isFrigateEvent(media)) {
       return;
     }
 
@@ -331,7 +333,7 @@ export class FrigateCameraManagerEngine implements CameraManagerEngine {
       if (!mediaType) {
         continue;
       }
-      const media = ViewMediaFactory.createViewMediaFromFrigateEvent(
+      const media = FrigateViewMediaFactory.createEventViewMedia(
         mediaType,
         query.cameraID,
         event,
@@ -353,7 +355,7 @@ export class FrigateCameraManagerEngine implements CameraManagerEngine {
 
     const output: ViewMedia[] = [];
     for (const recording of results.recordings) {
-      const media = ViewMediaFactory.createViewMediaFromFrigateRecording(
+      const media = FrigateViewMediaFactory.createRecordingViewMedia(
         query.cameraID,
         recording,
       );

src/camera/frigate/media-classifier.ts

@@ -0,0 +1,18 @@
+import { ViewMedia } from '../../view/media';
+import { FrigateEventViewMedia, FrigateRecordingViewMedia } from './media';
+
+export class FrigateViewMediaClassifier {
+  public static isFrigateMedia(
+    media: ViewMedia,
+  ): media is FrigateEventViewMedia | FrigateRecordingViewMedia {
+    return this.isFrigateEvent(media) || this.isFrigateRecording(media);
+  }
+  public static isFrigateEvent(media: ViewMedia): media is FrigateEventViewMedia {
+    return media instanceof FrigateEventViewMedia;
+  }
+  public static isFrigateRecording(
+    media: ViewMedia,
+  ): media is FrigateRecordingViewMedia {
+    return media instanceof FrigateRecordingViewMedia;
+  }
+}

src/camera/frigate/media.ts

@@ -0,0 +1,164 @@
+import fromUnixTime from 'date-fns/fromUnixTime';
+import isEqual from 'lodash-es/isEqual';
+import { CameraConfig } from '../../types';
+import { ViewMediaBase, EventViewMedia, RecordingViewMedia } from '../../view/media';
+import { FrigateEvent, FrigateRecording } from './types';
+import {
+  getEventMediaContentID,
+  getEventThumbnailURL,
+  getEventTitle,
+  getRecordingMediaContentID,
+  getRecordingTitle,
+} from './util';
+
+export class FrigateEventViewMedia
+  extends ViewMediaBase<FrigateEvent>
+  implements EventViewMedia<FrigateEvent>
+{
+  public hasClip(): boolean {
+    return !!this._source.has_clip;
+  }
+  public getStartTime(): Date {
+    return fromUnixTime(this._source.start_time);
+  }
+  public getEndTime(): Date | null {
+    return this._source.end_time ? fromUnixTime(this._source.end_time) : null;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public getID(_cameraConfig?: CameraConfig): string {
+    return this._source.id;
+  }
+  public getContentID(cameraConfig?: CameraConfig): string | null {
+    if (
+      !cameraConfig ||
+      !cameraConfig.frigate.client_id ||
+      !cameraConfig.frigate.camera_name
+    ) {
+      return null;
+    }
+    return getEventMediaContentID(
+      cameraConfig.frigate.client_id,
+      cameraConfig.frigate.camera_name,
+      this._source,
+      this._mediaType === 'clip' ? 'clips' : 'snapshots',
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public getTitle(_cameraConfig?: CameraConfig): string | null {
+    return getEventTitle(this._source);
+  }
+
+  public getThumbnail(cameraConfig?: CameraConfig): string | null {
+    if (cameraConfig?.frigate.client_id) {
+      return getEventThumbnailURL(cameraConfig.frigate.client_id, this._source);
+    }
+    return null;
+  }
+  public isFavorite(): boolean | null {
+    return this._source.retain_indefinitely ?? null;
+  }
+  public setFavorite(favorite: boolean): void {
+    this._source.retain_indefinitely = favorite;
+  }
+  public getWhat(): string[] | null {
+    return [this._source.label];
+  }
+  public getWhere(): string[] | null {
+    const zones = this._source.zones;
+    return zones.length ? zones : null;
+  }
+  public getScore(): number | null {
+    return this._source.top_score;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public isGroupableWith(that: EventViewMedia<unknown>): boolean {
+    return (
+      this.getMediaType() === that.getMediaType() &&
+      isEqual(this.getWhere(), that.getWhere()) &&
+      isEqual(this.getWhat(), that.getWhat())
+    );
+  }
+
+  public getClipEquivalent(): EventViewMedia<FrigateEvent> | null {
+    if (!this.hasClip()) {
+      return null;
+    }
+    return FrigateViewMediaFactory.createEventViewMedia(
+      'clip',
+      this._cameraID,
+      this._source,
+    );
+  }
+}
+
+export class FrigateRecordingViewMedia
+  extends ViewMediaBase<FrigateRecording>
+  implements RecordingViewMedia<FrigateRecording>
+{
+  public getID(cameraConfig?: CameraConfig): string | null {
+    // ID name is derived from the real camera name (not CameraID) since the
+    // recordings for the same camera across multiple zones will be the same and
+    // can be dedup'd from this id.
+    if (cameraConfig) {
+      return `${cameraConfig.frigate?.client_id ?? ''}/${
+        cameraConfig.frigate.camera_name ?? ''
+      }/${this._source.startTime.getTime()}/${this._source.endTime.getTime()}}`;
+    }
+    return null;
+  }
+  public getStartTime(): Date {
+    return this._source.startTime;
+  }
+  public getEndTime(): Date {
+    return this._source.endTime;
+  }
+  public getContentID(cameraConfig?: CameraConfig): string | null {
+    if (
+      !cameraConfig ||
+      !cameraConfig.frigate.client_id ||
+      !cameraConfig.frigate.camera_name
+    ) {
+      return null;
+    }
+    return getRecordingMediaContentID(
+      cameraConfig.frigate.client_id,
+      cameraConfig.frigate.camera_name,
+      this._source,
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public getTitle(cameraConfig?: CameraConfig): string | null {
+    if (!cameraConfig) {
+      return null;
+    }
+    return getRecordingTitle(cameraConfig, this._source);
+  }
+  public getEventCount(): number {
+    return this._source.events;
+  }
+}
+
+export class FrigateViewMediaFactory {
+  static createEventViewMedia(
+    type: 'clip' | 'snapshot',
+    cameraID: string,
+    event: FrigateEvent,
+  ): FrigateEventViewMedia | null {
+    if (
+      (type === 'clip' && event.has_clip) ||
+      (type === 'snapshot' && event.has_snapshot)
+    ) {
+      return new FrigateEventViewMedia(type, cameraID, event);
+    }
+    return null;
+  }
+
+  static createRecordingViewMedia(
+    cameraID: string,
+    recording: FrigateRecording,
+  ): FrigateRecordingViewMedia | null {
+    return new FrigateRecordingViewMedia('recording', cameraID, recording);
+  }
+}

src/camera/frigate/util.ts

@@ -1,6 +1,5 @@
 import utcToZonedTime from 'date-fns-tz/utcToZonedTime';
-import fromUnixTime from 'date-fns/fromUnixTime';
-import { ClipsOrSnapshots } from '../../types';
+import { CameraConfig, ClipsOrSnapshots } from '../../types';
 import { formatDateAndTime, prettifyTitle } from '../../utils/basic';
 import { FrigateEvent, FrigateRecording } from './types';
 
@@ -22,9 +21,12 @@ export const getEventTitle = (event: FrigateEvent): string => {
   )}%]`;
 };
 
-export const getRecordingTitle = (recording: FrigateRecording): string => {
-  return `${prettifyTitle(recording.camera)} ${formatDateAndTime(
-    fromUnixTime(recording.start_time),
+export const getRecordingTitle = (
+  cameraConfig: CameraConfig,
+  recording: FrigateRecording,
+): string => {
+  return `${prettifyTitle(cameraConfig.frigate.camera_name)} ${formatDateAndTime(
+    recording.startTime,
   )}`;
 };
 
@@ -67,15 +69,16 @@ export const getRecordingMediaContentID = (
   cameraName: string,
   recording: FrigateRecording,
 ): string => {
-  const date = fromUnixTime(recording.start_time);
   return [
     'media-source://frigate',
     clientId,
     'recordings',
     cameraName,
-    `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(
-      String(date.getDate()).padStart(2, '0'),
+    `${recording.startTime.getFullYear()}-${String(
+      recording.startTime.getMonth() + 1,
+    ).padStart(2, '0')}-${String(
+      String(recording.startTime.getDate()).padStart(2, '0'),
     )}`,
-    String(date.getHours()).padStart(2, '0'),
+    String(recording.startTime.getHours()).padStart(2, '0'),
   ].join('/');
 };