286 lines
10 KiB
Rust
286 lines
10 KiB
Rust
use std::{
|
|
collections::VecDeque,
|
|
fmt::Display,
|
|
mem,
|
|
net::{IpAddr, Ipv4Addr},
|
|
};
|
|
|
|
use egui::{Button, Color32, RichText, Sense, Stroke, Vec2};
|
|
use ewebsock::{Options, WsReceiver, WsSender};
|
|
use wasm_timer::Instant;
|
|
|
|
use crate::websocket::{
|
|
AddHyperdeckRequest, ClientRequest, HyperdeckConnectionState, RemoveHyperdeckRequest,
|
|
ServerEvent,
|
|
};
|
|
|
|
pub struct HyperdeckMonitorApp {
|
|
blink: bool,
|
|
last_blink_change: Instant,
|
|
new_hyperdeck_ip: String,
|
|
new_hyperdeck_name: String,
|
|
new_hyperdeck_port: String,
|
|
hyperdecks: Vec<Hyperdeck>,
|
|
websocket_message_queue: VecDeque<ClientRequest>,
|
|
ws_sender: WsSender,
|
|
ws_receiver: WsReceiver,
|
|
}
|
|
|
|
impl Default for HyperdeckMonitorApp {
|
|
fn default() -> Self {
|
|
let (ws_sender, ws_receiver) =
|
|
ewebsock::connect("ws://127.0.0.1:9681/ws", Options::default()).unwrap();
|
|
Self {
|
|
blink: false,
|
|
last_blink_change: Instant::now(),
|
|
new_hyperdeck_ip: "".to_owned(),
|
|
new_hyperdeck_name: "".to_owned(),
|
|
new_hyperdeck_port: 9993.to_string(),
|
|
hyperdecks: vec![
|
|
// Hyperdeck {
|
|
// id: "test-1".to_string(),
|
|
// name: "Test Hyperdeck 1".to_string(),
|
|
// ip: IpAddr::V4(Ipv4Addr::new(192, 168, 10, 1)),
|
|
// status: HyperdeckStatus::Connected,
|
|
// recording_bays: vec![HyperdeckRecordBay {
|
|
// status: RecordingStatus::NotRecording,
|
|
// storage_capacity_mb: 500_000,
|
|
// recording_time_remaining: TimeRemaining(60),
|
|
// }],
|
|
// },
|
|
// Hyperdeck {
|
|
// id: "test-2".to_string(),
|
|
// name: "Test Hyperdeck 2".to_string(),
|
|
// ip: IpAddr::V4(Ipv4Addr::new(192, 168, 10, 2)),
|
|
// status: HyperdeckStatus::Disconnected,
|
|
// recording_bays: vec![HyperdeckRecordBay {
|
|
// status: RecordingStatus::NotRecording,
|
|
// storage_capacity_mb: 500_000,
|
|
// recording_time_remaining: TimeRemaining(3600 * 5), // 5 Hours
|
|
// }],
|
|
// },
|
|
],
|
|
websocket_message_queue: VecDeque::new(),
|
|
ws_sender,
|
|
ws_receiver,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl eframe::App for HyperdeckMonitorApp {
|
|
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
|
|
if let Some(message) = self.websocket_message_queue.pop_front() {
|
|
self.ws_sender.send(ewebsock::WsMessage::Text(
|
|
serde_json::to_string(&message).expect("Could not serialize message"),
|
|
));
|
|
}
|
|
if let Some(ewebsock::WsEvent::Message(ewebsock::WsMessage::Text(event))) =
|
|
self.ws_receiver.try_recv()
|
|
{
|
|
if let Ok(received) = serde_json::from_str::<ServerEvent>(&event) {
|
|
match received {
|
|
ServerEvent::HyperdeckMonitorState(state) => {
|
|
self.hyperdecks = Default::default();
|
|
for (id, hyperdeck) in state.hyperdecks {
|
|
self.hyperdecks.push(Hyperdeck {
|
|
id,
|
|
name: hyperdeck.name,
|
|
ip: hyperdeck.ip.parse().unwrap(),
|
|
status: hyperdeck.connection_state.into(),
|
|
recording_bays: vec![],
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
|
|
egui::menu::bar(ui, |ui| {
|
|
egui::widgets::global_dark_light_mode_buttons(ui);
|
|
});
|
|
});
|
|
|
|
egui::CentralPanel::default().show(ctx, |ui| {
|
|
add_hyperdeck_panel(
|
|
ui,
|
|
&mut self.new_hyperdeck_name,
|
|
&mut self.new_hyperdeck_ip,
|
|
&mut self.new_hyperdeck_port,
|
|
&mut self.websocket_message_queue,
|
|
);
|
|
ui.separator();
|
|
|
|
ui.vertical(|ui| {
|
|
hyperdeck_list(
|
|
ui,
|
|
&self.hyperdecks,
|
|
self.blink,
|
|
&mut self.websocket_message_queue,
|
|
);
|
|
});
|
|
|
|
ui.with_layout(egui::Layout::bottom_up(egui::Align::LEFT), |ui| {
|
|
connection_status(ui);
|
|
egui::warn_if_debug_build(ui);
|
|
});
|
|
});
|
|
|
|
if self.last_blink_change.elapsed().as_secs() >= 1 {
|
|
self.blink = !self.blink;
|
|
println!("BLINK");
|
|
self.last_blink_change = Instant::now();
|
|
}
|
|
|
|
egui::Context::request_repaint(ctx);
|
|
}
|
|
}
|
|
|
|
fn add_hyperdeck_panel(
|
|
ui: &mut egui::Ui,
|
|
new_hyperdeck_name: &mut String,
|
|
new_hyperdeck_ip: &mut String,
|
|
new_hyperdeck_port: &mut String,
|
|
message_queue: &mut VecDeque<ClientRequest>,
|
|
) {
|
|
ui.heading("Add hyperdeck");
|
|
ui.horizontal(|ui| {
|
|
ui.label("Name");
|
|
ui.text_edit_singleline(new_hyperdeck_name);
|
|
ui.label("IP");
|
|
ui.text_edit_singleline(new_hyperdeck_ip);
|
|
ui.label("Port");
|
|
ui.text_edit_singleline(new_hyperdeck_port);
|
|
let button_enabled = new_hyperdeck_ip.parse::<IpAddr>().is_ok()
|
|
&& !new_hyperdeck_name.is_empty()
|
|
&& new_hyperdeck_port.parse::<u16>().is_ok();
|
|
if ui.add_enabled(button_enabled, Button::new("Add")).clicked() {
|
|
message_queue.push_back(ClientRequest::AddHyperdeck(AddHyperdeckRequest {
|
|
name: mem::take(new_hyperdeck_name),
|
|
ip: mem::take(new_hyperdeck_ip),
|
|
port: mem::replace(new_hyperdeck_port, "9993".to_string())
|
|
.parse::<u16>()
|
|
.unwrap(),
|
|
}));
|
|
}
|
|
});
|
|
}
|
|
|
|
fn hyperdeck_list(
|
|
ui: &mut egui::Ui,
|
|
hyperdecks: &[Hyperdeck],
|
|
blink: bool,
|
|
message_queue: &mut VecDeque<ClientRequest>,
|
|
) {
|
|
for hyperdeck in hyperdecks {
|
|
ui.vertical(|ui| {
|
|
ui.horizontal(|ui| {
|
|
let status_colour = match hyperdeck.status {
|
|
HyperdeckStatus::Connected => Color32::GREEN,
|
|
HyperdeckStatus::Disconnected => Color32::RED,
|
|
};
|
|
let (response, painter) =
|
|
ui.allocate_painter(Vec2 { x: 16.0, y: 16.0 }, Sense::hover());
|
|
let rect = response.rect;
|
|
let c = rect.center();
|
|
let r = (rect.width() / 2.0) * 0.8;
|
|
painter.circle(c, r, status_colour, Stroke::NONE);
|
|
let hyperdeck_heading: RichText =
|
|
format!("{} [{}]", hyperdeck.name, hyperdeck.ip).into();
|
|
ui.heading(hyperdeck_heading.strong());
|
|
if ui.button("Remove").clicked() {
|
|
message_queue.push_back(ClientRequest::RemoveHyperdeck(
|
|
RemoveHyperdeckRequest {
|
|
id: hyperdeck.id.clone(),
|
|
},
|
|
));
|
|
}
|
|
});
|
|
if !hyperdeck.recording_bays.is_empty()
|
|
&& matches!(hyperdeck.status, HyperdeckStatus::Connected)
|
|
{
|
|
let recording_bays_text: RichText = "Recording Bays".into();
|
|
ui.label(recording_bays_text.size(16.0).strong());
|
|
for (index, bay) in hyperdeck.recording_bays.iter().enumerate() {
|
|
ui.horizontal(|ui| {
|
|
let bay_label: RichText = format!("Bay {}", index + 1).into();
|
|
ui.label(bay_label.strong());
|
|
match bay.status {
|
|
RecordingStatus::Recording => ui.label("Recording"),
|
|
RecordingStatus::NotRecording => ui.label("Not Recording"),
|
|
};
|
|
ui.label(format!(
|
|
"Total Storage Capacity: {}GB",
|
|
bay.storage_capacity_mb / 1000,
|
|
));
|
|
let time_remaining_text: RichText =
|
|
format!("Time remaining: {}", bay.recording_time_remaining).into();
|
|
|
|
if bay.recording_time_remaining.0 > 15 * 60 || !blink {
|
|
ui.label(time_remaining_text);
|
|
} else {
|
|
ui.label(time_remaining_text.color(Color32::RED));
|
|
};
|
|
});
|
|
}
|
|
}
|
|
ui.separator();
|
|
});
|
|
}
|
|
}
|
|
|
|
fn connection_status(ui: &mut egui::Ui) {
|
|
ui.horizontal(|ui| {
|
|
// TODO: Make it real
|
|
ui.label("Connected");
|
|
});
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
struct Hyperdeck {
|
|
id: String,
|
|
name: String,
|
|
ip: IpAddr,
|
|
status: HyperdeckStatus,
|
|
recording_bays: Vec<HyperdeckRecordBay>,
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
enum HyperdeckStatus {
|
|
Connected,
|
|
Disconnected,
|
|
}
|
|
|
|
impl From<HyperdeckConnectionState> for HyperdeckStatus {
|
|
fn from(value: HyperdeckConnectionState) -> Self {
|
|
match value {
|
|
HyperdeckConnectionState::Connected => HyperdeckStatus::Connected,
|
|
HyperdeckConnectionState::Disconnected => HyperdeckStatus::Disconnected,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
struct HyperdeckRecordBay {
|
|
status: RecordingStatus,
|
|
/// Storage capacity in MB.
|
|
storage_capacity_mb: u64,
|
|
/// Recording time available in seconds.
|
|
recording_time_remaining: TimeRemaining,
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
struct TimeRemaining(u64);
|
|
|
|
impl Display for TimeRemaining {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let time = hrtime::from_sec_padded(self.0);
|
|
write!(f, "{time}")
|
|
}
|
|
}
|
|
|
|
#[derive(serde::Deserialize, serde::Serialize)]
|
|
enum RecordingStatus {
|
|
Recording,
|
|
NotRecording,
|
|
}
|