@blueharford/scrypted-spatial-awareness 0.1.0

package/src/devices/tracking-zone.ts

@@ -0,0 +1,245 @@
+/**
+ * Tracking Zone Device
+ * Virtual sensor for monitoring specific areas across cameras
+ */
+
+import {
+  MotionSensor,
+  OccupancySensor,
+  ScryptedDeviceBase,
+  Settings,
+  Setting,
+  SettingValue,
+  ScryptedNativeId,
+  ScryptedInterface,
+} from '@scrypted/sdk';
+import { StorageSettings } from '@scrypted/sdk/storage-settings';
+import { TrackingState } from '../state/tracking-state';
+import { TrackedObject } from '../models/tracked-object';
+import { GlobalZoneType } from '../models/topology';
+
+export interface TrackingZoneConfig {
+  type: GlobalZoneType;
+  cameras: string[];
+  dwellThreshold?: number;
+}
+
+export class TrackingZone extends ScryptedDeviceBase
+  implements MotionSensor, OccupancySensor, Settings {
+
+  private trackingState: TrackingState;
+  private plugin: any;
+  private config: TrackingZoneConfig = {
+    type: 'entry',
+    cameras: [],
+  };
+
+  storageSettings = new StorageSettings(this, {
+    zoneType: {
+      title: 'Zone Type',
+      type: 'string',
+      choices: ['entry', 'exit', 'dwell', 'restricted'],
+      defaultValue: 'entry',
+      description: 'Type of zone for alerting purposes',
+    },
+    cameras: {
+      title: 'Cameras',
+      type: 'device',
+      multiple: true,
+      deviceFilter: `interfaces.includes('${ScryptedInterface.ObjectDetector}')`,
+      description: 'Cameras that make up this zone',
+    },
+    dwellThreshold: {
+      title: 'Dwell Time Threshold (seconds)',
+      type: 'number',
+      defaultValue: 60,
+      description: 'For dwell zones: alert if object stays longer than this',
+    },
+    trackClasses: {
+      title: 'Track Object Types',
+      type: 'string',
+      multiple: true,
+      choices: ['person', 'car', 'vehicle', 'animal', 'package'],
+      description: 'Object types to monitor in this zone (empty = all)',
+    },
+  });
+
+  constructor(
+    plugin: any,
+    nativeId: ScryptedNativeId,
+    trackingState: TrackingState
+  ) {
+    super(nativeId);
+    this.plugin = plugin;
+    this.trackingState = trackingState;
+
+    // Load config
+    this.loadConfig();
+
+    // Listen for state changes
+    trackingState.onStateChange(() => this.evaluateZone());
+
+    // Initial evaluation
+    this.evaluateZone();
+  }
+
+  /**
+   * Load configuration from storage
+   */
+  private loadConfig(): void {
+    try {
+      const configJson = this.storage.getItem('zoneConfig');
+      if (configJson) {
+        this.config = JSON.parse(configJson);
+      }
+    } catch (e) {
+      this.console.error('Failed to load zone config:', e);
+    }
+  }
+
+  /**
+   * Save configuration to storage
+   */
+  private saveConfig(): void {
+    try {
+      this.storage.setItem('zoneConfig', JSON.stringify(this.config));
+    } catch (e) {
+      this.console.error('Failed to save zone config:', e);
+    }
+  }
+
+  /**
+   * Configure the zone programmatically
+   */
+  configure(config: Partial<TrackingZoneConfig>): void {
+    this.config = { ...this.config, ...config };
+    this.saveConfig();
+    this.evaluateZone();
+  }
+
+  /**
+   * Evaluate the zone state based on current tracking data
+   */
+  private evaluateZone(): void {
+    const cameras = this.getCameraIds();
+    if (cameras.length === 0) {
+      this.occupied = false;
+      this.motionDetected = false;
+      return;
+    }
+
+    const trackClasses = this.storageSettings.values.trackClasses as string[] || [];
+    let hasObject = false;
+    let hasMovement = false;
+    const now = Date.now();
+
+    for (const cameraId of cameras) {
+      const objects = this.trackingState.getObjectsOnCamera(cameraId);
+
+      for (const obj of objects) {
+        // Filter by class if specified
+        if (trackClasses.length > 0 && !trackClasses.includes(obj.className)) {
+          continue;
+        }
+
+        hasObject = true;
+
+        // Check for recent movement
+        const recentSightings = obj.sightings.filter(
+          s => s.cameraId === cameraId && now - s.timestamp < 5000
+        );
+
+        if (recentSightings.some(s => s.detection.movement?.moving)) {
+          hasMovement = true;
+        }
+      }
+    }
+
+    this.occupied = hasObject;
+    this.motionDetected = hasMovement;
+  }
+
+  /**
+   * Get camera IDs from settings
+   */
+  private getCameraIds(): string[] {
+    const cameras = this.storageSettings.values.cameras;
+    if (Array.isArray(cameras)) {
+      return cameras as string[];
+    }
+    if (cameras) {
+      return [cameras as string];
+    }
+    return this.config.cameras || [];
+  }
+
+  /**
+   * Get objects currently in this zone
+   */
+  getObjectsInZone(): TrackedObject[] {
+    const cameras = this.getCameraIds();
+    const trackClasses = this.storageSettings.values.trackClasses as string[] || [];
+    const objects: TrackedObject[] = [];
+    const seen = new Set<string>();
+
+    for (const cameraId of cameras) {
+      for (const obj of this.trackingState.getObjectsOnCamera(cameraId)) {
+        if (seen.has(obj.globalId)) continue;
+        seen.add(obj.globalId);
+
+        if (trackClasses.length === 0 || trackClasses.includes(obj.className)) {
+          objects.push(obj);
+        }
+      }
+    }
+
+    return objects;
+  }
+
+  // ==================== Settings Implementation ====================
+
+  async getSettings(): Promise<Setting[]> {
+    const settings = await this.storageSettings.getSettings();
+
+    // Add current status
+    const objectsInZone = this.getObjectsInZone();
+
+    settings.push({
+      key: 'currentStatus',
+      title: 'Current Status',
+      type: 'string',
+      readonly: true,
+      value: this.occupied
+        ? `Occupied: ${objectsInZone.length} object${objectsInZone.length !== 1 ? 's' : ''}`
+        : 'Empty',
+      group: 'Status',
+    });
+
+    if (objectsInZone.length > 0) {
+      settings.push({
+        key: 'objectsList',
+        title: 'Objects in Zone',
+        type: 'string',
+        readonly: true,
+        value: objectsInZone
+          .map(o => `${o.className}${o.label ? ` (${o.label})` : ''}`)
+          .join(', '),
+        group: 'Status',
+      });
+    }
+
+    return settings;
+  }
+
+  async putSetting(key: string, value: SettingValue): Promise<void> {
+    await this.storageSettings.putSetting(key, value);
+
+    // Update config based on settings
+    this.config.type = this.storageSettings.values.zoneType as GlobalZoneType || 'entry';
+    this.config.cameras = this.getCameraIds();
+    this.config.dwellThreshold = (this.storageSettings.values.dwellThreshold as number || 60) * 1000;
+
+    this.saveConfig();
+    this.evaluateZone();
+  }
+}

package/src/integrations/mqtt-publisher.ts

@@ -0,0 +1,320 @@
+/**
+ * MQTT Publisher
+ * Publishes tracking state and alerts to MQTT for Home Assistant integration
+ */
+
+import mqtt, { MqttClient, IClientOptions } from 'mqtt';
+import { TrackedObject } from '../models/tracked-object';
+import { Alert } from '../models/alert';
+
+export interface MqttConfig {
+  broker: string;
+  username?: string;
+  password?: string;
+  baseTopic: string;
+}
+
+export class MqttPublisher {
+  private client: MqttClient | null = null;
+  private config: MqttConfig;
+  private console: Console;
+  private connected: boolean = false;
+  private reconnectTimer: NodeJS.Timeout | null = null;
+
+  constructor(config: MqttConfig, console: Console) {
+    this.config = config;
+    this.console = console;
+  }
+
+  /**
+   * Connect to MQTT broker
+   */
+  async connect(): Promise<void> {
+    if (this.client) {
+      return;
+    }
+
+    const options: IClientOptions = {
+      clientId: `scrypted-spatial-awareness-${Date.now()}`,
+      clean: true,
+      connectTimeout: 10000,
+      reconnectPeriod: 5000,
+    };
+
+    if (this.config.username) {
+      options.username = this.config.username;
+      options.password = this.config.password;
+    }
+
+    try {
+      this.client = mqtt.connect(this.config.broker, options);
+
+      this.client.on('connect', () => {
+        this.connected = true;
+        this.console.log(`MQTT connected to ${this.config.broker}`);
+        this.publishDiscovery();
+      });
+
+      this.client.on('error', (error) => {
+        this.console.error('MQTT error:', error);
+      });
+
+      this.client.on('close', () => {
+        this.connected = false;
+        this.console.log('MQTT connection closed');
+      });
+
+      this.client.on('offline', () => {
+        this.connected = false;
+        this.console.log('MQTT offline');
+      });
+    } catch (e) {
+      this.console.error('Failed to connect to MQTT:', e);
+    }
+  }
+
+  /**
+   * Disconnect from MQTT broker
+   */
+  disconnect(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+
+    if (this.client) {
+      this.client.end();
+      this.client = null;
+      this.connected = false;
+    }
+  }
+
+  /**
+   * Publish Home Assistant MQTT discovery messages
+   */
+  private publishDiscovery(): void {
+    if (!this.client || !this.connected) return;
+
+    const baseTopic = this.config.baseTopic;
+
+    // Occupancy sensor for property
+    const occupancyConfig = {
+      name: 'Property Occupancy',
+      unique_id: 'spatial_awareness_occupancy',
+      state_topic: `${baseTopic}/occupancy/state`,
+      device_class: 'occupancy',
+      payload_on: 'ON',
+      payload_off: 'OFF',
+      device: {
+        identifiers: ['spatial_awareness'],
+        name: 'Spatial Awareness',
+        model: 'Cross-Camera Tracker',
+        manufacturer: 'Scrypted',
+      },
+    };
+
+    this.client.publish(
+      `homeassistant/binary_sensor/spatial_awareness_occupancy/config`,
+      JSON.stringify(occupancyConfig),
+      { retain: true }
+    );
+
+    // Active count sensor
+    const countConfig = {
+      name: 'Active Tracked Objects',
+      unique_id: 'spatial_awareness_count',
+      state_topic: `${baseTopic}/count/state`,
+      icon: 'mdi:account-multiple',
+      device: {
+        identifiers: ['spatial_awareness'],
+      },
+    };
+
+    this.client.publish(
+      `homeassistant/sensor/spatial_awareness_count/config`,
+      JSON.stringify(countConfig),
+      { retain: true }
+    );
+
+    // Person count sensor
+    const personCountConfig = {
+      name: 'People on Property',
+      unique_id: 'spatial_awareness_person_count',
+      state_topic: `${baseTopic}/person_count/state`,
+      icon: 'mdi:account-group',
+      device: {
+        identifiers: ['spatial_awareness'],
+      },
+    };
+
+    this.client.publish(
+      `homeassistant/sensor/spatial_awareness_person_count/config`,
+      JSON.stringify(personCountConfig),
+      { retain: true }
+    );
+
+    // Vehicle count sensor
+    const vehicleCountConfig = {
+      name: 'Vehicles on Property',
+      unique_id: 'spatial_awareness_vehicle_count',
+      state_topic: `${baseTopic}/vehicle_count/state`,
+      icon: 'mdi:car',
+      device: {
+        identifiers: ['spatial_awareness'],
+      },
+    };
+
+    this.client.publish(
+      `homeassistant/sensor/spatial_awareness_vehicle_count/config`,
+      JSON.stringify(vehicleCountConfig),
+      { retain: true }
+    );
+
+    this.console.log('MQTT discovery published');
+  }
+
+  /**
+   * Publish current tracking state
+   */
+  publishState(objects: TrackedObject[]): void {
+    if (!this.client || !this.connected) return;
+
+    const baseTopic = this.config.baseTopic;
+    const activeObjects = objects.filter(o => o.state === 'active' || o.state === 'pending');
+
+    // Occupancy
+    const occupied = activeObjects.length > 0;
+    this.client.publish(`${baseTopic}/occupancy/state`, occupied ? 'ON' : 'OFF', { retain: true });
+
+    // Counts
+    this.client.publish(`${baseTopic}/count/state`, String(activeObjects.length), { retain: true });
+
+    const personCount = activeObjects.filter(o => o.className === 'person').length;
+    this.client.publish(`${baseTopic}/person_count/state`, String(personCount), { retain: true });
+
+    const vehicleCount = activeObjects.filter(o =>
+      ['car', 'vehicle', 'truck'].includes(o.className)
+    ).length;
+    this.client.publish(`${baseTopic}/vehicle_count/state`, String(vehicleCount), { retain: true });
+
+    // Full state JSON
+    const statePayload = {
+      timestamp: Date.now(),
+      occupied,
+      activeCount: activeObjects.length,
+      personCount,
+      vehicleCount,
+      objects: activeObjects.map(o => ({
+        id: o.globalId,
+        class: o.className,
+        label: o.label,
+        cameras: o.activeOnCameras,
+        firstSeen: o.firstSeen,
+        lastSeen: o.lastSeen,
+        state: o.state,
+      })),
+    };
+
+    this.client.publish(`${baseTopic}/state`, JSON.stringify(statePayload), { retain: true });
+  }
+
+  /**
+   * Publish an alert
+   */
+  publishAlert(alert: Alert): void {
+    if (!this.client || !this.connected) return;
+
+    const baseTopic = this.config.baseTopic;
+
+    const alertPayload = {
+      id: alert.id,
+      type: alert.type,
+      severity: alert.severity,
+      message: alert.message,
+      timestamp: alert.timestamp,
+      objectId: alert.trackedObjectId,
+      details: alert.details,
+    };
+
+    // Publish to alerts topic
+    this.client.publish(`${baseTopic}/alerts`, JSON.stringify(alertPayload));
+
+    // Also publish to type-specific topic
+    this.client.publish(`${baseTopic}/alerts/${alert.type}`, JSON.stringify(alertPayload));
+  }
+
+  /**
+   * Publish object entry event
+   */
+  publishEntry(object: TrackedObject, cameraName: string): void {
+    if (!this.client || !this.connected) return;
+
+    const baseTopic = this.config.baseTopic;
+
+    const payload = {
+      event: 'entry',
+      timestamp: Date.now(),
+      object: {
+        id: object.globalId,
+        class: object.className,
+        label: object.label,
+      },
+      camera: cameraName,
+    };
+
+    this.client.publish(`${baseTopic}/events/entry`, JSON.stringify(payload));
+  }
+
+  /**
+   * Publish object exit event
+   */
+  publishExit(object: TrackedObject, cameraName: string): void {
+    if (!this.client || !this.connected) return;
+
+    const baseTopic = this.config.baseTopic;
+
+    const payload = {
+      event: 'exit',
+      timestamp: Date.now(),
+      object: {
+        id: object.globalId,
+        class: object.className,
+        label: object.label,
+        dwellTime: object.lastSeen - object.firstSeen,
+      },
+      camera: cameraName,
+    };
+
+    this.client.publish(`${baseTopic}/events/exit`, JSON.stringify(payload));
+  }
+
+  /**
+   * Publish camera transition event
+   */
+  publishTransition(object: TrackedObject, fromCamera: string, toCamera: string): void {
+    if (!this.client || !this.connected) return;
+
+    const baseTopic = this.config.baseTopic;
+
+    const payload = {
+      event: 'transition',
+      timestamp: Date.now(),
+      object: {
+        id: object.globalId,
+        class: object.className,
+        label: object.label,
+      },
+      from: fromCamera,
+      to: toCamera,
+    };
+
+    this.client.publish(`${baseTopic}/events/transition`, JSON.stringify(payload));
+  }
+
+  /**
+   * Check if connected
+   */
+  isConnected(): boolean {
+    return this.connected;
+  }
+}