qlsdk2 0.6.0a14__py3-none-any.whl → 0.7.0a1__py3-none-any.whl

qlsdk/rsc/device_manager.py

@@ -1,119 +0,0 @@
-import socket
-from typing import Optional
-from loguru import logger   
-from qlsdk.rsc.discover import UdpBroadcaster
-from threading import Thread
-from qlsdk.core import *
-from qlsdk.rsc.entity import QLDevice
-from qlsdk.rsc.proxy import DeviceProxy
-import time
-        
-        
-class DeviceContainer(object):
-    def __init__(self, proxy_enabled=False, tcp_port = 19216):
-        self._devices = {}
-        self._tcp_port = tcp_port
-        self._proxy_enabled = proxy_enabled
-        
-        # 设备搜索广播器
-        self._broadcaster = UdpBroadcaster()
-        self._broadcaster.start()
-        
-        # 监听设备连接
-        self._listening_thread = Thread(target=self._listening)
-        self._listening_thread.daemon = True
-        self._listening_thread.start()
-        
-    @property
-    def devices(self)-> QLDevice:
-        return self._devices
-    
-    '''
-        等待设备连接
-    '''
-    def connect(self, device_id: str, timeout:int=30) -> Optional[QLDevice]:        
-        logger.info(f"Searching for device: {device_id}")
-        self.add_search(device_id)
-        for _ in range(timeout):
-            device = self.get_device(device_id)
-            if device:
-                logger.success(f"Device {device_id} connected")
-                return device
-            time.sleep(1)
-        logger.error(f"Device {device_id} not found")
-        return None
-            
-    def _listening(self):
-        tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        try:
-            # 绑定到所有接口的19216端口
-            tcp_socket.bind(('0.0.0.0', self._tcp_port))
-            tcp_socket.listen(5)
-            logger.info(f"端口[{self._tcp_port}]监听服务已启动")
-
-            while True:
-                client_socket, addr = tcp_socket.accept()
-                logger.info(f"接收到来自 {addr[0]}:{addr[1]} 的连接")
-                
-                
-                # 为每个新连接创建线程处理
-                client_handler = Thread(
-                    target=self.client_handler,
-                    args=(client_socket,)
-                )
-                client_handler.daemon = True
-                client_handler.start()
-                
-        except KeyboardInterrupt:
-            logger.error(f"端口[{self._tcp_port}]监听服务异常关闭")
-        finally:
-            logger.error(f"端口[{self._tcp_port}]监听服务关闭")
-            tcp_socket.close()
-            
-    def client_handler(self, client_socket):
-                
-        if self._proxy_enabled:
-            # 启动代理  TODO: 代理的同时支持接口控制和数据转发
-            proxy = DeviceProxy(client_socket)
-            proxy.start()
-        else:            
-            # 数据监听
-            device = QLDevice(client_socket)
-            # GET_DEVICE_INFO
-            msg = GetDeviceInfoCommand.build(device).pack()
-            logger.info(f"发送获取设备信息命令: {msg.hex()}")
-            device.send(msg)
-            # 添加设备
-            while True:
-                if device.device_name:
-                    logger.info(f"设备 {device.device_name} 已连接")
-                    self.add_device(device)
-                    break
-            
-        
-    # 搜寻设备
-    def add_search(self, device_id):
-        self._broadcaster.add_device(device_id)
-        
-    def add_device(self, device: QLDevice):
-        if device is None or device.device_name is None:
-            logger.warning("无效的设备")
-            
-        self._devices.update({device.device_name: device})
-        logger.debug(f"add_device {device.device_name} then has devices {self._devices}")
-        
-        self._broadcaster.remove_device(device.device_name)
-        logger.debug(f"add_device {device.device_name} then has broadcaster {self._broadcaster}")
-        
-    def get_device(self, device_id=None)->QLDevice:
-        logger.trace(f"已连接设备数量:{len(self._devices)}")
-        if len(self._devices) == 0:
-            return None
-        
-        # 未指定device_id，返回第一个设备
-        if device_id is None:
-            return list(self._devices.values())[0]
-        
-        return self._devices.get(device_id)
-            

qlsdk/rsc/discover.py

@@ -1,87 +0,0 @@
-import socket
-import time
-from threading import Thread, Lock
-from loguru import logger
-
-from qlsdk.core.message import UDPMessage
-
-class UdpBroadcaster:
-    # 广播端口需要和ar4sdk做区分， 使用54366时不能和x8同时使用
-    def __init__(self, port=54366):
-        self.broadcast_port = port
-        self.devices_to_broadcast = []  # 待广播的设备序列号列表
-        self.connected_devices = set()  # 已连接的设备序列号集合
-        self.lock = Lock()  # 用于线程安全的锁
-        self.running = True
-
-        # 创建UDP socket
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
-
-    def add_device(self, device_id):
-        """添加设备序列号到待广播列表"""
-        with self.lock:
-            if device_id not in self.devices_to_broadcast:
-                self.devices_to_broadcast.append(device_id)
-                logger.info(f"Added device {device_id} to broadcast list.")
-
-    def remove_device(self, device_id):
-        """从待广播列表中移除设备序列号"""
-        with self.lock:
-            if device_id in self.devices_to_broadcast:
-                self.devices_to_broadcast.remove(device_id)
-                logger.info(f"Removed device {device_id} from broadcast list.")
-
-    def mark_device_as_connected(self, device_id):
-        """将设备标记为已连接，并从未广播列表中移除"""
-        with self.lock:
-            if device_id in self.devices_to_broadcast:
-                self.devices_to_broadcast.remove(device_id)
-            self.connected_devices.add(device_id)
-            logger.info(f"Device {device_id} is now connected.")
-
-    def broadcast_devices(self):
-        """轮询发送广播"""
-        while self.running:
-            with self.lock:
-                for device_id in self.devices_to_broadcast:
-                    message = UDPMessage.search(device_id)
-                    self.sock.sendto(message, ('<broadcast>', self.broadcast_port))
-                    logger.info(f"Broadcasting device ID: {device_id}")
-            time.sleep(1)  # 每隔1秒发送一次广播
-
-    def start(self):
-        """启动广播线程"""
-        self.broadcast_thread = Thread(target=self.broadcast_devices)
-        self.broadcast_thread.setDaemon(True)
-        self.broadcast_thread.start()
-
-    def stop(self):
-        """停止广播"""
-        self.running = False
-        self.broadcast_thread.join()
-        self.sock.close()
-
-# 示例使用
-if __name__ == "__main__":
-    broadcaster = UdpBroadcaster()
-
-    # 添加设备序列号到待广播列表
-    broadcaster.add_device_to_broadcast("390024130032")
-
-    # 启动广播
-    broadcaster.start()
-
-    try:
-        # 模拟运行一段时间
-        time.sleep(10)
-
-        # 标记设备为已连接
-        broadcaster.mark_device_as_connected("390024130032")
-
-        # 继续运行一段时间
-        time.sleep(10)
-
-    finally:
-        # 停止广播
-        broadcaster.stop()