【第6章 数据存储与网络】6.3 WebSocket实时通信

以下是为统信UOS设计的Kivy WebSocket实时通信完整解决方案，包含统信UOS特定优化、断线重连机制和性能调优：

---

统信UOS Kivy WebSocket实时通信指南

一、基础架构设计

1. 项目结构

myapp/
├── websocket/
│   ├── __init__.py
│   ├── client.py       # WebSocket核心客户端
│   ├── protocol.py     # 通信协议定义
│   └── uos_adapter.py  # 统信UOS适配层
└── utils/
    └── network.py      # 网络状态监测

2. 统信UOS WebSocket选型

# websocket/__init__.py
import platform

if platform.system() == 'Linux' and 'UOS' in platform.uname().version:
    # 统信UOS推荐使用经过优化的websockets库
    from websockets.sync.client import connect as ws_connect
else:
    # 其他平台使用标准websocket-client
    from websocket import create_connection as ws_connect

二、核心客户端实现

1. 带统信UOS优化的WebSocket客户端

# websocket/client.py
import threading
import time
import json
from kivy.clock import Clock
from kivy.app import App
from kivy.properties import BooleanProperty, StringProperty

class WSClient:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._init_client()
        return cls._instance
    
    def _init_client(self):
        """初始化客户端"""
        self.connected = BooleanProperty(False)
        self.status = StringProperty('disconnected')
        self._ws = None
        self._thread = None
        self._stop_event = threading.Event()
        self._reconnect_attempts = 0
        self._max_reconnect = 5
        
        # 统信UOS心跳配置
        self.heartbeat_interval = 30
        self.last_heartbeat = time.time()
        
    def connect(self, url):
        """建立WebSocket连接"""
        if self.connected:
            return
            
        self._thread = threading.Thread(
            target=self._run,
            args=(url,),
            daemon=True
        )
        self._thread.start()
    
    def _run(self, url):
        """连接主循环（在后台线程运行）"""
        while not self._stop_event.is_set() and self._reconnect_attempts < self._max_reconnect:
            try:
                # 统信UOS特殊配置
                ws_params = {
                    'ping_interval': self.heartbeat_interval,
                    'ping_timeout': 10
                }
                
                if platform.system() == 'Linux' and 'UOS' in platform.uname().version:
                    ws_params['ssl_context'] = self._get_uos_ssl_context()
                
                with ws_connect(url, **ws_params) as self._ws:
                    self._on_connected()
                    self._listen()
                    
            except Exception as e:
                self._on_error(e)
                time.sleep(min(2 ** self._reconnect_attempts, 30))  # 指数退避
                self._reconnect_attempts += 1
                
        self._on_disconnected()
    
    def _get_uos_ssl_context(self):
        """获取统信UOS SSL上下文"""
        import ssl
        ctx = ssl.create_default_context()
        ctx.load_verify_locations('/etc/UOS/certs/ca-bundle.crt')
        return ctx
    
    def _listen(self):
        """监听消息"""
        while not self._stop_event.is_set():
            try:
                message = self._ws.recv()
                self._handle_message(message)
                
                # 统信UOS下需要更频繁的心跳检测
                if time.time() - self.last_heartbeat > self.heartbeat_interval:
                    self._ws.ping()
                    self.last_heartbeat = time.time()
                    
            except Exception as e:
                self._on_error(e)
                break

三、Kivy线程安全集成

1. 主线程回调处理

class WSClient:
    # ...接上...
    
    def _on_connected(self):
        """连接成功回调（线程安全）"""
        def on_main_thread(dt):
            self.connected = True
            self.status = 'connected'
            self._reconnect_attempts = 0
            App.get_running_app().on_ws_connected()
        
        Clock.schedule_once(on_main_thread, 0)
    
    def _on_error(self, error):
        """错误处理回调"""
        def on_main_thread(dt):
            self.status = f"error: {str(error)}"
            App.get_running_app().on_ws_error(error)
        
        Clock.schedule_once(on_main_thread, 0)
    
    def _handle_message(self, message):
        """处理接收到的消息"""
        try:
            data = json.loads(message)
            
            def on_main_thread(dt):
                App.get_running_app().on_ws_message(data)
            
            Clock.schedule_once(on_main_thread, 0)
            
        except json.JSONDecodeError:
            print(f"Invalid message: {message}")

2. KV界面绑定

<ChatInterface>:
    BoxLayout:
        orientation: 'vertical'
        
        Label:
            text: app.ws_client.status
            color: 
                (0,1,0,1) if app.ws_client.connected 
                else (1,0,0,1)
        
        ScrollView:
            TextInput:
                id: chat_log
                readonly: True
                background_color: 0.9, 0.9, 0.9, 1
        
        BoxLayout:
            size_hint_y: None
            height: '50sp'
            
            TextInput:
                id: message_input
                hint_text: "输入消息..."
            
            Button:
                text: "发送"
                disabled: not app.ws_client.connected
                on_press: app.send_message(message_input.text)

四、统信UOS特定优化

1. 网络状态监测集成

# utils/network.py
import dbus
from threading import Thread

class UOSNetworkMonitor:
    def __init__(self, ws_client):
        self.ws_client = ws_client
        self._thread = Thread(target=self._monitor, daemon=True)
        self._thread.start()
    
    def _monitor(self):
        """监测统信UOS网络状态变化"""
        bus = dbus.SystemBus()
        proxy = bus.get_object('com.uniontech.network', '/')
        iface = dbus.Interface(proxy, 'com.uniontech.network.manager')
        
        # 监听网络状态信号
        iface.connect_to_signal('StatusChanged', self._handle_network_change)
        
        # 初始状态
        self._handle_network_change(iface.GetStatus())
    
    def _handle_network_change(self, is_connected):
        """处理网络状态变化"""
        if is_connected and not self.ws_client.connected:
            self.ws_client.connect("wss://api.example.com/ws")
        elif not is_connected:
            self.ws_client.disconnect()

2. 电源管理集成

# websocket/uos_adapter.py
import dbus

class UOSPowerManager:
    def __init__(self, ws_client):
        self.ws_client = ws_client
        bus = dbus.SessionBus()
        proxy = bus.get_object('com.uniontech.power', '/')
        self.iface = dbus.Interface(proxy, 'com.uniontech.power.manager')
        self.iface.connect_to_signal('PowerSaveChanged', self._on_power_save)
    
    def _on_power_save(self, enabled):
        """省电模式切换处理"""
        if enabled:
            # 统信UOS进入省电模式时降低心跳频率
            self.ws_client.heartbeat_interval = 60
        else:
            self.ws_client.heartbeat_interval = 30

五、完整应用示例

1. 应用主类集成

# main.py
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from websocket.client import WSClient
from utils.network import UOSNetworkMonitor

class ChatApp(App):
    def build(self):
        self.ws_client = WSClient()
        self.ws_client.connect("wss://api.example.com/ws")
        
        # 统信UOS网络监测
        if platform.system() == 'Linux' and 'UOS' in platform.uname().version:
            self.monitor = UOSNetworkMonitor(self.ws_client)
        
        return ChatInterface()
    
    def on_ws_connected(self):
        print("WebSocket connected")
    
    def on_ws_message(self, data):
        root = self.root
        root.ids.chat_log.text += f"\n{data['user']}: {data['message']}"
    
    def send_message(self, text):
        if text.strip() and self.ws_client.connected:
            self.ws_client.send({
                'type': 'message',
                'content': text
            })
            self.root.ids.message_input.text = ''

class ChatInterface(BoxLayout):
    pass

2. 消息协议设计

# websocket/protocol.py
class WSProtocol:
    @staticmethod
    def encode_message(msg_type, **kwargs):
        """编码发送消息"""
        return json.dumps({
            'type': msg_type,
            'timestamp': int(time.time()),
            'data': kwargs
        })
    
    @staticmethod
    def decode_message(message):
        """解码接收消息"""
        data = json.loads(message)
        return {
            'type': data['type'],
            'data': data.get('data', {})
        }

六、高级功能实现

1. 断线自动恢复

class WSClient:
    # ...接上...
    
    def _start_reconnect_timer(self):
        """启动断线重连定时器"""
        if not hasattr(self, '_reconnect_timer'):
            self._reconnect_timer = Clock.schedule_interval(
                self._try_reconnect, 
                5  # 每5秒尝试一次
            )
    
    def _try_reconnect(self, dt):
        """尝试重新连接"""
        if self.connected or self._reconnect_attempts >= self._max_reconnect:
            self._reconnect_timer.cancel()
            del self._reconnect_timer
            return
            
        self.connect(self._current_url)

2. 消息队列（离线支持）

class MessageQueue:
    def __init__(self, max_size=100):
        self._queue = []
        self._max_size = max_size
    
    def add(self, message):
        """添加消息到队列"""
        if len(self._queue) >= self._max_size:
            self._queue.pop(0)
        self._queue.append(message)
    
    def flush(self, ws_client):
        """尝试发送队列中的所有消息"""
        while self._queue:
            if not ws_client.connected:
                break
            message = self._queue.pop(0)
            ws_client.send(message)

七、性能优化建议

1. 统信UOS专用优化：

   # 在统信UOS上启用TCP快速路径
   if 'UOS' in platform.uname().version:
       import socket
       socket.TCP_QUICKACK = 1
       socket.TCP_NODELAY = 1
   

2. 消息压缩：

   # websocket/client.py
   def send(self, data):
       """发送压缩消息（统信UOS下自动启用）"""
       message = json.dumps(data)
       
       if platform.system() == 'Linux' and 'UOS' in platform.uname().version:
           import zlib
           message = zlib.compress(message.encode())
       
       self._ws.send(message)
   

3. 批量消息处理：

   class BatchProcessor:
       def __init__(self, ws_client, batch_size=10, interval=0.5):
           self.ws_client = ws_client
           self.batch_size = batch_size
           self.buffer = []
           Clock.schedule_interval(self._process, interval)
       
       def add(self, message):
           self.buffer.append(message)
           if len(self.buffer) >= self.batch_size:
               self._process()
       
       def _process(self, dt=None):
           if self.buffer:
               batch = {
                   'type': 'batch',
                   'messages': self.buffer[:self.batch_size]
               }
               self.ws_client.send(batch)
               self.buffer = self.buffer[self.batch_size:]
   

---

关键问题解决方案

1. 统信UOS证书验证失败：

   # 更新统信UOS证书链
   sudo update-ca-certificates --fresh
   

2. WebSocket连接被系统中断：

   # 统信UOS电源管理白名单
   def add_to_power_whitelist():
       try:
           import dbus
           bus = dbus.SessionBus()
           proxy = bus.get_object('com.uniontech.power', '/')
           iface = dbus.Interface(proxy, 'com.uniontech.power.manager')
           iface.AddWhitelist("myapp-websocket")
       except:
           pass
   

3. 高延迟下的消息排序：

   class OrderedMessageQueue:
       def __init__(self):
           self._seq = 0
           self._pending = {}
       
       def add(self, message):
           self._seq += 1
           self._pending[self._seq] = message
           return self._seq
       
       def ack(self, seq_num):
           self._pending.pop(seq_num, None)
       
       def resend_pending(self, ws_client):
           for seq, msg in self._pending.items():
               ws_client.send({'resend': seq, **msg})
   

4. 统信UOS防火墙配置：

   # 添加WebSocket端口例外
   sudo ufw allow 443/tcp comment "WebSocket for MyApp"
   

通过以上实现，您的Kivy应用可以在统信UOS上建立稳定、高效的WebSocket通信，同时完美适配统信UOS的系统特性和安全要求。