mirror of
https://github.com/mofeng-git/One-KVM.git
synced 2026-03-15 07:26:44 +08:00
1786b7689d
- 调整音视频架构，提升 RKMPP 编码 MJPEG-->H264 性能，同时解决丢帧马赛克问题； - 删除多用户逻辑，只保留单用户，支持设置 web 单会话； - 修复删除体验不好的的回退逻辑，前端页面菜单位置微调； - 增加 OTG USB 设备动态调整功能； - 修复 mdns 问题，webrtc 视频切换更顺畅。
667 lines
22 KiB
Rust
667 lines
22 KiB
Rust
//! System event types
|
|
//!
|
|
//! Defines all event types that can be broadcast through the event bus.
|
|
|
|
use chrono::{DateTime, Utc};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::collections::HashMap;
|
|
|
|
use crate::atx::PowerStatus;
|
|
use crate::msd::MsdMode;
|
|
|
|
// ============================================================================
|
|
// Device Info Structures (for system.device_info event)
|
|
// ============================================================================
|
|
|
|
/// Video device information
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct VideoDeviceInfo {
|
|
/// Whether video device is available
|
|
pub available: bool,
|
|
/// Device path (e.g., /dev/video0)
|
|
pub device: Option<String>,
|
|
/// Pixel format (e.g., "MJPEG", "YUYV")
|
|
pub format: Option<String>,
|
|
/// Resolution (width, height)
|
|
pub resolution: Option<(u32, u32)>,
|
|
/// Frames per second
|
|
pub fps: u32,
|
|
/// Whether stream is currently active
|
|
pub online: bool,
|
|
/// Current streaming mode: "mjpeg", "h264", "h265", "vp8", or "vp9"
|
|
pub stream_mode: String,
|
|
/// Whether video config is currently being changed (frontend should skip mode sync)
|
|
pub config_changing: bool,
|
|
/// Error message if any, None if OK
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
/// HID device information
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct HidDeviceInfo {
|
|
/// Whether HID backend is available
|
|
pub available: bool,
|
|
/// Backend type: "otg", "ch9329", "none"
|
|
pub backend: String,
|
|
/// Whether backend is initialized and ready
|
|
pub initialized: bool,
|
|
/// Whether absolute mouse positioning is supported
|
|
pub supports_absolute_mouse: bool,
|
|
/// Device path (e.g., serial port for CH9329)
|
|
pub device: Option<String>,
|
|
/// Error message if any, None if OK
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
/// MSD device information
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct MsdDeviceInfo {
|
|
/// Whether MSD is available
|
|
pub available: bool,
|
|
/// Operating mode: "none", "image", "drive"
|
|
pub mode: String,
|
|
/// Whether storage is connected to target
|
|
pub connected: bool,
|
|
/// Currently mounted image ID
|
|
pub image_id: Option<String>,
|
|
/// Error message if any, None if OK
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
/// ATX device information
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct AtxDeviceInfo {
|
|
/// Whether ATX controller is available
|
|
pub available: bool,
|
|
/// Backend type: "gpio", "usb_relay", "none"
|
|
pub backend: String,
|
|
/// Whether backend is initialized
|
|
pub initialized: bool,
|
|
/// Whether power is currently on
|
|
pub power_on: bool,
|
|
/// Error message if any, None if OK
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
/// Audio device information
|
|
///
|
|
/// Note: Sample rate is fixed at 48000Hz and channels at 2 (stereo).
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct AudioDeviceInfo {
|
|
/// Whether audio is enabled/available
|
|
pub available: bool,
|
|
/// Whether audio is currently streaming
|
|
pub streaming: bool,
|
|
/// Current audio device name
|
|
pub device: Option<String>,
|
|
/// Quality preset: "voice", "balanced", "high"
|
|
pub quality: String,
|
|
/// Error message if any, None if OK
|
|
pub error: Option<String>,
|
|
}
|
|
|
|
/// Per-client statistics
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct ClientStats {
|
|
/// Client ID
|
|
pub id: String,
|
|
/// Current FPS for this client (frames sent in last second)
|
|
pub fps: u32,
|
|
/// Connected duration (seconds)
|
|
pub connected_secs: u64,
|
|
}
|
|
|
|
/// System event enumeration
|
|
///
|
|
/// All events are tagged with their event name for serialization.
|
|
/// The `serde(tag = "event", content = "data")` attribute creates a
|
|
/// JSON structure like:
|
|
/// ```json
|
|
/// {
|
|
/// "event": "stream.state_changed",
|
|
/// "data": { "state": "streaming", "device": "/dev/video0" }
|
|
/// }
|
|
/// ```
|
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
#[serde(tag = "event", content = "data")]
|
|
pub enum SystemEvent {
|
|
// ============================================================================
|
|
// Video Stream Events
|
|
// ============================================================================
|
|
/// Stream mode switching started (transactional, correlates all following events)
|
|
///
|
|
/// Sent immediately after a mode switch request is accepted.
|
|
/// Clients can use `transition_id` to correlate subsequent `stream.*` events.
|
|
#[serde(rename = "stream.mode_switching")]
|
|
StreamModeSwitching {
|
|
/// Unique transition ID for this mode switch transaction
|
|
transition_id: String,
|
|
/// Target mode: "mjpeg", "h264", "h265", "vp8", "vp9"
|
|
to_mode: String,
|
|
/// Previous mode: "mjpeg", "h264", "h265", "vp8", "vp9"
|
|
from_mode: String,
|
|
},
|
|
|
|
/// Stream state changed (e.g., started, stopped, error)
|
|
#[serde(rename = "stream.state_changed")]
|
|
StreamStateChanged {
|
|
/// Current state: "uninitialized", "ready", "streaming", "no_signal", "error"
|
|
state: String,
|
|
/// Device path if available
|
|
device: Option<String>,
|
|
},
|
|
|
|
/// Stream configuration is being changed
|
|
///
|
|
/// Sent before applying new configuration to notify clients that
|
|
/// the stream will be interrupted temporarily.
|
|
#[serde(rename = "stream.config_changing")]
|
|
StreamConfigChanging {
|
|
/// Optional transition ID if this config change is part of a mode switch transaction
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
transition_id: Option<String>,
|
|
/// Reason for change: "device_switch", "resolution_change", "format_change"
|
|
reason: String,
|
|
},
|
|
|
|
/// Stream configuration has been applied successfully
|
|
///
|
|
/// Sent after new configuration is active. Clients can reconnect now.
|
|
#[serde(rename = "stream.config_applied")]
|
|
StreamConfigApplied {
|
|
/// Optional transition ID if this config change is part of a mode switch transaction
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
transition_id: Option<String>,
|
|
/// Device path
|
|
device: String,
|
|
/// Resolution (width, height)
|
|
resolution: (u32, u32),
|
|
/// Pixel format: "mjpeg", "yuyv", etc.
|
|
format: String,
|
|
/// Frames per second
|
|
fps: u32,
|
|
},
|
|
|
|
/// Stream device was lost (disconnected or error)
|
|
#[serde(rename = "stream.device_lost")]
|
|
StreamDeviceLost {
|
|
/// Device path that was lost
|
|
device: String,
|
|
/// Reason for loss
|
|
reason: String,
|
|
},
|
|
|
|
/// Stream device is reconnecting
|
|
#[serde(rename = "stream.reconnecting")]
|
|
StreamReconnecting {
|
|
/// Device path being reconnected
|
|
device: String,
|
|
/// Retry attempt number
|
|
attempt: u32,
|
|
},
|
|
|
|
/// Stream device has recovered
|
|
#[serde(rename = "stream.recovered")]
|
|
StreamRecovered {
|
|
/// Device path that was recovered
|
|
device: String,
|
|
},
|
|
|
|
/// WebRTC is ready to accept connections
|
|
///
|
|
/// Sent after video frame source is connected to WebRTC pipeline.
|
|
/// Clients should wait for this event before attempting to create WebRTC sessions.
|
|
#[serde(rename = "stream.webrtc_ready")]
|
|
WebRTCReady {
|
|
/// Optional transition ID if this readiness is part of a mode switch transaction
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
transition_id: Option<String>,
|
|
/// Current video codec
|
|
codec: String,
|
|
/// Whether hardware encoding is being used
|
|
hardware: bool,
|
|
},
|
|
|
|
/// WebRTC ICE candidate (server -> client trickle)
|
|
#[serde(rename = "webrtc.ice_candidate")]
|
|
WebRTCIceCandidate {
|
|
/// WebRTC session ID
|
|
session_id: String,
|
|
/// ICE candidate data
|
|
candidate: crate::webrtc::signaling::IceCandidate,
|
|
},
|
|
|
|
/// WebRTC ICE gathering complete (server -> client)
|
|
#[serde(rename = "webrtc.ice_complete")]
|
|
WebRTCIceComplete {
|
|
/// WebRTC session ID
|
|
session_id: String,
|
|
},
|
|
|
|
/// Stream statistics update (sent periodically for client stats)
|
|
#[serde(rename = "stream.stats_update")]
|
|
StreamStatsUpdate {
|
|
/// Number of connected clients
|
|
clients: u64,
|
|
/// Per-client statistics (client_id -> client stats)
|
|
/// Each client's FPS reflects the actual frames sent in the last second
|
|
clients_stat: HashMap<String, ClientStats>,
|
|
},
|
|
|
|
/// Stream mode changed (MJPEG <-> WebRTC)
|
|
///
|
|
/// Sent when the streaming mode is switched. Clients should disconnect
|
|
/// from the current stream and reconnect using the new mode.
|
|
#[serde(rename = "stream.mode_changed")]
|
|
StreamModeChanged {
|
|
/// Optional transition ID if this change is part of a mode switch transaction
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
transition_id: Option<String>,
|
|
/// New mode: "mjpeg", "h264", "h265", "vp8", or "vp9"
|
|
mode: String,
|
|
/// Previous mode: "mjpeg", "h264", "h265", "vp8", or "vp9"
|
|
previous_mode: String,
|
|
},
|
|
|
|
/// Stream mode switching completed (transactional end marker)
|
|
///
|
|
/// Sent when the backend considers the new mode ready for clients to connect.
|
|
#[serde(rename = "stream.mode_ready")]
|
|
StreamModeReady {
|
|
/// Unique transition ID for this mode switch transaction
|
|
transition_id: String,
|
|
/// Active mode after switch: "mjpeg", "h264", "h265", "vp8", "vp9"
|
|
mode: String,
|
|
},
|
|
|
|
// ============================================================================
|
|
// HID Events
|
|
// ============================================================================
|
|
/// HID backend state changed
|
|
#[serde(rename = "hid.state_changed")]
|
|
HidStateChanged {
|
|
/// Backend type: "otg", "ch9329", "none"
|
|
backend: String,
|
|
/// Whether backend is initialized and ready
|
|
initialized: bool,
|
|
/// Error message if any, None if OK
|
|
error: Option<String>,
|
|
/// Error code for programmatic handling: "epipe", "eagain", "port_not_found", etc.
|
|
error_code: Option<String>,
|
|
},
|
|
|
|
/// HID backend is being switched
|
|
#[serde(rename = "hid.backend_switching")]
|
|
HidBackendSwitching {
|
|
/// Current backend
|
|
from: String,
|
|
/// New backend
|
|
to: String,
|
|
},
|
|
|
|
/// HID device lost (device file missing or I/O error)
|
|
#[serde(rename = "hid.device_lost")]
|
|
HidDeviceLost {
|
|
/// Backend type: "otg", "ch9329"
|
|
backend: String,
|
|
/// Device path that was lost (e.g., /dev/hidg0 or /dev/ttyUSB0)
|
|
device: Option<String>,
|
|
/// Human-readable reason for loss
|
|
reason: String,
|
|
/// Error code: "epipe", "eshutdown", "eagain", "enxio", "port_not_found", "io_error"
|
|
error_code: String,
|
|
},
|
|
|
|
/// HID device is reconnecting
|
|
#[serde(rename = "hid.reconnecting")]
|
|
HidReconnecting {
|
|
/// Backend type: "otg", "ch9329"
|
|
backend: String,
|
|
/// Current retry attempt number
|
|
attempt: u32,
|
|
},
|
|
|
|
/// HID device has recovered after error
|
|
#[serde(rename = "hid.recovered")]
|
|
HidRecovered {
|
|
/// Backend type: "otg", "ch9329"
|
|
backend: String,
|
|
},
|
|
|
|
// ============================================================================
|
|
// MSD (Mass Storage Device) Events
|
|
// ============================================================================
|
|
/// MSD state changed
|
|
#[serde(rename = "msd.state_changed")]
|
|
MsdStateChanged {
|
|
/// Operating mode
|
|
mode: MsdMode,
|
|
/// Whether storage is connected to target
|
|
connected: bool,
|
|
},
|
|
|
|
/// Image has been mounted
|
|
#[serde(rename = "msd.image_mounted")]
|
|
MsdImageMounted {
|
|
/// Image ID
|
|
image_id: String,
|
|
/// Image filename
|
|
image_name: String,
|
|
/// Image size in bytes
|
|
size: u64,
|
|
/// Mount as CD-ROM (read-only)
|
|
cdrom: bool,
|
|
},
|
|
|
|
/// Image has been unmounted
|
|
#[serde(rename = "msd.image_unmounted")]
|
|
MsdImageUnmounted,
|
|
|
|
/// File upload progress (for large file uploads)
|
|
#[serde(rename = "msd.upload_progress")]
|
|
MsdUploadProgress {
|
|
/// Upload operation ID
|
|
upload_id: String,
|
|
/// Filename being uploaded
|
|
filename: String,
|
|
/// Bytes uploaded so far
|
|
bytes_uploaded: u64,
|
|
/// Total file size
|
|
total_bytes: u64,
|
|
/// Progress percentage (0.0 - 100.0)
|
|
progress_pct: f32,
|
|
},
|
|
|
|
/// Image download progress (for URL downloads)
|
|
#[serde(rename = "msd.download_progress")]
|
|
MsdDownloadProgress {
|
|
/// Download operation ID
|
|
download_id: String,
|
|
/// Source URL
|
|
url: String,
|
|
/// Target filename
|
|
filename: String,
|
|
/// Bytes downloaded so far
|
|
bytes_downloaded: u64,
|
|
/// Total file size (None if unknown)
|
|
total_bytes: Option<u64>,
|
|
/// Progress percentage (0.0 - 100.0, None if total unknown)
|
|
progress_pct: Option<f32>,
|
|
/// Download status: "started", "in_progress", "completed", "failed"
|
|
status: String,
|
|
},
|
|
|
|
/// USB gadget connection status changed (host connected/disconnected)
|
|
#[serde(rename = "msd.usb_status_changed")]
|
|
MsdUsbStatusChanged {
|
|
/// Whether host is connected to USB device
|
|
connected: bool,
|
|
/// USB device state from kernel (e.g., "configured", "not attached")
|
|
device_state: String,
|
|
},
|
|
|
|
/// MSD operation error (configfs, image mount, etc.)
|
|
#[serde(rename = "msd.error")]
|
|
MsdError {
|
|
/// Human-readable reason for error
|
|
reason: String,
|
|
/// Error code: "configfs_error", "image_not_found", "mount_failed", "io_error"
|
|
error_code: String,
|
|
},
|
|
|
|
/// MSD has recovered after error
|
|
#[serde(rename = "msd.recovered")]
|
|
MsdRecovered,
|
|
|
|
// ============================================================================
|
|
// ATX (Power Control) Events
|
|
// ============================================================================
|
|
/// ATX power state changed
|
|
#[serde(rename = "atx.state_changed")]
|
|
AtxStateChanged {
|
|
/// Power status
|
|
power_status: PowerStatus,
|
|
},
|
|
|
|
/// ATX action was executed
|
|
#[serde(rename = "atx.action_executed")]
|
|
AtxActionExecuted {
|
|
/// Action: "short", "long", "reset"
|
|
action: String,
|
|
/// When the action was executed
|
|
timestamp: DateTime<Utc>,
|
|
},
|
|
|
|
// ============================================================================
|
|
// Audio Events
|
|
// ============================================================================
|
|
/// Audio state changed (streaming started/stopped)
|
|
#[serde(rename = "audio.state_changed")]
|
|
AudioStateChanged {
|
|
/// Whether audio is currently streaming
|
|
streaming: bool,
|
|
/// Current device (None if stopped)
|
|
device: Option<String>,
|
|
},
|
|
|
|
/// Audio device was selected
|
|
#[serde(rename = "audio.device_selected")]
|
|
AudioDeviceSelected {
|
|
/// Selected device name
|
|
device: String,
|
|
},
|
|
|
|
/// Audio quality was changed
|
|
#[serde(rename = "audio.quality_changed")]
|
|
AudioQualityChanged {
|
|
/// New quality setting: "voice", "balanced", "high"
|
|
quality: String,
|
|
},
|
|
|
|
/// Audio device lost (capture error or device disconnected)
|
|
#[serde(rename = "audio.device_lost")]
|
|
AudioDeviceLost {
|
|
/// Audio device name (e.g., "hw:0,0")
|
|
device: Option<String>,
|
|
/// Human-readable reason for loss
|
|
reason: String,
|
|
/// Error code: "device_busy", "device_disconnected", "capture_error", "io_error"
|
|
error_code: String,
|
|
},
|
|
|
|
/// Audio device is reconnecting
|
|
#[serde(rename = "audio.reconnecting")]
|
|
AudioReconnecting {
|
|
/// Current retry attempt number
|
|
attempt: u32,
|
|
},
|
|
|
|
/// Audio device has recovered after error
|
|
#[serde(rename = "audio.recovered")]
|
|
AudioRecovered {
|
|
/// Audio device name
|
|
device: Option<String>,
|
|
},
|
|
|
|
// ============================================================================
|
|
// System Events
|
|
// ============================================================================
|
|
/// A device was added (hot-plug)
|
|
#[serde(rename = "system.device_added")]
|
|
SystemDeviceAdded {
|
|
/// Device type: "video", "audio", "hid", etc.
|
|
device_type: String,
|
|
/// Device path
|
|
device_path: String,
|
|
/// Device name/description
|
|
device_name: String,
|
|
},
|
|
|
|
/// A device was removed (hot-unplug)
|
|
#[serde(rename = "system.device_removed")]
|
|
SystemDeviceRemoved {
|
|
/// Device type
|
|
device_type: String,
|
|
/// Device path that was removed
|
|
device_path: String,
|
|
},
|
|
|
|
/// System error or warning
|
|
#[serde(rename = "system.error")]
|
|
SystemError {
|
|
/// Module that generated the error: "stream", "hid", "msd", "atx"
|
|
module: String,
|
|
/// Severity: "warning", "error", "critical"
|
|
severity: String,
|
|
/// Error message
|
|
message: String,
|
|
},
|
|
|
|
/// Complete device information (sent on WebSocket connect and state changes)
|
|
#[serde(rename = "system.device_info")]
|
|
DeviceInfo {
|
|
/// Video device information
|
|
video: VideoDeviceInfo,
|
|
/// HID device information
|
|
hid: HidDeviceInfo,
|
|
/// MSD device information (None if MSD not enabled)
|
|
msd: Option<MsdDeviceInfo>,
|
|
/// ATX device information (None if ATX not enabled)
|
|
atx: Option<AtxDeviceInfo>,
|
|
/// Audio device information (None if audio not enabled)
|
|
audio: Option<AudioDeviceInfo>,
|
|
},
|
|
|
|
/// WebSocket error notification (for connection-level errors like lag)
|
|
#[serde(rename = "error")]
|
|
Error {
|
|
/// Error message
|
|
message: String,
|
|
},
|
|
}
|
|
|
|
impl SystemEvent {
|
|
/// Get the event name (for filtering/routing)
|
|
pub fn event_name(&self) -> &'static str {
|
|
match self {
|
|
Self::StreamModeSwitching { .. } => "stream.mode_switching",
|
|
Self::StreamStateChanged { .. } => "stream.state_changed",
|
|
Self::StreamConfigChanging { .. } => "stream.config_changing",
|
|
Self::StreamConfigApplied { .. } => "stream.config_applied",
|
|
Self::StreamDeviceLost { .. } => "stream.device_lost",
|
|
Self::StreamReconnecting { .. } => "stream.reconnecting",
|
|
Self::StreamRecovered { .. } => "stream.recovered",
|
|
Self::WebRTCReady { .. } => "stream.webrtc_ready",
|
|
Self::StreamStatsUpdate { .. } => "stream.stats_update",
|
|
Self::StreamModeChanged { .. } => "stream.mode_changed",
|
|
Self::StreamModeReady { .. } => "stream.mode_ready",
|
|
Self::WebRTCIceCandidate { .. } => "webrtc.ice_candidate",
|
|
Self::WebRTCIceComplete { .. } => "webrtc.ice_complete",
|
|
Self::HidStateChanged { .. } => "hid.state_changed",
|
|
Self::HidBackendSwitching { .. } => "hid.backend_switching",
|
|
Self::HidDeviceLost { .. } => "hid.device_lost",
|
|
Self::HidReconnecting { .. } => "hid.reconnecting",
|
|
Self::HidRecovered { .. } => "hid.recovered",
|
|
Self::MsdStateChanged { .. } => "msd.state_changed",
|
|
Self::MsdImageMounted { .. } => "msd.image_mounted",
|
|
Self::MsdImageUnmounted => "msd.image_unmounted",
|
|
Self::MsdUploadProgress { .. } => "msd.upload_progress",
|
|
Self::MsdDownloadProgress { .. } => "msd.download_progress",
|
|
Self::MsdUsbStatusChanged { .. } => "msd.usb_status_changed",
|
|
Self::MsdError { .. } => "msd.error",
|
|
Self::MsdRecovered => "msd.recovered",
|
|
Self::AtxStateChanged { .. } => "atx.state_changed",
|
|
Self::AtxActionExecuted { .. } => "atx.action_executed",
|
|
Self::AudioStateChanged { .. } => "audio.state_changed",
|
|
Self::AudioDeviceSelected { .. } => "audio.device_selected",
|
|
Self::AudioQualityChanged { .. } => "audio.quality_changed",
|
|
Self::AudioDeviceLost { .. } => "audio.device_lost",
|
|
Self::AudioReconnecting { .. } => "audio.reconnecting",
|
|
Self::AudioRecovered { .. } => "audio.recovered",
|
|
Self::SystemDeviceAdded { .. } => "system.device_added",
|
|
Self::SystemDeviceRemoved { .. } => "system.device_removed",
|
|
Self::SystemError { .. } => "system.error",
|
|
Self::DeviceInfo { .. } => "system.device_info",
|
|
Self::Error { .. } => "error",
|
|
}
|
|
}
|
|
|
|
/// Check if event name matches a topic pattern
|
|
///
|
|
/// Supports wildcards:
|
|
/// - `*` matches all events
|
|
/// - `stream.*` matches all stream events
|
|
/// - `stream.state_changed` matches exact event
|
|
pub fn matches_topic(&self, topic: &str) -> bool {
|
|
if topic == "*" {
|
|
return true;
|
|
}
|
|
|
|
let event_name = self.event_name();
|
|
|
|
if topic.ends_with(".*") {
|
|
let prefix = topic.trim_end_matches(".*");
|
|
event_name.starts_with(prefix)
|
|
} else {
|
|
event_name == topic
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_event_name() {
|
|
let event = SystemEvent::StreamStateChanged {
|
|
state: "streaming".to_string(),
|
|
device: Some("/dev/video0".to_string()),
|
|
};
|
|
assert_eq!(event.event_name(), "stream.state_changed");
|
|
|
|
let event = SystemEvent::MsdImageMounted {
|
|
image_id: "123".to_string(),
|
|
image_name: "ubuntu.iso".to_string(),
|
|
size: 1024,
|
|
cdrom: true,
|
|
};
|
|
assert_eq!(event.event_name(), "msd.image_mounted");
|
|
}
|
|
|
|
#[test]
|
|
fn test_matches_topic() {
|
|
let event = SystemEvent::StreamStateChanged {
|
|
state: "streaming".to_string(),
|
|
device: None,
|
|
};
|
|
|
|
assert!(event.matches_topic("*"));
|
|
assert!(event.matches_topic("stream.*"));
|
|
assert!(event.matches_topic("stream.state_changed"));
|
|
assert!(!event.matches_topic("msd.*"));
|
|
assert!(!event.matches_topic("stream.config_changed"));
|
|
}
|
|
|
|
#[test]
|
|
fn test_serialization() {
|
|
let event = SystemEvent::StreamConfigApplied {
|
|
transition_id: None,
|
|
device: "/dev/video0".to_string(),
|
|
resolution: (1920, 1080),
|
|
format: "mjpeg".to_string(),
|
|
fps: 30,
|
|
};
|
|
|
|
let json = serde_json::to_string(&event).unwrap();
|
|
assert!(json.contains("stream.config_applied"));
|
|
assert!(json.contains("/dev/video0"));
|
|
|
|
let deserialized: SystemEvent = serde_json::from_str(&json).unwrap();
|
|
assert!(matches!(
|
|
deserialized,
|
|
SystemEvent::StreamConfigApplied { .. }
|
|
));
|
|
}
|
|
}
|