feat: Add experimental reolink media support (#1694)

* feat: Add experimental rich reolink support.

* Formatting fix

tests/camera-manager/browse-media/utils/browse-media-to-view-media.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { BrowseMediaMetadata } from '../../../../src/camera-manager/browse-media/types';
+import { getViewMediaFromBrowseMediaArray } from '../../../../src/camera-manager/browse-media/utils/browse-media-to-view-media';
+import {
+  MEDIA_CLASS_IMAGE,
+  MEDIA_CLASS_VIDEO,
+  RichBrowseMedia,
+} from '../../../../src/utils/ha/browse-media/types';
+import { createBrowseMedia } from './test-utils';
+
+const createBrowseMediaChildren = (
+  overrides: Partial<RichBrowseMedia<BrowseMediaMetadata>>[],
+) => {
+  return overrides.map((override) => createBrowseMedia(override));
+};
+
+describe('getViewMediaFromBrowseMediaArray', () => {
+  it('should ignore absent metadata', () => {
+    const children = createBrowseMediaChildren([{ _metadata: undefined }]);
+    expect(getViewMediaFromBrowseMediaArray(children)).toEqual([]);
+  });
+
+  it('should ignore unknown media class', () => {
+    const children = createBrowseMediaChildren([{ media_class: 'UNKNOWN' }]);
+    expect(getViewMediaFromBrowseMediaArray(children)).toEqual([]);
+  });
+
+  it('should generate clip view media', () => {
+    const children = createBrowseMediaChildren([{ media_class: MEDIA_CLASS_VIDEO }]);
+    const viewMedia = getViewMediaFromBrowseMediaArray(children);
+    expect(viewMedia).toHaveLength(1);
+    expect(viewMedia?.[0].getMediaType()).toBe('clip');
+    expect(viewMedia?.[0].getID()).toBe('camera.test/2024-11-19 07:23:00');
+  });
+
+  it('should generate snapshot view media', () => {
+    const children = createBrowseMediaChildren([{ media_class: MEDIA_CLASS_IMAGE }]);
+    const viewMedia = getViewMediaFromBrowseMediaArray(children);
+    expect(viewMedia).toHaveLength(1);
+    expect(viewMedia?.[0].getMediaType()).toBe('snapshot');
+    expect(viewMedia?.[0].getID()).toBe('camera.test/2024-11-19 07:23:00');
+  });
+
+  it('should de-duplicate snapshot/clip duplicates', () => {
+    const children = createBrowseMediaChildren([
+      { media_class: MEDIA_CLASS_IMAGE },
+      { media_class: MEDIA_CLASS_IMAGE },
+      { media_class: MEDIA_CLASS_VIDEO },
+    ]);
+    const viewMedia = getViewMediaFromBrowseMediaArray(children);
+    expect(viewMedia).toHaveLength(1);
+    expect(viewMedia?.[0].getMediaType()).toBe('clip');
+    expect(viewMedia?.[0].getID()).toBe('camera.test/2024-11-19 07:23:00');
+  });
+});

tests/camera-manager/browse-media/utils/test-utils.ts

@@ -0,0 +1,23 @@
+import { BrowseMediaMetadata } from '../../../../src/camera-manager/browse-media/types';
+import { RichBrowseMedia } from '../../../../src/utils/ha/browse-media/types';
+
+export const createBrowseMedia = (
+  media?: Partial<RichBrowseMedia<BrowseMediaMetadata>>,
+): RichBrowseMedia<BrowseMediaMetadata> => {
+  return {
+    title: 'Test Media',
+    media_class: 'video',
+    media_content_type: 'video/mp4',
+    media_content_id: 'test',
+    can_play: true,
+    can_expand: false,
+    thumbnail: null,
+    children: null,
+    _metadata: {
+      cameraID: 'camera.test',
+      startDate: new Date('2024-11-19T07:23:00'),
+      endDate: new Date('2025-11-19T07:24:00'),
+    },
+    ...media,
+  };
+};

tests/camera-manager/browse-media/utils/within-dates.test.ts

@@ -0,0 +1,40 @@
+import { sub } from 'date-fns';
+import { describe, expect, it } from 'vitest';
+import { isMediaWithinDates } from '../../../../src/camera-manager/browse-media/utils/within-dates';
+import { createBrowseMedia } from './test-utils';
+
+describe('isMediaWithinDates', () => {
+  const rangeStart = new Date('2024-11-19T07:00:00');
+  const rangeEnd = new Date('2024-11-19T08:00:00');
+
+  it('should never match media without metadata', () => {
+    const media = createBrowseMedia({ _metadata: undefined });
+    expect(isMediaWithinDates(media, rangeStart, rangeEnd)).toBe(false);
+  });
+
+  it('should always match media without start or end date', () => {
+    expect(isMediaWithinDates(createBrowseMedia(), undefined, undefined)).toBe(true);
+  });
+
+  it('should match without a start date in the range', () => {
+    expect(isMediaWithinDates(createBrowseMedia(), undefined, rangeEnd)).toBe(true);
+  });
+
+  it('should match without an end date in the range', () => {
+    expect(isMediaWithinDates(createBrowseMedia(), rangeStart, undefined)).toBe(true);
+  });
+
+  it('should match when ranges overlap', () => {
+    expect(isMediaWithinDates(createBrowseMedia(), rangeStart, rangeEnd)).toBe(true);
+  });
+
+  it('should not match when ranges do not overlap', () => {
+    expect(
+      isMediaWithinDates(
+        createBrowseMedia(),
+        sub(rangeStart, { days: 1 }),
+        sub(rangeEnd, { days: 1 }),
+      ),
+    ).toBe(false);
+  });
+});

tests/camera-manager/camera.test.ts

@@ -2,7 +2,9 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { mock } from 'vitest-mock-extended';
 import { Camera } from '../../src/camera-manager/camera.js';
 import { GenericCameraManagerEngine } from '../../src/camera-manager/generic/engine-generic.js';
+import { CameraProxyConfig } from '../../src/camera-manager/types.js';
 import { StateWatcherSubscriptionInterface } from '../../src/card-controller/hass/state-watcher.js';
+import { ProxyConfig } from '../../src/config/types.js';
 import {
   callStateWatcherCallback,
   createCameraConfig,
@@ -137,4 +139,124 @@ describe('Camera', () => {
       },
     );
   });
+
+  describe('should get proxy config', () => {
+    it.each([
+      [
+        'when unspecified',
+        {},
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when media set to true',
+        { media: true },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when media set to false',
+        { media: false as const },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when media set to auto',
+        { media: 'auto' as const },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when ssl_verification is set to auto',
+        { ssl_verification: 'auto' as const },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when ssl_verification is set to true',
+        { ssl_verification: true },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when ssl_verification is set to false',
+        { ssl_verification: false },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: false,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when ssl_ciphers is set to auto',
+        { ssl_ciphers: 'auto' as const },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+      [
+        'when ssl_ciphers is set to modern',
+        { ssl_ciphers: 'modern' as const },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'modern' as const,
+        },
+      ],
+      [
+        'when dynamic is set to false',
+        { dynamic: false },
+        {
+          dynamic: false,
+          media: false,
+          ssl_verification: true,
+          ssl_ciphers: 'default' as const,
+        },
+      ],
+    ])(
+      '%s',
+      (
+        _name: string,
+        proxyConfig: Partial<ProxyConfig>,
+        expectedResult: CameraProxyConfig,
+      ) => {
+        const camera = new Camera(
+          createCameraConfig({
+            proxy: proxyConfig,
+          }),
+          new GenericCameraManagerEngine(mock<StateWatcherSubscriptionInterface>()),
+        );
+        expect(camera.getProxyConfig()).toEqual(expectedResult);
+      },
+    );
+  });
 });

tests/camera-manager/engine-factory.test.ts

@@ -18,6 +18,7 @@ import {
   createRegistryEntity,
   createStateEntity,
 } from '../test-utils';
+import { ReolinkCameraManagerEngine } from '../../src/camera-manager/reolink/engine-reolink.js';
 
 vi.mock('../../src/utils/ha/entity-registry');
 vi.mock('../../src/utils/ha/entity-registry/cache');
@@ -70,7 +71,7 @@ describe('getEngineForCamera()', () => {
     });
   });
 
-  describe('should get a motionEye camera', () => {
+  describe('should get a motioneye camera', () => {
     it('from manually set engine', async () => {
       const config = createCameraConfig({ engine: 'motioneye' });
       expect(await createFactory().getEngineForCamera(createHASS(), config)).toBe(
@@ -98,6 +99,34 @@ describe('getEngineForCamera()', () => {
     });
   });
 
+  describe('should get a reolink camera', () => {
+    it('from manually set engine', async () => {
+      const config = createCameraConfig({ engine: 'reolink' });
+      expect(await createFactory().getEngineForCamera(createHASS(), config)).toBe(
+        Engine.Reolink,
+      );
+    });
+
+    it('from auto detection', async () => {
+      const config = createCameraConfig({ engine: 'auto', camera_entity: 'camera.foo' });
+      const entityRegistryManager = new EntityRegistryManager(
+        createEntityRegistryCache(),
+      );
+
+      entityRegistryManager.getEntity = vi
+        .fn()
+        .mockResolvedValue(
+          createRegistryEntity({ entity_id: 'camera.foo', platform: 'reolink' }),
+        );
+
+      expect(
+        await createFactory({
+          entityRegistryManager: entityRegistryManager,
+        }).getEngineForCamera(createHASS(), config),
+      ).toBe(Engine.Reolink);
+    });
+  });
+
   describe('should get a generic camera', () => {
     it('from manually set engine', async () => {
       const config = createCameraConfig({ engine: 'generic' });
@@ -233,4 +262,12 @@ describe('createEngine()', () => {
       }),
     ).toBeInstanceOf(MotionEyeCameraManagerEngine);
   });
+  it('should create reolink engine', async () => {
+    expect(
+      await createFactory().createEngine(Engine.Reolink, {
+        stateWatcher: mock<StateWatcherSubscriptionInterface>(),
+        resolvedMediaCache: mock<ResolvedMediaCache>(),
+      }),
+    ).toBeInstanceOf(ReolinkCameraManagerEngine);
+  });
 });

tests/camera-manager/frigate/requests.test.ts

@@ -18,10 +18,10 @@ import {
   retainResultSchema,
 } from '../../../src/camera-manager/frigate/types';
 import { RecordingSegment } from '../../../src/camera-manager/types';
-import { homeAssistantWSRequest } from '../../../src/utils/ha';
+import { homeAssistantWSRequest } from '../../../src/utils/ha/ws-request';
 import { createFrigateEvent, createHASS } from '../../test-utils';
 
-vi.mock('../../../src/utils/ha');
+vi.mock('../../../src/utils/ha/ws-request');
 
 describe('frigate requests', () => {
   afterEach(() => {

tests/camera-manager/reolink/camera.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, it } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { CameraManagerEngine } from '../../../src/camera-manager/engine';
+import { ReolinkCamera } from '../../../src/camera-manager/reolink/camera';
+import { CameraProxyConfig } from '../../../src/camera-manager/types';
+import { StateWatcher } from '../../../src/card-controller/hass/state-watcher';
+import { ProxyConfig } from '../../../src/config/types';
+import { EntityRegistryManager } from '../../../src/utils/ha/registry/entity';
+import { createCameraConfig, createHASS, createRegistryEntity } from '../../test-utils';
+
+describe('ReolinkCamera', () => {
+  describe('should initialize config', () => {
+    describe('should detect channel', () => {
+      it('without a camera_entity', async () => {
+        const config = createCameraConfig();
+        const camera = new ReolinkCamera(config, mock<CameraManagerEngine>());
+
+        expect(
+          async () =>
+            await camera.initialize({
+              hass: createHASS(),
+              entityRegistryManager: mock<EntityRegistryManager>(),
+              stateWatcher: mock<StateWatcher>(),
+            }),
+        ).rejects.toThrowError('Could not find camera entity');
+      });
+
+      it('without a unique_id', async () => {
+        const config = createCameraConfig({
+          camera_entity: 'camera.office_reolink',
+        });
+        const camera = new ReolinkCamera(config, mock<CameraManagerEngine>());
+
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        const entity = createRegistryEntity({
+          platform: 'reolink',
+        });
+        entityRegistryManager.getEntity.mockResolvedValue(entity);
+
+        expect(
+          async () =>
+            await camera.initialize({
+              hass: createHASS(),
+              entityRegistryManager: entityRegistryManager,
+              stateWatcher: mock<StateWatcher>(),
+            }),
+        ).rejects.toThrowError('Could not initialize Reolink camera');
+      });
+
+      it('without a channel in the unique_id', async () => {
+        const config = createCameraConfig({
+          camera_entity: 'camera.office_reolink',
+        });
+        const camera = new ReolinkCamera(config, mock<CameraManagerEngine>());
+
+        const entityRegistryManager = mock<EntityRegistryManager>();
+        const entity = createRegistryEntity({
+          unique_id: 'invalid',
+          platform: 'reolink',
+        });
+        entityRegistryManager.getEntity.mockResolvedValue(entity);
+
+        expect(
+          async () =>
+            await camera.initialize({
+              hass: createHASS(),
+              entityRegistryManager: entityRegistryManager,
+              stateWatcher: mock<StateWatcher>(),
+            }),
+        ).rejects.toThrowError('Could not initialize Reolink camera');
+      });
+    });
+
+    it('successfully with main camera', async () => {
+      const config = createCameraConfig({
+        camera_entity: 'camera.office_reolink',
+      });
+      const camera = new ReolinkCamera(config, mock<CameraManagerEngine>());
+
+      const entityRegistryManager = mock<EntityRegistryManager>();
+      const entity = createRegistryEntity({
+        unique_id: '85270002TS7D4RUP_0_main',
+        platform: 'reolink',
+      });
+      entityRegistryManager.getEntity.mockResolvedValue(entity);
+
+      await camera.initialize({
+        hass: createHASS(),
+        entityRegistryManager: entityRegistryManager,
+        stateWatcher: mock<StateWatcher>(),
+      });
+
+      expect(camera.getChannel()).toBe(0);
+    });
+  });
+
+  describe('should get proxy config', () => {
+    it.each([
+      [
+        'when unspecified',
+        {},
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when media set to on',
+        { media: true },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when media set to off',
+        { media: false },
+        {
+          dynamic: true,
+          media: false,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when media set to auto',
+        { media: 'auto' as const },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when ssl_verification is set to auto',
+        { ssl_verification: 'auto' as const },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when ssl_verification is set to true',
+        { ssl_verification: true },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: true,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when ssl_verification is set to false',
+        { ssl_verification: false },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when ssl_ciphers is set to auto',
+        { ssl_ciphers: 'auto' as const },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+      [
+        'when ssl_ciphers is set to modern',
+        { ssl_ciphers: 'modern' as const },
+        {
+          dynamic: true,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'modern' as const,
+        },
+      ],
+      [
+        'when dynamic is set to false',
+        { dynamic: false },
+        {
+          dynamic: false,
+          media: true,
+          ssl_verification: false,
+          ssl_ciphers: 'intermediate' as const,
+        },
+      ],
+    ])(
+      '%s',
+      (
+        _name: string,
+        proxyConfig: Partial<ProxyConfig>,
+        expectedResult: CameraProxyConfig,
+      ) => {
+        const camera = new ReolinkCamera(
+          createCameraConfig({
+            proxy: proxyConfig,
+          }),
+          mock<CameraManagerEngine>(),
+        );
+        expect(camera.getProxyConfig()).toEqual(expectedResult);
+      },
+    );
+  });
+});