@apocaliss92/scrypted-advanced-notifier 4.8.37 → 4.8.39

package/CHANGELOG.md

@@ -1,6 +1,10 @@
 <details>
 <summary>Changelog</summary>
 
+### 4.8.39
+
+Added section on every battery camera to setup the battery management based on customizable thresholds
+
 ### 4.8.37
 
 - **On-generated sequences**: new sequence hook for Detection, Occupancy and Timelapse rules. Runs when all rule artifacts (video, gif, image) have been generated. Configurable per rule under "On-generated sequences". Script actions in the sequence receive a `payload` object (e.g. `variables.payload` in Scrypted scripts) with `rule`, `videoUrl`, `gifUrl`, `imageUrl` (and for timelapse also `videoPath`, `imagePath`). Any sequence can now receive an optional payload and forward it to linked scripts.

package/docs/INTERFACE_DESCRIPTORS_MIGRATION.md

@@ -0,0 +1,184 @@
+# Migrazione da Webhook HTTP a Socket SDK con interfaceDescriptors
+
+Piano per esporre i metodi Events App via **interfaceDescriptors** (come [@scrypted/llm](https://github.com/scryptedapp/llm)), eliminando le chiamate REST e usando solo la socket SDK.
+
+---
+
+## 1. Come funziona interfaceDescriptors (LLM plugin)
+
+Dal [package.json dell'LLM](https://github.com/scryptedapp/llm/blob/main/package.json):
+
+```json
+{
+  "scrypted": {
+    "interfaces": ["DeviceProvider", "UserDatabase", ...],
+    "interfaceDescriptors": {
+      "UserDatabase": {
+        "name": "UserDatabase",
+        "methods": ["openDatabase"],
+        "properties": []
+      }
+    }
+  }
+}
+```
+
+- **interfaceDescriptors** dichiara interfacce custom con metodi e proprietà
+- Il server Scrypted usa questi descrittori per esporre i metodi via RPC sulla socket
+- Il client può chiamare `device.openDatabase()` invece di fare HTTP
+
+---
+
+## 2. Metodi Events App da esporre (handleEventsAppRequest)
+
+| apimethod | payload | Note |
+|-----------|---------|------|
+| GetConfigs | — | |
+| GetCamerasStatus | — | |
+| GetEvents | fromDate, tillDate, limit, offset, sources, cameras, detectionClasses, eventSource, filter, groupingRange | |
+| GetVideoclips | fromDate, tillDate, limit, offset, cameras, detectionClasses | |
+| GetCameraDayData | deviceId, day | |
+| GetClusteredDayData | deviceId, days, bucketMs, enabledClasses, classFilter | |
+| GetClusterEvents | clusterId, deviceId, startMs, endMs | |
+| GetArtifacts | deviceId, day | |
+| GetLatestRuleArtifacts | deviceId, limit | |
+| RemoteLog | level, message | |
+
+---
+
+## 3. Modifiche al plugin advanced-notifier
+
+### 3.1 package.json — aggiungere interfaceDescriptors
+
+```json
+{
+  "scrypted": {
+    "interfaces": ["Settings", "DeviceProvider", "MixinProvider", "HttpRequestHandler", "Videoclips", "LauncherApplication", "PushHandler"],
+    "interfaceDescriptors": {
+      "EventsAppApi": {
+        "name": "EventsAppApi",
+        "methods": [
+          "getConfigs",
+          "getCamerasStatus",
+          "getEvents",
+          "getVideoclips",
+          "getCameraDayData",
+          "getClusteredDayData",
+          "getClusterEvents",
+          "getArtifacts",
+          "getLatestRuleArtifacts",
+          "remoteLog"
+        ],
+        "properties": []
+      }
+    }
+  }
+}
+```
+
+### 3.2 utils.ts — costante interfaccia
+
+```ts
+export const EVENTS_APP_API_INTERFACE = "EventsAppApi";
+```
+
+### 3.3 main.ts — aggiungere interfaccia al data fetcher
+
+In `onDeviceDiscovered` per DATA_FETCHER_NATIVE_ID:
+
+```ts
+interfaces: [
+  ScryptedInterface.VideoClips,
+  ScryptedInterface.EventRecorder,
+  ScryptedInterface.Settings,
+  EVENTS_APP_API_INTERFACE,  // <-- aggiungere
+],
+```
+
+### 3.4 dataFetcher.ts — implementare EventsAppApi
+
+La classe `AdvancedNotifierDataFetcher` deve implementare i metodi pubblici che mappano 1:1 con gli apimethod. Esempio:
+
+```ts
+// EventsAppApi interface
+async getConfigs(): Promise<{ cameras: ...; enabledDetectionSources: string[] }> {
+  const { statusCode, body } = await this.handleEventsAppRequest('GetConfigs', {});
+  if (statusCode !== 200) throw new Error(JSON.stringify(body));
+  return body as any;
+}
+async getCamerasStatus(): Promise<CamerasStatusResponse> { ... }
+async getEvents(payload: GetEventsPayload): Promise<GetEventsResponse> { ... }
+// ... etc
+```
+
+Oppure, più pulito: estrarre la logica da `handleEventsAppRequest` in metodi dedicati e far sì che `handleEventsAppRequest` li chiami, così si evita duplicazione.
+
+---
+
+## 4. Come il server Scrypted gestisce interfaceDescriptors
+
+Il server Scrypted (koush/scrypted) legge `interfaceDescriptors` dal `package.json` del plugin. Quando un device dichiara un'interfaccia in `interfaces`, il server:
+
+1. Verifica che l'interfaccia sia in `interfaceDescriptors` (per interfacce custom)
+2. Espone i metodi via RPC sulla socket Engine.IO
+3. Il client `@scrypted/client` può chiamare `device.getConfigs()` e la chiamata viene serializzata e inviata via socket
+
+Non serve modificare il server: il supporto è già presente. Il client deve solo usare `client.systemManager.getDeviceById(deviceId)` e chiamare i metodi sull'oggetto restituito.
+
+---
+
+## 5. Modifiche al client (camstack / scrypted-an-frontend)
+
+### 5.1 Trovare il device Events App
+
+Il device "Advanced notifier data fetcher" ha tipo `API` e implementa `EventsAppApi`. Per ottenere il suo ID:
+
+```ts
+const state = client.systemManager.getSystemState();
+const eventsAppDeviceId = Object.entries(state).find(
+  ([_, d]) => (d as any)?.interfaces?.includes?.('EventsAppApi')
+)?.[0];
+```
+
+Oppure cercare per nome/tipo se lo stato lo espone.
+
+### 5.2 Sostituire fetch con chiamate SDK
+
+**Prima (HTTP):**
+```ts
+const res = await fetch(`${baseUrl}/eventsApp`, {
+  method: 'POST',
+  body: JSON.stringify({ apimethod: 'GetClusteredDayData', payload: { deviceId, days, bucketMs } }),
+  headers: { 'Content-Type': 'application/json', Authorization: getAuthHeader(auth) },
+});
+const data = await res.json();
+```
+
+**Dopo (Socket):**
+```ts
+const client = await getScryptedClient(auth);
+const device = client.systemManager.getDeviceById(eventsAppDeviceId) as EventsAppApi;
+const data = await device.getClusteredDayData({ deviceId, days, bucketMs });
+```
+
+### 5.3 Cosa resta su HTTP
+
+- **URL di immagini/thumbnail/video**: usati in `<Image src={url} />` e `<Video source={{ uri }} />` — devono restare URL HTTP. Il plugin continua a servire `/eventThumbnail/...`, `/eventImage/...`, `/eventVideoclip/...` via HttpRequestHandler.
+- **Autenticazione**: la socket SDK usa già le credenziali del client (login con username/password). Non serve più Basic auth per le chiamate dati.
+
+---
+
+## 6. Ordine di implementazione
+
+1. **Plugin**: aggiungere `interfaceDescriptors` e `EVENTS_APP_API_INTERFACE`, implementare i metodi su `AdvancedNotifierDataFetcher`
+2. **Mantenere HttpRequestHandler**: per `apimethod` POST a `/eventsApp` — opzionale durante la transizione (fallback)
+3. **Client**: creare `eventsAppSdk.ts` che usa la socket; `eventsAppApi.ts` può passare a usare l'SDK quando il client è connesso
+4. **Rimuovere** le chiamate fetch a `/eventsApp` dal client una volta validato l'SDK
+
+---
+
+## 7. Riferimenti
+
+- [LLM plugin package.json](https://github.com/scryptedapp/llm/blob/main/package.json) — esempio interfaceDescriptors
+- [Scrypted Developer Docs](https://developer.scrypted.app/) — interfacce e plugin
+- [@scrypted/client](https://www.npmjs.com/package/@scrypted/client) — SDK client con socket

package/docs/PLAN-RECORDER-MIXIN-AND-UNIFIED-PIPELINE.md

@@ -0,0 +1,203 @@
+# Piano: Advanced Notifier Recorder mixin e pipeline unificata
+
+Piano per un’estensiva modifica al plugin Advanced Notifier: **sostituire** decoder, ffmpeg audio e recorder attuali con **una sola pipeline** che supporti clip on-demand, recording con retention (motion, detection, ecc.) e spostare tutta la logica eventi/recording in un nuovo mixin **Advanced Notifier Recorder**.
+
+---
+
+## 1. Situazione attuale (da sostituire)
+
+### 1.1 Componenti separati
+
+| Componente | File | Ruolo | Input | Output |
+|------------|------|--------|-------|--------|
+| **Decoder** | `cameraMixin.ts` | Loop frame per motion/detection | `getVideoStream(decoderStream)` (solo video, no audio) | JPEG in `lastFrame` + `storeDecoderFrame()` |
+| **Audio** | `audioAnalyzerUtils.ts` | Analisi volume/classificazione | RTSP → ffmpeg `-vn -dn -sn` → PCM 16kHz mono | Eventi `audio` → `processAudioDetection` → `addMotionEvent` |
+| **Recording** | `videoRecorderUtils.ts` | Clip su trigger (recording rules) | RTSP → ffmpeg `-c:v copy|libx264` (no audio in pratica) | `.mp4` in `recordedEvents/` |
+
+Problemi:
+- **Tre consumi separati** dello stream (decoder, audio ffmpeg, recording ffmpeg) = più connessioni RTSP e più carico.
+- **Nessuna pipeline unica** video+audio: decoder senza audio, recorder senza audio reale, audio da secondo ffmpeg.
+- **Eventi e recording** sono in `cameraMixin` + `main.ts`; nessun modulo dedicato “recorder/events”.
+
+### 1.2 Dove vivono eventi e clip oggi
+
+- **Scrittura eventi:** `main.ts` → `storeEventImage()`, `addMotionEvent()` → `enqueueDbWrite` → `writeEventsAndMotionBatch()` in `db.ts` (path `storagePath/{deviceId}/events/dbs/{YYYYMMDD}.json`).
+- **Trigger recording:** `cameraMixin.processAccumulatedDetections()` → `startRecording({ triggerTime, rules, candidates })`; prolungamento da `ensureRecordingMotionCheckInterval()`.
+- **Clip:** `cameraMixin.getVideoClipsInternal()` legge da `recordedEventsPath` e da rule-generated path; `VideoRtspFfmpegRecorder` scrive in `recordedEvents/`.
+
+---
+
+## 2. Obiettivi
+
+1. **Una sola pipeline** per dispositivo camera:
+   - Un input (stream video, con o senza audio).
+   - Da lì: **frame per analysis** (motion/detection), **audio** (se presente), **segmenti di recording** (buffer/scratch + clip finali).
+2. **Clip on-demand:** generazione clip a partire da un intervallo temporale (es. “ultimi 30 s”, o “dalle 12:00:00 per 60 s”) usando la pipeline, senza avviare un secondo ffmpeg ad hoc.
+3. **Recording con retention rules:** continuare a supportare “record on motion / on detection” con regole configurabili; retention (es. “tieni 7 giorni”, “solo eventi con persona”) gestita nel nuovo mixin.
+4. **Nuovo mixin “Advanced Notifier Recorder”:** contiene tutta la logica eventi + recording + clip; il camera mixin resta “analysis + notifiche”, il plugin orchestra e espone API.
+
+---
+
+## 3. Architettura target
+
+### 3.1 Pipeline unica (per camera)
+
+```
+                    ┌─────────────────────────────────────────────────────────┐
+                    │                  UNIFIED RECORDER PIPELINE                │
+  Stream (RTSP/     │  ┌─────────────┐    ┌──────────────┐    ┌─────────────┐  │
+  getVideoStream)   │  │   Ingest    │───▶│   Circular   │───▶│   Outputs   │  │
+  ─────────────────▶│  │ (demux +   │    │   Buffer     │    │ - Analysis   │  │
+                    │  │  optional   │    │ (e.g. 60s)   │    │   frames     │  │
+                    │  │  audio)     │    │              │    │ - Audio      │  │
+                    │  └─────────────┘    └──────┬───────┘    │   chunks     │  │
+                    │         │                   │           │ - Clips      │  │
+                    │         │                   │           │   (on-demand │  │
+                    │         │                   │           │   or rule)  │  │
+                    │         │                   ▼           └─────────────┘  │
+                    │         │            ┌──────────────┐                     │
+                    │         └───────────│  Retention   │                     │
+                    │                      │  & clip      │                     │
+                    │                      │  writer      │                     │
+                    └─────────────────────┴──────────────┴─────────────────────┘
+```
+
+- **Ingest:** un processo ffmpeg (o un solo consumer Scrypted) che legge **un** stream (video + audio se disponibile): demux, decode video (e opzionale audio), scrive in un **buffer circolare** (segmenti in memoria o su disco, es. anelli da 60 s).
+- **Outputs dalla pipeline:**
+  - **Analysis:** copia frame (o callback) verso il decoder esistente / motion / detection (così il camera mixin continua a ricevere frame senza aprire un secondo stream).
+  - **Audio:** stessi chunk PCM usati per analisi (soglie, YAMNET) e, se serve, per mux nei clip.
+  - **Clips:**
+    - **On-demand:** da buffer circolare + eventuale “tail live” → un segmento [start, end] → file .mp4 (o altro) generato dalla pipeline (es. segmenti già in formato adatto, o un secondo pass ffmpeg breve).
+    - **Retention rules:** quando una regola dice “record”, la pipeline scrive da buffer + live in un file in `recordedEvents/` (o path configurato), con possibile post-processing (thumbnail, metadati).
+
+### 3.2 Nuovo mixin: Advanced Notifier Recorder
+
+- **Nome proposto:** `AdvancedNotifierRecorderMixin` (file es. `src/recorderMixin.ts`).
+- **Interfacce Scrypted da considerare:** `EventRecorder`, `VideoClips` (se già usate), più l’eventuale nuova interfaccia per “clip on-demand” (es. `getClipForTimeRange(deviceId, startTime, endTime)`).
+- **Responsabilità:**
+  - **Eventi:** ricevere “eventi” e “motion” dal camera mixin (o dalla pipeline) e scriverli nel DB (delega a `main.ts` per `enqueueDbWrite` o incorpora la logica se si sposta anche la queue nel recorder).
+  - **Recording:** gestione regole di recording (motion, detection, retention); avvio/arresto segmenti di recording tramite la **pipeline unica** (non più `VideoRtspFfmpegRecorder` separato).
+  - **Clip on-demand:** esporre API per “genera clip per [deviceId, start, end]” usando il buffer + writer della pipeline.
+  - **Retention:** pulizia clip/segmenti secondo retention rules (giorni, tipo evento, spazio disco); possibile integrazione con “rimuovi clip più vecchi di X” già presente in `main.ts`.
+
+### 3.3 Ruolo del camera mixin dopo il refactor
+
+- **Conservare:** regole detection, notifiche, occupancy, timelapse, UI settings (decoder type, stream destination, ecc.).
+- **Cambiare:**
+  - **Decoder:** non più un loop che chiama `getVideoStream()` da solo; invece **riceve frame dalla pipeline** del recorder (o legge da un’API del recorder “get next frame for analysis”). In questo modo c’è un solo consumer dello stream.
+  - **Audio:** non più `AudioRtspFfmpegStream` nel camera mixin; il recorder espone chunk audio (o callback) e il camera mixin continua a chiamare `processAudioDetection` con quei chunk.
+  - **Recording:** nessuna chiamata a `startRecording` / `VideoRtspFfmpegRecorder` dal camera mixin; il camera mixin segnala al recorder “c’è un evento/motion che matcha una recording rule” e il **recorder** avvia/ prolunga il segmento tramite la pipeline.
+- **Eventi:** il camera mixin può continuare a chiamare `plugin.storeEventImage()` e `plugin.addMotionEvent()`; l’implementazione di queste può essere spostata nel recorder mixin (e il plugin le delega al recorder), così tutta la “scrittura eventi” è in un posto.
+
+### 3.4 Plugin (main.ts)
+
+- **Composizione:** oltre a `AdvancedNotifierCameraMixin` e `AdvancedNotifierNotifierMixin`, introdurre `AdvancedNotifierRecorderMixin`.
+  - Opzione A: il **recorder è un mixin sulla stessa camera** (stesso device, tre mixin: notifier, camera, recorder). La pipeline unica è di proprietà del recorder; camera e notifier la “usano” tramite il recorder.
+  - Opzione B: il recorder è un **device separato** “Recorder” per camera (uno-a-uno). La pipeline vive nel device Recorder; la camera mixin comunica con esso via plugin.
+- **Percorsi e storage:** `getRecordedEventPath`, `getEventPaths`, `storeEventImage`, `addMotionEvent` possono restare in `main.ts` come facade che delega al recorder mixin (per device camera), così l’API pubblica del plugin non cambia.
+- **DB queue:** `dbWriteQueue` / `enqueueDbWrite` / `runDbWriteProcess` possono restare in `main.ts` o essere spostati nel recorder; il recorder in ogni caso deve poter scrivere eventi/motion nel DB.
+
+---
+
+## 4. Pipeline unica: dettaglio tecnico
+
+### 4.1 Scelta implementativa
+
+- **Opzione 1 – FFmpeg unico (demux + buffer + tee):** un processo ffmpeg che:
+  - Legge RTSP (o riceve stream da Scrypted).
+  - Demux video + audio.
+  - Scrive in un **segment file** circolare (es. `segment_%03d.m4s` o simile) o in un **named pipe / shared memory** letto da Node.
+  - Opzionale: `tee` per inviare copia a un secondo output (es. analisi).
+  - Pro: un solo processo, meno connessioni. Contro: complessità buffer/segmenti e sincronizzazione con “clip da intervallo”.
+- **Opzione 2 – Consumer Scrypted + buffer in Node:** un solo `getVideoStream()` (con audio se il backend lo supporta); in Node un consumer che:
+  - Legge frame (e eventuale audio) e li mette in un **buffer circolare** (es. anello di segmenti in memoria o file).
+  - Espone “slice del buffer” per clip on-demand e per “scrivi da start a end” per recording.
+  - Pro: massimo controllo in JS. Contro: possibile overhead e complessità (codec, mux) se i frame arrivano già codificati.
+- **Opzione 3 – Ibrido:** ffmpeg per ingest e buffer su disco (segmenti brevi, es. 5–10 s); un servizio in Node che tiene un indice (startTime → file) e per clip on-demand concatena/rimux con ffmpeg. Recording “su regola” = copia di segmenti già scritti + append live fino a fine evento.
+
+Raccomandazione: partire da **Opzione 3** per avere un buffer su disco ben definito e clip on-demand affidabili; unificare comunque in **un solo ffmpeg di ingest** (video+audio) che produce segmenti, e un “RecorderPipeline” in Node che gestisce indice, retention e generazione clip.
+
+### 4.2 Buffer circolare / segmenti
+
+- **Formato:** segmenti brevi (es. 5–15 s) in formato adatto al concatenamento (es. fMP4 o segmenti MPEG-TS).
+- **Indice:** struttura (in memoria o file) che mappa `[startTime, endTime]` → lista file segmenti.
+- **Retention:** job periodico che rimuove segmenti oltre la retention (o oltre lo spazio massimo); i clip “recorded” (salvati in `recordedEvents/`) sono copie permanenti fino a quando non scatta la loro retention.
+
+### 4.3 Clip on-demand
+
+- **Input:** `deviceId`, `startTime`, `endTime` (timestamp Unix o ms).
+- **Logica:** dalla pipeline (indice segmenti) individuare i segmenti che coprono [startTime, endTime]; concatenare (concat demuxer ffmpeg o copy) e scrivere un file .mp4; opzionale: estrarre thumbnail a metà clip.
+- **Output:** path del file clip (e thumbnail) da esporre via API (es. `VideoClips.getVideoClip` o nuova `getClipForTimeRange`).
+
+### 4.4 Recording con retention rules
+
+- **Regole:** come oggi (motion, classi detection, ecc.) ma interpretate dal **recorder mixin**.
+- **Trigger:** il camera mixin (o la pipeline) segnala “motion on” / “detection X”; il recorder confronta con le regole e decide “start recording” / “prolong”.
+- **Scrittura:** invece di avviare un `VideoRtspFfmpegRecorder` separato, il recorder dice alla pipeline “da adesso scrivi in un file in `recordedEvents/` fino a fine evento (o max duration)”. La pipeline può:
+  - copiare dal buffer (segmenti già scritti) per la parte “pre-trigger” (es. 30 s prima),
+  - poi appendere live fino a “motion off” + post-buffer.
+- **Retention:** regole tipo “conserva 7 giorni”, “solo eventi con persona”; il recorder applica la pulizia sui file in `recordedEvents/` (e eventualmente sui segmenti del buffer).
+
+---
+
+## 5. Piano di implementazione (fasi)
+
+### Fase 1 – Fondamenta recorder e spostamento eventi
+
+1. **Creare `recorderMixin.ts`** (Advanced Notifier Recorder mixin).
+   - Interfacce: almeno ciò che serve per “eventi” e “clip” (EventRecorder / VideoClips se già usate).
+   - Implementare **delega** di `storeEventImage` e `addMotionEvent`: il plugin, quando è un device camera con recorder mixin, inoltra al recorder; il recorder chiama la stessa logica di scrittura DB (o sposta `enqueueDbWrite` nel recorder).
+2. **Registrare il mixin in `main.ts`:** per le camera, creare anche il recorder mixin (stesso device o device figlio); mantenere l’API `storeEventImage` / `addMotionEvent` sul plugin che delega al recorder.
+3. **Test:** verificare che eventi e motion continuino a essere scritti e letti come oggi (Events App, Data Fetcher).
+
+### Fase 2 – Pipeline unica (ingest + buffer)
+
+1. **Modulo “RecorderPipeline”** (es. `src/recorderPipeline.ts` o sotto `src/recorder/`):
+   - Ingest: un processo ffmpeg che legge **un** stream (RTSP o URL da `getVideoStream` se possibile) con **video + audio**, output in segmenti (fMP4 o TS).
+   - Parametri: cameraId, stream URL, path directory segmenti, lunghezza segmento, lunghezza buffer (es. 60 s = 12 segmenti da 5 s).
+   - Scrittura segmenti e indice (startTime/endTime per segmento).
+2. **Integrazione nel recorder mixin:** all’avvio della camera (o on-demand quando serve recording/clip), avviare la pipeline per quella camera; fermarla quando la camera viene rilasciata.
+3. **Sostituire l’audio analyzer:** invece di avviare `AudioRtspFfmpegStream`, il recorder legge l’audio dalla pipeline (dai segmenti o da un output ffmpeg dedicato “solo audio” tee). Fornire i chunk al camera mixin per `processAudioDetection` (stessa API).
+4. **Sostituire il decoder:** il decoder non chiama più `getVideoStream()` direttamente; la pipeline espone “frame per analysis” (es. estrazione frame dai segmenti con ffmpeg, o tee video verso un output che il camera mixin consuma). Il camera mixin continua a fare motion/detection sui frame così forniti.
+
+### Fase 3 – Recording e clip dalla pipeline
+
+1. **Recording:** rimuovere `VideoRtspFfmpegRecorder` e `startRecording` dal camera mixin. Nel recorder:
+   - Alla notifica “start recording” (da camera mixin o da regole interne), chiedere alla pipeline di “salvare da buffer[start] a live fino a stop”.
+   - Implementare “prolong on motion” leggendo lo stato motion dalla pipeline/camera mixin.
+2. **Clip on-demand:** implementare `getClipForTimeRange(deviceId, startTime, endTime)` (o equivalente) usando l’indice segmenti; concatenare e scrivere .mp4; restituire path o URL.
+3. **Retention:** job nel recorder che applica retention rules su `recordedEvents/` e sui segmenti del buffer; integrare con la logica di rimozione clip già presente in `main.ts` (es. spostarla nel recorder).
+
+### Fase 4 – Pulizia e opzionali
+
+1. **Rimuovere** da `cameraMixin.ts`: `startRecording`, `stopRecording`, `ensureRecordingMotionCheckInterval`, uso di `VideoRtspFfmpegRecorder`, `AudioRtspFfmpegStream` (sostituito dalla pipeline), e il loop decoder “standalone” (sostituito da frame dalla pipeline).
+2. **Deprecare** (o rimuovere) `videoRecorderUtils.ts` e `audioAnalyzerUtils.ts` nella forma attuale; eventualmente tenere helper riutilizzabili (es. estrazione thumbnail) dentro il modulo pipeline/recorder.
+3. **Documentazione:** aggiornare README e doc per “single pipeline”, “recorder mixin”, “retention rules”.
+4. **Settings:** spostare le impostazioni “recording rules”, “retention”, “buffer length”, “decoder source” (pipeline vs legacy, se si mantiene fallback) nel recorder mixin o in una sezione “Recording” condivisa.
+
+---
+
+## 6. Riepilogo file toccati / nuovi
+
+| Azione | File |
+|--------|------|
+| **Nuovo** | `src/recorderMixin.ts` – Advanced Notifier Recorder mixin (eventi, recording, clip, retention). |
+| **Nuovo** | `src/recorderPipeline.ts` (o `src/recorder/`) – Ingest ffmpeg, buffer segmenti, indice, export clip. |
+| **Modifica** | `src/main.ts` – Registrazione recorder mixin, delega `storeEventImage`/`addMotionEvent` al recorder, eventuale spostamento DB queue. |
+| **Modifica** | `src/cameraMixin.ts` – Rimuovere decoder standalone, audio analyzer, startRecording/VideoRtspFfmpegRecorder; ricevere frame e audio dalla pipeline/recorder; mantenere detection, notifiche, regole. |
+| **Modifica** | `src/db.ts` – Solo se la scrittura eventi viene spostata nel recorder (stesso schema, diverso chiamante). |
+| **Deprecare/rimuovere** | `src/videoRecorderUtils.ts` – Sostituito dalla pipeline. |
+| **Deprecare/rimuovere** | `src/audioAnalyzerUtils.ts` – Sostituito da audio dalla pipeline. |
+
+---
+
+## 7. Rischi e mitigazioni
+
+- **Compatibilità:** mantenere l’API pubblica del plugin (EventRecorder, VideoClips, getVideoClips, getRecordedEventPath, storeEventImage, addMotionEvent) così che camstack e altri client non cambino.
+- **Performance:** un solo ffmpeg per camera può essere un single point of failure; prevedere restart automatico e backoff come in `VideoRtspFfmpegRecorder`/`AudioRtspFfmpegStream`.
+- **Disco:** il buffer circolare su disco consuma spazio; configurare lunghezza massima e retention chiara.
+- **Migrazione:** per rollout graduale, si può mantenere un “legacy mode” (decoder + audio ffmpeg + VideoRtspFfmpegRecorder) disattivabile da setting “Use unified recorder pipeline”, e abilitare la nuova pipeline solo quando il setting è on.
+
+---
+
+Questo piano può essere usato come base per issue, task e PR incrementali (una fase per volta).

package/fs-camstack/_expo/static/css/styles-c5d89ce0dbf15ca8fde5bf5e6193a6f9.css

@@ -0,0 +1 @@
+.react-resizable{position:relative}.react-resizable-handle{box-sizing:border-box;background-image:url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2IDYiIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiNmZmZmZmYwMCIgeD0iMHB4IiB5PSIwcHgiIHdpZHRoPSI2cHgiIGhlaWdodD0iNnB4Ij48ZyBvcGFjaXR5PSIwLjMwMiI+PHBhdGggZD0iTSA2IDYgTCAwIDYgTCAwIDQuMiBMIDQgNC4yIEwgNC4yIDQuMiBMIDQuMiAwIEwgNiAwIEwgNiA2IEwgNiA2IFoiIGZpbGw9IiMwMDAwMDAiLz48L2c+PC9zdmc+");background-position:100% 100%;background-repeat:no-repeat;background-origin:content-box;width:20px;height:20px;padding:0 3px 3px 0;position:absolute}.react-resizable-handle-sw{cursor:sw-resize;bottom:0;left:0;transform:rotate(90deg)}.react-resizable-handle-se{cursor:se-resize;bottom:0;right:0}.react-resizable-handle-nw{cursor:nw-resize;top:0;left:0;transform:rotate(180deg)}.react-resizable-handle-ne{cursor:ne-resize;top:0;right:0;transform:rotate(270deg)}.react-resizable-handle-w,.react-resizable-handle-e{cursor:ew-resize;margin-top:-10px;top:50%}.react-resizable-handle-w{left:0;transform:rotate(135deg)}.react-resizable-handle-e{right:0;transform:rotate(315deg)}.react-resizable-handle-n,.react-resizable-handle-s{cursor:ns-resize;margin-left:-10px;left:50%}.react-resizable-handle-n{top:0;transform:rotate(225deg)}.react-resizable-handle-s{bottom:0;transform:rotate(45deg)}

package/fs-camstack/_expo/static/css/styles-d46d3dc27ce9bd30adff69475412fa30.css

@@ -0,0 +1 @@
+.react-grid-layout{transition:height .2s;position:relative}.react-grid-item{transition:left .2s,top .2s,width .2s,height .2s}.react-grid-item img{pointer-events:none;-webkit-user-select:none;user-select:none}.react-grid-item.cssTransforms{transition-property:transform,width,height}.react-grid-item.resizing{z-index:1;will-change:width, height;transition:none}.react-grid-item.react-draggable-dragging{z-index:3;will-change:transform;transition:none}.react-grid-item.dropping{visibility:hidden}.react-grid-item.react-grid-placeholder{opacity:.2;z-index:2;-webkit-user-select:none;user-select:none;background:red;transition-duration:.1s}.react-grid-item.react-grid-placeholder.placeholder-resizing{transition:none}.react-grid-item>.react-resizable-handle{opacity:0;width:20px;height:20px;position:absolute}.react-grid-item:hover>.react-resizable-handle{opacity:1}.react-grid-item>.react-resizable-handle:after{content:"";border-bottom:2px solid #0006;border-right:2px solid #0006;width:5px;height:5px;position:absolute;bottom:3px;right:3px}.react-resizable-hide>.react-resizable-handle{display:none}.react-grid-item>.react-resizable-handle.react-resizable-handle-sw{cursor:sw-resize;bottom:0;left:0;transform:rotate(90deg)}.react-grid-item>.react-resizable-handle.react-resizable-handle-se{cursor:se-resize;bottom:0;right:0}.react-grid-item>.react-resizable-handle.react-resizable-handle-nw{cursor:nw-resize;top:0;left:0;transform:rotate(180deg)}.react-grid-item>.react-resizable-handle.react-resizable-handle-ne{cursor:ne-resize;top:0;right:0;transform:rotate(270deg)}.react-grid-item>.react-resizable-handle.react-resizable-handle-w,.react-grid-item>.react-resizable-handle.react-resizable-handle-e{cursor:ew-resize;margin-top:-10px;top:50%}.react-grid-item>.react-resizable-handle.react-resizable-handle-w{left:0;transform:rotate(135deg)}.react-grid-item>.react-resizable-handle.react-resizable-handle-e{right:0;transform:rotate(315deg)}.react-grid-item>.react-resizable-handle.react-resizable-handle-n,.react-grid-item>.react-resizable-handle.react-resizable-handle-s{cursor:ns-resize;margin-left:-10px;left:50%}.react-grid-item>.react-resizable-handle.react-resizable-handle-n{top:0;transform:rotate(225deg)}.react-grid-item>.react-resizable-handle.react-resizable-handle-s{bottom:0;transform:rotate(45deg)}