Add connection status on client entries (#1688)

Author: zmerp

alvr/dashboard/src/dashboard/components/connections.rs

@@ -3,7 +3,7 @@ use crate::{
     theme::{self, log_colors},
 };
 use alvr_packets::ClientListAction;
-use alvr_session::{ClientConnectionConfig, SessionConfig};
+use alvr_session::{ClientConnectionConfig, ConnectionState, SessionConfig};
 use eframe::{
     egui::{Frame, Grid, Layout, RichText, TextEdit, Ui, Window},
     emath::{Align, Align2},
@@ -127,6 +127,11 @@ impl ConnectionsTab {
                                             .unwrap_or(IpAddr::V4(Ipv4Addr::UNSPECIFIED)),
                                         data.display_name
                                     ));
+                                    if data.connection_state == ConnectionState::Disconnected {
+                                        ui.colored_label(Color32::GRAY, "Disconnected");
+                                    } else {
+                                        ui.colored_label(theme::OK_GREEN, "Streaming");
+                                    }
                                 });
                                 ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
                                     if ui.button("Remove").clicked() {

alvr/dashboard/src/dashboard/mod.rs

@@ -249,8 +249,6 @@ impl eframe::App for Dashboard {
                     ui.with_layout(
                         Layout::bottom_up(Align::Center).with_cross_justify(true),
                         |ui| {
-                            use eframe::epaint::Color32;
-
                             ui.add_space(5.0);
 
                             if connected_to_server {
@@ -263,12 +261,12 @@ impl eframe::App for Dashboard {
 
                             ui.horizontal(|ui| {
                                 ui.add_space(5.0);
-                                ui.label("Streamer:");
+                                ui.label("SteamVR:");
                                 ui.add_space(-10.0);
                                 if connected_to_server {
-                                    ui.label(RichText::new("Connected").color(Color32::GREEN));
+                                    ui.label(RichText::new("Connected").color(theme::OK_GREEN));
                                 } else {
-                                    ui.label(RichText::new("Disconnected").color(Color32::RED));
+                                    ui.label(RichText::new("Disconnected").color(theme::KO_RED));
                                 }
                             })
                         },

alvr/dashboard/src/data_sources.rs

@@ -175,7 +175,7 @@ impl DataSources {
                                 | ServerRequest::InsertIdr
                                 | ServerRequest::StartRecording
                                 | ServerRequest::StopRecording => {
-                                    warn!("Cannot perform action, streamer is not connected.")
+                                    warn!("Cannot perform action, streamer (SteamVR) is not connected.")
                                 }
                                 ServerRequest::RestartSteamvr | ServerRequest::ShutdownSteamvr => {
                                     warn!("SteamVR not launched")

alvr/dashboard/src/theme.rs

@@ -10,6 +10,7 @@ pub const SELECTED: Color32 = Color32::from_rgb(120, 174, 237);
 pub const FG: Color32 = Color32::from_rgb(250, 250, 250);
 
 pub const OK_GREEN: Color32 = Color32::GREEN;
+pub const KO_RED: Color32 = Color32::RED;
 
 pub mod log_colors {
     use super::ACCENT;

alvr/packets/src/lib.rs

@@ -2,7 +2,7 @@ use alvr_common::{
     glam::{UVec2, Vec2},
     DeviceMotion, Fov, LogEntry, LogSeverity, Pose,
 };
-use alvr_session::{CodecType, SessionConfig};
+use alvr_session::{CodecType, ConnectionState, SessionConfig};
 use serde::{Deserialize, Serialize};
 use std::{
     fmt::{self, Debug},
@@ -193,6 +193,7 @@ pub enum ClientListAction {
     SetManualIps(Vec<IpAddr>),
     RemoveEntry,
     UpdateCurrentIp(Option<IpAddr>),
+    SetConnectionState(ConnectionState),
 }
 
 #[derive(Serialize, Deserialize, Default, Clone)]

alvr/server/src/connection.rs

@@ -24,7 +24,7 @@ use alvr_packets::{
     ButtonValue, ClientConnectionResult, ClientControlPacket, ClientListAction, ClientStatistics,
     ServerControlPacket, StreamConfigPacket, Tracking, AUDIO, HAPTICS, STATISTICS, TRACKING, VIDEO,
 };
-use alvr_session::{CodecType, ControllersEmulationMode, FrameSize, OpenvrConfig};
+use alvr_session::{CodecType, ConnectionState, ControllersEmulationMode, FrameSize, OpenvrConfig};
 use alvr_sockets::{
     spawn_cancelable, ControlSocketReceiver, ControlSocketSender, PeerType, ProtoControlSocket,
     StreamSocketBuilder, KEEPALIVE_INTERVAL,
@@ -506,11 +506,19 @@ fn try_connect(mut client_ips: HashMap<IpAddr, String>) -> IntResult {
 }
 
 // close stream on Drop (manual disconnection or execution canceling)
-struct StreamCloseGuard(Arc<RelaxedAtomic>);
+struct StreamCloseGuard {
+    is_streaming: Arc<RelaxedAtomic>,
+    streaming_hostname: String,
+}
 
 impl Drop for StreamCloseGuard {
     fn drop(&mut self) {
-        self.0.set(false);
+        self.is_streaming.set(false);
+
+        SERVER_DATA_MANAGER.write().update_client_list(
+            self.streaming_hostname.clone(),
+            ClientListAction::SetConnectionState(ConnectionState::Disconnected),
+        );
 
         *VIDEO_RECORDING_FILE.lock() = None;
 
@@ -611,7 +619,15 @@ async fn connection_pipeline(
     unsafe { crate::InitializeStreaming() };
 
     let is_streaming = Arc::new(RelaxedAtomic::new(true));
-    let _stream_guard = StreamCloseGuard(Arc::clone(&is_streaming));
+    let _stream_guard = StreamCloseGuard {
+        is_streaming: Arc::clone(&is_streaming),
+        streaming_hostname: client_hostname.clone(),
+    };
+
+    SERVER_DATA_MANAGER.write().update_client_list(
+        client_hostname.clone(),
+        ClientListAction::SetConnectionState(ConnectionState::Streaming),
+    );
 
     let game_audio_loop: BoxFuture<_> = if let Switch::Enabled(config) = settings.audio.game_audio {
         let sender = stream_socket.request_stream(AUDIO).await?;

alvr/server_io/src/lib.rs

@@ -9,7 +9,7 @@ pub use openvrpaths::*;
 use alvr_common::prelude::*;
 use alvr_events::EventType;
 use alvr_packets::{AudioDevicesList, ClientListAction, GpuVendor, PathSegment, PathValuePair};
-use alvr_session::{ClientConnectionConfig, SessionConfig, Settings};
+use alvr_session::{ClientConnectionConfig, ConnectionState, SessionConfig, Settings};
 use cpal::traits::{DeviceTrait, HostTrait};
 use serde_json as json;
 use std::{
@@ -216,10 +216,11 @@ impl ServerDataManager {
             } => {
                 if let Entry::Vacant(new_entry) = maybe_client_entry {
                     let client_connection_desc = ClientConnectionConfig {
-                        trusted,
+                        display_name: "Unknown".into(),
                         current_ip: None,
                         manual_ips: manual_ips.into_iter().collect(),
-                        display_name: "Unknown".into(),
+                        trusted,
+                        connection_state: ConnectionState::Disconnected,
                     };
                     new_entry.insert(client_connection_desc);
 
@@ -259,6 +260,15 @@ impl ServerDataManager {
                     if entry.get().current_ip != current_ip {
                         entry.get_mut().current_ip = current_ip;
 
+                        updated = true;
+                    }
+                }
+            }
+            ClientListAction::SetConnectionState(state) => {
+                if let Entry::Occupied(mut entry) = maybe_client_entry {
+                    if entry.get().connection_state != state {
+                        entry.get_mut().connection_state = state;
+
                         updated = true;
                     }
                 }

alvr/session/src/lib.rs

@@ -96,12 +96,20 @@ pub struct OpenvrConfig {
     pub amd_bitrate_corruption_fix: bool,
 }
 
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
+pub enum ConnectionState {
+    Disconnected,
+    Connected,
+    Streaming,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct ClientConnectionConfig {
     pub display_name: String,
     pub current_ip: Option<IpAddr>,
     pub manual_ips: HashSet<IpAddr>,
     pub trusted: bool,
+    pub connection_state: ConnectionState,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]