fixed pong messages being sent to the wrong socket

Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 
 [features]
 tracker-state-debug = []
+tokio-logging = []
 
 [dependencies]
 async-channel = "2.2.0"

src/coordinator/mod.rs

@@ -193,9 +193,11 @@ pub async fn start_coordinator(
                             y_adj = y;
                         }
                         Err(e) => {
+                            if state.tracker_state.tracking_id > 0 {
                                 info!("Could not calculate the tracking!: {e}");
                             }
                         }
+                    }
 
                     let me = MoveEvent { x: x_adj, y: y_adj };
                     if let Err(e) = state

src/coordinator/remote_video_processor.rs

@@ -6,7 +6,7 @@ use std::{
 use async_recursion::async_recursion;
 
 use async_channel::Sender;
-use futures_util::{stream::SplitStream, SinkExt, StreamExt, TryStreamExt};
+use futures_util::{stream::{SplitSink, SplitStream}, SinkExt, StreamExt, TryStreamExt};
 use gstreamer_app::AppSink;
 use tokio::{net::TcpStream, sync::Mutex, time::sleep_until};
 use tokio_tungstenite::{connect_async, tungstenite::Message, MaybeTlsStream, WebSocketStream};
@@ -75,7 +75,7 @@ pub async fn remote_video_loop(
                     break;
                 }
 
-                let do_not_break = handle_message(&mut recvr, &to_mec, last_iter).await;
+                let do_not_break = handle_message(&mut recvr, &mut sender, &to_mec, last_iter).await;
 
                 if !do_not_break { break; }
 
@@ -131,6 +131,7 @@ fn get_video_frame(appsink: &AppSink) -> Result<Message, String> {
 #[async_recursion]
 async fn handle_message(
     recvr: &mut SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>, 
+    sender: &mut SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>, 
     to_mec: &Sender<ApplicationEvent>,
     last_iter: Instant,
 ) -> bool {
@@ -144,15 +145,15 @@ async fn handle_message(
                 Message::Pong(_) | Message::Frame(_) | Message::Text(_) => {
                     warn!("There was an unhandled message type from the camera: {}\n{}", message, message.to_string());
                     // this was not the expected response, recursion!
-                    return handle_message(recvr, to_mec, last_iter).await;
+                    return handle_message(recvr, sender, to_mec, last_iter).await;
                 }
                 Message::Ping(content) => {
-                    if let Err(e) = to_mec.send(ApplicationEvent::SocketMessage(Message::Pong(content))).await {
+                    if let Err(e) = sender.send(Message::Pong(content)).await {
                         error!("Video processor could not send message to MEC, exiting: {e}");
                         return false;
                     }
                     // this was not the expected response, recursion!
-                    return handle_message(recvr, to_mec, last_iter).await;
+                    return handle_message(recvr, sender, to_mec, last_iter).await;
                 }
                 Message::Binary(bin) => {
                     let message = std::str::from_utf8(&bin);

src/main.rs

@@ -31,11 +31,19 @@ fn main() -> glib::ExitCode {
             .with_ansi(false)
             .init();
     }
-    #[cfg(debug_assertions)]
+    #[cfg(all(not(feature = "tokio-debug"), debug_assertions))]
+    {
+        let sub = tracing_subscriber::FmtSubscriber::new();
+        if let Err(e) = tracing::subscriber::set_global_default(sub) {
+            panic!("Could not set tracing global: {e}");
+        }
+    }
+    #[cfg(feature = "tokio-debug")]
     {
         console_subscriber::init();
     }
 
+
     let span = tracing::span!(Level::TRACE, "main");
     let _enter = span.enter();