✨ Add connection logic to a separate thread for independent client handling

🏗️ Refactor connection management into `ConnectionThread` class
♻️ Move connection-related code to `ConnectionThread` for background execution
⚡ Remove QTimer and replace with threading for client connection checks
🥅 Ensure tracking logic continues even if client connection is lost
🐛 Fix potential issues with client reconnection logic
🎨 Improve code structure and readability

app.py

@@ -4,9 +4,9 @@ import sys
 from datetime import datetime, timedelta
 from time import sleep
 from typing import List
-
-import sys
 import os
+import time
+import threading  # Import threading module
 
 # Add the proto directory to the Python path
 proto_dir = os.path.join(os.path.dirname(__file__), 'message_queue', 'proto')
@@ -37,9 +37,6 @@ from message_queue.proto.ConnectStatus_pb2 import ConnectStatus
 from video_streamer.gst_video_streamer import GstVideoStreamer
 import cv2
 
-import os
-import time  # Ensure time module is imported
-
 config_manager = ConfigManager('config.yaml')
 rtsp_links = config_manager.configs['rtsp_links'].get()
 debug = config_manager.configs['debug'].get()
@@ -65,41 +62,41 @@ class ConnectionTracker:
 # Create an instance of ConnectionTracker
 connection_tracker = ConnectionTracker()
 
-def check_client_connection():
+class ConnectionThread(threading.Thread):
-    if not connection_tracker.is_client_connected():
-        print("Client disconnected. Searching for another client...")
-        cl_ip, _ = start_discovery_service(12345)
-        ic(cl_ip)
-
-        # Reinitialize the Manager with the new client addressimport time  # Ensure time module is imported
-
-# Helper class to track client connection status
-class ConnectionTracker:
     def __init__(self):
-        self.last_message_time = time.time()  # Use time.time() to get the current time
+        super().__init__()
-        self.timeout = 15  # Timeout in seconds (adjust as needed)
+        self.running = True
 
-    def update_last_message_time(self):
+    def run(self):
-        self.last_message_time = time.time()  # Update with the current time
+        while self.running:
+            if not connection_tracker.is_client_connected():
+                print("Client disconnected. Searching for another client...")
+                cl_ip, _ = self.start_discovery_service(12345)
+                print(cl_ip)
 
-    def is_client_connected(self):
+                # Reinitialize the Manager with the new client address
-        return (time.time() - self.last_message_time) < self.timeout  # Use time.time()
+                global manager
+                manager = Manager(f"tcp://{cl_ip}:5558", f"tcp://{cl_ip}:5557")
+                manager.start(manager_callback)  # Restart the Manager and re-register the callback
 
-# Create an instance of ConnectionTracker
+                connection_tracker.update_last_message_time()  # Reset the timer after reconnecting
-connection_tracker = ConnectionTracker()
+            time.sleep(10)  # Check every 10 seconds
 
-def check_client_connection():
+    def start_discovery_service(self, port):
-    if not connection_tracker.is_client_connected():
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        print("Client disconnected. Searching for another client...")
+        sock.bind(('0.0.0.0', port))
-        cl_ip, _ = start_discovery_service(12345)
+        print(f"Discovery service listening on port {port}...")
-        print(cl_ip)
 
-        # Reinitialize the Manager with the new client address
+        while True:
-        global manager
+            data, addr = sock.recvfrom(1024)
-        manager = Manager(f"tcp://{cl_ip}:5558", f"tcp://{cl_ip}:5557")
+            if data.decode() == "DISCOVER_SERVER":
-        manager.start(manager_callback)  # Restart the Manager and re-register the callback
+                print(f"Received discovery request from {addr}")
+                sock.sendto(b"SERVER_RESPONSE", addr)
+                break
+        return addr
 
-        connection_tracker.update_last_message_time()  # Reset the timer after reconnecting
+    def stop(self):
+        self.running = False
 
 if __name__ == '__main__':
     QCoreApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
@@ -193,12 +190,13 @@ if __name__ == '__main__':
     core.newFrame.connect(gotNewFrame)
     core.coordsUpdated.connect(gotCoords)
 
-    # Set up the QTimer to check client connection every 10 seconds
+    # Start the connection thread
-    timer = QTimer()
+    connection_thread = ConnectionThread()
-    timer.timeout.connect(check_client_connection)
+    connection_thread.start()
-    timer.start(10000)  # 10 seconds
 
     try:
         app.exec_()
     except KeyboardInterrupt:
-        sys.exit(0)
+        connection_thread.stop()
+        connection_thread.join()
+        sys.exit(0)