feat(unity): handle initial compile errors and first message detection

Add handling for initial compile errors before connection to Unity is established. Track first message received to trigger initial compile error request. This ensures we capture all compile errors even before full connection is established.

Author: hackerzhuli

src/unity_manager.rs

@@ -258,6 +258,26 @@ impl UnityManager {
                                     }
                                 });
                             }
+                            UnityEvent::CompileErrors(log_container) => {
+                                // Handle initial compile errors from Unity
+                                // If we never received compile finish events
+                                // then this is the initial compile errors before we connect to Unity
+                                if let Ok(mut last_compilation_finished_guard) = last_compilation_finished.lock() {
+                                    if last_compilation_finished_guard.is_none() {
+                                        if let Ok(mut compile_errors_guard) = last_compile_errors.lock() {
+                                            compile_errors_guard.clear();
+                                            for log in &log_container.logs {
+                                                let main_message = extract_main_message(&log.message);
+                                                compile_errors_guard.push(main_message);
+                                            }
+                                            debug_log!("Initial compile errors received from Unity: {} errors", compile_errors_guard.len());
+                                        }
+
+                                        // compile didn't happen just now, but we can use now as a fake compile time, it's ok
+                                        *last_compilation_finished_guard = Some(SystemTime::now());
+                                    }
+                                }
+                            }
                             _ => {}
                         }
                     }
@@ -299,15 +319,6 @@ impl UnityManager {
         }
     }
 
-    /// Get the timestamp of the last compilation finished event
-    pub fn get_last_compilation_finished(&self) -> Option<SystemTime> {
-        if let Ok(compilation_guard) = self.last_compilation_finished.lock() {
-            *compilation_guard
-        } else {
-            None
-        }
-    }
-
     /// Get the compile errors from the last compilation
     pub fn get_last_compile_errors(&self) -> Vec<String> {
         if let Ok(compile_errors_guard) = self.last_compile_errors.lock() {

src/unity_messaging_client.rs

@@ -31,6 +31,8 @@ pub struct UnityMessagingClient {
     last_compilation_finished: Arc<Mutex<Option<SystemTime>>>,
     /// Compile errors collected after compilation finishes
     last_compile_errors: Arc<Mutex<Vec<String>>>,
+    /// Whether we have received the first message from Unity (used to trigger initial GetCompileErrors)
+    first_message_received: Arc<Mutex<bool>>,
 }
 
 impl UnityMessagingClient {
@@ -66,6 +68,7 @@ impl UnityMessagingClient {
             is_in_play_mode: Arc::new(Mutex::new(false)),
             last_compilation_finished: Arc::new(Mutex::new(None)),
             last_compile_errors: Arc::new(Mutex::new(Vec::new())),
+            first_message_received: Arc::new(Mutex::new(false)),
         })
     }
 
@@ -91,8 +94,7 @@ impl UnityMessagingClient {
         let is_online = self.is_online.clone();
         let current_test_run_id = self.current_test_run_id.clone();
         let is_in_play_mode = self.is_in_play_mode.clone();
-        let last_compilation_finished = self.last_compilation_finished.clone();
-        let last_compile_errors = self.last_compile_errors.clone();
+        let first_message_received = self.first_message_received.clone();
 
         // Spawn background task for message listening
         let task = tokio::spawn(async move {
@@ -103,7 +105,8 @@ impl UnityMessagingClient {
                 last_response_time,
                 is_online,
                 current_test_run_id,
-                is_in_play_mode
+                is_in_play_mode,
+                first_message_received
             )
             .await;
         });
@@ -163,6 +166,7 @@ impl UnityMessagingClient {
         is_online: Arc<Mutex<bool>>,
         current_test_run_id: Arc<Mutex<Option<String>>>,
         is_in_play_mode: Arc<Mutex<bool>>,
+        first_message_received: Arc<Mutex<bool>>,
     ) {
         let mut buffer = [0u8; 8192];
         let mut ping_interval = tokio::time::interval(Duration::from_secs(1));
@@ -196,6 +200,24 @@ impl UnityMessagingClient {
                                     info_log!("Unity {:?}: {}", message.message_type, message.value);
                                 }
 
+                                let mut just_received_first_message = false;
+                                // Check if this is the first message from Unity (excluding Ping/Pong)
+                                if let Ok(mut first_received) = first_message_received.lock() {
+                                    if !*first_received {
+                                        *first_received = true;
+                                        debug_log!("First message received from Unity, requesting initial compile errors");
+                                        just_received_first_message = true;
+                                    }
+                                }
+                                
+                                if just_received_first_message {
+                                    // Send GetCompileErrors request to get initial compile errors
+                                    let get_compile_errors_message = Message::new(MessageType::GetCompileErrors, String::new());
+                                    if let Err(e) = socket.send_to(&get_compile_errors_message.serialize(), unity_address).await {
+                                        error_log!("Failed to send initial GetCompileErrors request: {}", e);
+                                    }
+                                }
+
                                 // Update last response time for any valid message
                                 if let Ok(mut time) = last_response_time.lock() {
                                     *time = Some(std::time::Instant::now());