pumaguard 21.post29__py3-none-any.whl → 21.post83__py3-none-any.whl

pumaguard-ui/lib/services/camera_events_service.dart

@@ -0,0 +1,195 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart' as http;
+import '../models/camera.dart';
+
+/// Event types for camera status changes
+enum CameraEventType {
+  connected,
+  cameraConnected,
+  cameraDisconnected,
+  cameraAdded,
+  cameraStatusChangedOnline,
+  cameraStatusChangedOffline,
+  unknown,
+}
+
+/// Camera event data
+class CameraEvent {
+  final CameraEventType type;
+  final Camera? camera;
+  final String timestamp;
+
+  CameraEvent({required this.type, required this.timestamp, this.camera});
+
+  factory CameraEvent.fromJson(Map<String, dynamic> json) {
+    final typeStr = json['type'] as String? ?? 'unknown';
+    final type = _parseEventType(typeStr);
+
+    Camera? camera;
+    if (json['data'] != null && json['data'] is Map<String, dynamic>) {
+      try {
+        camera = Camera.fromJson(json['data'] as Map<String, dynamic>);
+      } catch (e) {
+        debugPrint('[CameraEvent] Error parsing camera data: $e');
+      }
+    }
+
+    return CameraEvent(
+      type: type,
+      timestamp: json['timestamp'] as String? ?? '',
+      camera: camera,
+    );
+  }
+
+  static CameraEventType _parseEventType(String typeStr) {
+    switch (typeStr) {
+      case 'connected':
+        return CameraEventType.connected;
+      case 'camera_connected':
+        return CameraEventType.cameraConnected;
+      case 'camera_disconnected':
+        return CameraEventType.cameraDisconnected;
+      case 'camera_added':
+        return CameraEventType.cameraAdded;
+      case 'camera_status_changed_online':
+        return CameraEventType.cameraStatusChangedOnline;
+      case 'camera_status_changed_offline':
+        return CameraEventType.cameraStatusChangedOffline;
+      default:
+        return CameraEventType.unknown;
+    }
+  }
+}
+
+/// Service for receiving real-time camera status updates via Server-Sent Events
+class CameraEventsService {
+  final String baseUrl;
+  final _eventController = StreamController<CameraEvent>.broadcast();
+  http.Client? _client;
+  bool _isListening = false;
+
+  CameraEventsService(this.baseUrl);
+
+  /// Stream of camera events
+  Stream<CameraEvent> get events => _eventController.stream;
+
+  /// Whether the service is currently listening for events
+  bool get isListening => _isListening;
+
+  /// Start listening for camera events
+  Future<void> startListening() async {
+    if (_isListening) {
+      debugPrint('[CameraEventsService] Already listening');
+      return;
+    }
+
+    _isListening = true;
+    _client = http.Client();
+
+    try {
+      final url = Uri.parse('$baseUrl/api/dhcp/cameras/events');
+      debugPrint('[CameraEventsService] Connecting to SSE: $url');
+
+      final request = http.Request('GET', url);
+      request.headers['Accept'] = 'text/event-stream';
+      request.headers['Cache-Control'] = 'no-cache';
+
+      final response = await _client!.send(request);
+
+      if (response.statusCode != 200) {
+        debugPrint(
+          '[CameraEventsService] Failed to connect: ${response.statusCode}',
+        );
+        _isListening = false;
+        return;
+      }
+
+      debugPrint('[CameraEventsService] Connected successfully');
+
+      // Listen to the stream
+      response.stream
+          .transform(utf8.decoder)
+          .transform(const LineSplitter())
+          .listen(
+            _handleLine,
+            onError: (error) {
+              debugPrint('[CameraEventsService] Stream error: $error');
+              _handleDisconnect();
+            },
+            onDone: () {
+              debugPrint('[CameraEventsService] Stream closed');
+              _handleDisconnect();
+            },
+            cancelOnError: false,
+          );
+    } catch (e) {
+      debugPrint('[CameraEventsService] Connection error: $e');
+      _isListening = false;
+      _client?.close();
+      _client = null;
+    }
+  }
+
+  /// Stop listening for camera events
+  void stopListening() {
+    if (!_isListening) {
+      return;
+    }
+
+    debugPrint('[CameraEventsService] Stopping event listener');
+    _isListening = false;
+    _client?.close();
+    _client = null;
+  }
+
+  /// Handle incoming SSE line
+  void _handleLine(String line) {
+    if (line.isEmpty || line.startsWith(':')) {
+      // Skip empty lines and comments (keepalive)
+      return;
+    }
+
+    if (line.startsWith('data: ')) {
+      final data = line.substring(6); // Remove 'data: ' prefix
+      try {
+        final json = jsonDecode(data) as Map<String, dynamic>;
+        final event = CameraEvent.fromJson(json);
+
+        debugPrint(
+          '[CameraEventsService] Received event: ${event.type} - ${event.camera?.hostname ?? "N/A"}',
+        );
+
+        _eventController.add(event);
+      } catch (e) {
+        debugPrint('[CameraEventsService] Error parsing event: $e');
+      }
+    }
+  }
+
+  /// Handle disconnection
+  void _handleDisconnect() {
+    if (!_isListening) {
+      return;
+    }
+
+    _isListening = false;
+    _client?.close();
+    _client = null;
+
+    // Attempt to reconnect after a delay
+    debugPrint('[CameraEventsService] Attempting to reconnect in 5 seconds');
+    Future.delayed(const Duration(seconds: 5), () {
+      if (!_isListening) {
+        startListening();
+      }
+    });
+  }
+
+  /// Dispose of resources
+  void dispose() {
+    stopListening();
+    _eventController.close();
+  }
+}

pumaguard-ui/lib/services/mdns_service.dart

@@ -0,0 +1,4 @@
+// Conditional export for mDNS service based on platform
+// Uses native implementation on mobile/desktop, stub on web
+
+export 'mdns_service_web.dart' if (dart.library.io) 'mdns_service_io.dart';

pumaguard-ui/lib/services/mdns_service_impl.dart

@@ -0,0 +1,282 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:flutter/foundation.dart';
+import 'package:multicast_dns/multicast_dns.dart';
+
+/// Represents a discovered Pumaguard server via mDNS
+class PumaguardServer {
+  final String name;
+  final String hostname;
+  final String ip;
+  final int port;
+  final Map<String, String> properties;
+
+  PumaguardServer({
+    required this.name,
+    required this.hostname,
+    required this.ip,
+    required this.port,
+    required this.properties,
+  });
+
+  /// Get the base URL for this server
+  String get baseUrl => 'http://$ip:$port';
+
+  /// Get the mDNS URL (hostname.local)
+  String get mdnsUrl => 'http://$hostname:$port';
+
+  @override
+  String toString() {
+    return 'PumaguardServer(name: $name, ip: $ip, port: $port, hostname: $hostname)';
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is PumaguardServer &&
+        other.name == name &&
+        other.ip == ip &&
+        other.port == port;
+  }
+
+  @override
+  int get hashCode => Object.hash(name, ip, port);
+}
+
+/// Service for discovering Pumaguard servers via mDNS/Zeroconf
+class MdnsService {
+  static const String serviceType = '_http._tcp';
+  static const Duration discoveryTimeout = Duration(seconds: 5);
+  static const Duration discoveryInterval = Duration(seconds: 30);
+
+  final List<PumaguardServer> _discoveredServers = [];
+  final StreamController<List<PumaguardServer>> _serversController =
+      StreamController<List<PumaguardServer>>.broadcast();
+
+  MDnsClient? _mdns;
+  Timer? _discoveryTimer;
+  bool _isDiscovering = false;
+
+  /// Stream of discovered servers
+  Stream<List<PumaguardServer>> get serversStream => _serversController.stream;
+
+  /// List of currently discovered servers
+  List<PumaguardServer> get servers => List.unmodifiable(_discoveredServers);
+
+  /// Start continuous discovery of Pumaguard servers
+  Future<void> startDiscovery() async {
+    if (_isDiscovering) {
+      return;
+    }
+
+    _isDiscovering = true;
+
+    // Do initial discovery
+    await discoverServers();
+
+    // Set up periodic discovery
+    _discoveryTimer = Timer.periodic(discoveryInterval, (timer) async {
+      await discoverServers();
+    });
+  }
+
+  /// Stop continuous discovery
+  void stopDiscovery() {
+    _discoveryTimer?.cancel();
+    _discoveryTimer = null;
+    _isDiscovering = false;
+  }
+
+  /// Discover Pumaguard servers on the network
+  Future<List<PumaguardServer>> discoverServers() async {
+    try {
+      // Create mDNS client if needed
+      if (_mdns == null) {
+        _mdns = MDnsClient(
+          rawDatagramSocketFactory:
+              (
+                dynamic host,
+                int port, {
+                bool? reuseAddress,
+                bool? reusePort,
+                int? ttl,
+              }) async {
+                return RawDatagramSocket.bind(
+                  host,
+                  port,
+                  reuseAddress: reuseAddress ?? true,
+                  reusePort: reusePort ?? false,
+                  ttl: ttl ?? 255,
+                );
+              },
+        );
+        await _mdns!.start();
+      }
+
+      final Set<PumaguardServer> foundServers = {};
+
+      // Query for HTTP services
+      await for (final PtrResourceRecord ptr
+          in _mdns!
+              .lookup<PtrResourceRecord>(
+                ResourceRecordQuery.serverPointer(serviceType),
+              )
+              .timeout(discoveryTimeout)) {
+        // Get service details
+        final String serviceName = ptr.domainName;
+
+        // Query for service details (SRV and TXT records)
+        final srvFuture = _mdns!
+            .lookup<SrvResourceRecord>(ResourceRecordQuery.service(serviceName))
+            .timeout(discoveryTimeout)
+            .toList();
+
+        final txtFuture = _mdns!
+            .lookup<TxtResourceRecord>(ResourceRecordQuery.text(serviceName))
+            .timeout(discoveryTimeout)
+            .toList();
+
+        final ipFuture = _mdns!
+            .lookup<IPAddressResourceRecord>(
+              ResourceRecordQuery.addressIPv4(serviceName),
+            )
+            .timeout(discoveryTimeout)
+            .toList();
+
+        final results = await Future.wait([srvFuture, txtFuture, ipFuture]);
+        final srvRecords = results[0] as List<SrvResourceRecord>;
+        final txtRecords = results[1] as List<TxtResourceRecord>;
+        final ipRecords = results[2] as List<IPAddressResourceRecord>;
+
+        // Process SRV records to get port and hostname
+        for (final srv in srvRecords) {
+          final int port = srv.port;
+          final String target = srv.target;
+
+          // Parse TXT records for properties
+          final Map<String, String> properties = {};
+          for (final txt in txtRecords) {
+            for (final String data in txt.text.split('\n')) {
+              final parts = data.split('=');
+              if (parts.length == 2) {
+                properties[parts[0]] = parts[1];
+              }
+            }
+          }
+
+          // Check if this is a Pumaguard server
+          final ispumaguard =
+              properties['app'] == 'pumaguard' ||
+              serviceName.toLowerCase().contains('pumaguard');
+
+          if (!ispumaguard) {
+            continue;
+          }
+
+          // Get IP addresses
+          for (final ip in ipRecords) {
+            final server = PumaguardServer(
+              name: serviceName.split('.').first,
+              hostname: target.replaceAll(RegExp(r'\.$'), ''),
+              ip: ip.address.address,
+              port: port,
+              properties: properties,
+            );
+
+            foundServers.add(server);
+          }
+        }
+      }
+
+      // Update discovered servers list
+      _discoveredServers.clear();
+      _discoveredServers.addAll(foundServers);
+
+      // Notify listeners
+      if (!_serversController.isClosed) {
+        _serversController.add(_discoveredServers);
+      }
+
+      return _discoveredServers;
+    } catch (e) {
+      // Discovery failed, return empty list
+      debugPrint('mDNS discovery error: $e');
+      return [];
+    }
+  }
+
+  /// Find a specific server by name
+  Future<PumaguardServer?> findServerByName(String name) async {
+    // First check already discovered servers
+    for (final server in _discoveredServers) {
+      if (server.name.toLowerCase() == name.toLowerCase()) {
+        return server;
+      }
+    }
+
+    // Do a fresh discovery
+    final servers = await discoverServers();
+    for (final server in servers) {
+      if (server.name.toLowerCase() == name.toLowerCase()) {
+        return server;
+      }
+    }
+
+    return null;
+  }
+
+  /// Resolve a .local hostname to an IP address
+  Future<String?> resolveLocalHostname(String hostname) async {
+    try {
+      if (_mdns == null) {
+        _mdns = MDnsClient(
+          rawDatagramSocketFactory:
+              (
+                dynamic host,
+                int port, {
+                bool? reuseAddress,
+                bool? reusePort,
+                int? ttl,
+              }) async {
+                return RawDatagramSocket.bind(
+                  host,
+                  port,
+                  reuseAddress: reuseAddress ?? true,
+                  reusePort: reusePort ?? false,
+                  ttl: ttl ?? 255,
+                );
+              },
+        );
+        await _mdns!.start();
+      }
+
+      // Ensure hostname ends with .local
+      if (!hostname.endsWith('.local')) {
+        hostname = '$hostname.local';
+      }
+
+      // Query for IPv4 address
+      await for (final IPAddressResourceRecord record
+          in _mdns!
+              .lookup<IPAddressResourceRecord>(
+                ResourceRecordQuery.addressIPv4(hostname),
+              )
+              .timeout(discoveryTimeout)) {
+        return record.address.address;
+      }
+
+      return null;
+    } catch (e) {
+      debugPrint('Hostname resolution error: $e');
+      return null;
+    }
+  }
+
+  /// Clean up resources
+  void dispose() {
+    stopDiscovery();
+    _mdns?.stop();
+    _serversController.close();
+  }
+}

pumaguard-ui/lib/services/mdns_service_io.dart

@@ -0,0 +1 @@
+export 'mdns_service_impl.dart';

pumaguard-ui/lib/services/mdns_service_web.dart

@@ -0,0 +1,106 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+
+/// Represents a discovered Pumaguard server via mDNS
+class PumaguardServer {
+  final String name;
+  final String hostname;
+  final String ip;
+  final int port;
+  final Map<String, String> properties;
+
+  PumaguardServer({
+    required this.name,
+    required this.hostname,
+    required this.ip,
+    required this.port,
+    required this.properties,
+  });
+
+  /// Get the base URL for this server
+  String get baseUrl => 'http://$ip:$port';
+
+  /// Get the mDNS URL (hostname.local)
+  String get mdnsUrl => 'http://$hostname:$port';
+
+  @override
+  String toString() {
+    return 'PumaguardServer(name: $name, ip: $ip, port: $port, hostname: $hostname)';
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is PumaguardServer &&
+        other.name == name &&
+        other.ip == ip &&
+        other.port == port;
+  }
+
+  @override
+  int get hashCode => Object.hash(name, ip, port);
+}
+
+/// Web stub for mDNS service (mDNS discovery not supported in web browsers)
+///
+/// Note: mDNS/Zeroconf discovery requires native socket access which is not
+/// available in web browsers. This is a no-op implementation for web platforms.
+/// Users should use manual URL entry or rely on the dynamic URL detection.
+class MdnsService {
+  static const String serviceType = '_http._tcp';
+  static const Duration discoveryTimeout = Duration(seconds: 5);
+  static const Duration discoveryInterval = Duration(seconds: 30);
+
+  final List<PumaguardServer> _discoveredServers = [];
+  final StreamController<List<PumaguardServer>> _serversController =
+      StreamController<List<PumaguardServer>>.broadcast();
+
+  /// Stream of discovered servers (always empty on web)
+  Stream<List<PumaguardServer>> get serversStream => _serversController.stream;
+
+  /// List of currently discovered servers (always empty on web)
+  List<PumaguardServer> get servers => List.unmodifiable(_discoveredServers);
+
+  /// Start continuous discovery (no-op on web)
+  Future<void> startDiscovery() async {
+    // mDNS discovery is not supported on web platforms
+    debugPrint('mDNS discovery is not available in web browsers');
+    return;
+  }
+
+  /// Stop continuous discovery (no-op on web)
+  void stopDiscovery() {
+    // No-op on web
+  }
+
+  /// Discover servers (always returns empty list on web)
+  Future<List<PumaguardServer>> discoverServers() async {
+    // mDNS discovery requires native socket access not available in browsers
+    debugPrint('mDNS discovery is not supported on web. Use manual URL entry.');
+    return [];
+  }
+
+  /// Find a specific server by name (always returns null on web)
+  Future<PumaguardServer?> findServerByName(String name) async {
+    // Not supported on web
+    return null;
+  }
+
+  /// Resolve a .local hostname (not supported on web)
+  ///
+  /// Note: Browsers may be able to resolve .local hostnames through the OS
+  /// if mDNS is properly configured, but programmatic resolution is not available.
+  Future<String?> resolveLocalHostname(String hostname) async {
+    debugPrint('Hostname resolution is not available in web browsers');
+    debugPrint(
+      'Browsers may resolve .local hostnames through the OS automatically',
+    );
+    return null;
+  }
+
+  /// Clean up resources
+  void dispose() {
+    _serversController.close();
+  }
+}

pumaguard-ui/lib/utils/download_helper.dart

@@ -0,0 +1,2 @@
+export 'download_helper_stub.dart'
+    if (dart.library.js_interop) 'download_helper_web.dart';

pumaguard-ui/lib/utils/download_helper_stub.dart

@@ -0,0 +1,6 @@
+import 'dart:typed_data';
+
+/// Stub implementation for non-web platforms
+void downloadFilesWeb(Uint8List fileBytes, String filename) {
+  throw UnsupportedError('downloadFilesWeb is only supported on web platforms');
+}

pumaguard-ui/lib/utils/download_helper_web.dart

@@ -0,0 +1,14 @@
+import 'dart:js_interop';
+import 'package:web/web.dart' as web;
+import 'dart:typed_data';
+
+/// Download files using web browser APIs
+void downloadFilesWeb(Uint8List fileBytes, String filename) {
+  final anchor = web.document.createElement('a') as web.HTMLAnchorElement;
+  final blob = web.Blob([fileBytes.toJS].toJS);
+  final url = web.URL.createObjectURL(blob);
+  anchor.href = url;
+  anchor.download = filename;
+  anchor.click();
+  web.URL.revokeObjectURL(url);
+}

pumaguard-ui/lib/utils/platform_url.dart

@@ -0,0 +1,10 @@
+/// Platform-agnostic URL helper that provides the API base URL.
+///
+/// This file uses conditional exports to provide different implementations
+/// for web and non-web platforms, avoiding the use of web-only APIs
+/// in test environments.
+library;
+
+export 'platform_url_stub.dart'
+    if (dart.library.html) 'platform_url_web.dart'
+    if (dart.library.io) 'platform_url_stub.dart';

pumaguard-ui/lib/utils/platform_url_stub.dart

@@ -0,0 +1,11 @@
+/// Stub implementation for non-web platforms (VM, tests, etc.).
+///
+/// This provides a default localhost URL for testing and non-web environments
+/// where browser APIs are not available.
+library;
+
+String getApiBaseUrl() {
+  // Default to localhost for test environments
+  // In a real production non-web build, this would need proper configuration
+  return 'http://localhost:5000';
+}

pumaguard-ui/lib/utils/platform_url_web.dart

@@ -0,0 +1,16 @@
+/// Web-specific implementation for getting the API base URL.
+///
+/// This implementation uses package:web to access the browser's window.location
+/// and construct the API base URL dynamically based on the current page URL.
+library;
+
+import 'package:web/web.dart' as web;
+
+String getApiBaseUrl() {
+  // Get the current window location to construct the API base URL
+  // This allows the app to work when accessed from any host/port
+  final window = web.window;
+  final protocol = window.location.protocol; // 'http:' or 'https:'
+  final host = window.location.host; // 'hostname:port' or just 'hostname'
+  return '$protocol//$host';
+}

pumaguard-ui/linux/.gitignore

@@ -0,0 +1 @@
+flutter/ephemeral