sensor-sdk 0.2.0__tar.gz → 0.2.2__tar.gz

{sensor_sdk-0.2.0/sensor_sdk.egg-info → sensor_sdk-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor_sdk-0.2.0 → sensor_sdk-0.2.2}/sensor/bleak_no_ack_patch.py

@@ -3,7 +3,7 @@
 某些 Windows 主机上 write-with-response 会因为系统 ACK 等待导致命令超时，
 把命令特征强制改成无响应写入可以显著提升命令通道的实时性。
 
-默认只作用于 SDK 已知的两个 CMD 特征 UUID；传入空列表或 `None` 则全局生效。
+默认只作用于 SDK 已知的两个 CMD 特征 UUID；传 `None` 则全局生效，空列表表示不匹配任何特征。
 """
 
 import logging
@@ -53,6 +53,7 @@ def apply(cmd_char_uuids=DEFAULT_CMD_CHAR_UUIDS):
         return await orig_write(self, char_specifier, data, response=response)
 
     BleakClient.write_gatt_char = patched_write
+    BleakClient._orig_write_gatt_char = orig_write  # type: ignore[attr-defined]
     BleakClient._no_ack_patched = True  # type: ignore[attr-defined]
     logger.debug(
         "Applied bleak write-without-response patch (targets: %s)",
@@ -70,6 +71,8 @@ def reset():
     if not getattr(BleakClient, "_no_ack_patched", False):
         return
 
-    # 找到原始的未绑定方法比较麻烦，这里简单把标记清掉，
-    # 实际撤销需要保存原始方法；apply 没有保存，故 reset 仅作占位。
+    orig_write = getattr(BleakClient, "_orig_write_gatt_char", None)
+    if orig_write is not None:
+        BleakClient.write_gatt_char = orig_write
+        del BleakClient._orig_write_gatt_char  # type: ignore[attr-defined]
     BleakClient._no_ack_patched = False  # type: ignore[attr-defined]

{sensor_sdk-0.2.0 → sensor_sdk-0.2.2}/sensor/bleak_process.py

@@ -25,6 +25,20 @@ OYM_DATA_NOTIFY_CHAR_UUID = "f000ffe2-0451-4000-b000-000000000000"
 RFSTAR_CMD_UUID = "00000002-0000-1000-8000-00805f9b34fb"
 RFSTAR_DATA_UUID = "00000003-0000-1000-8000-00805f9b34fb"
 
+# 异常断开后自动重连参数
+_MAX_RECONNECT_ATTEMPTS = 5
+_RECONNECT_DELAY_SECONDS = 1.0
+
+
+def _is_core_bluetooth(client) -> bool:
+    """判断 bleak 当前是否使用 macOS CoreBluetooth 后端。"""
+    if client is None:
+        return False
+    backend = getattr(client, "_backend", None)
+    if backend is None:
+        return False
+    return "corebluetooth" in type(backend).__module__.lower()
+
 
 def _extract_mac(_device: bleak.BLEDevice, adv: AdvertisementData) -> str:
 
@@ -93,6 +107,9 @@ class BleakProcess(multiprocessing.Process):
         self._power_intervals: dict = {}  # mac -> int (ms)
         self._data_tasks: dict = {}       # mac -> asyncio.Task
         self._battery_tasks: dict = {}    # mac -> asyncio.Task
+        self._reconnect_info: dict = {}   # mac -> {cmd, attempts, task, normal_disconnect}
+        self._restore_info: dict = {}     # mac -> {package_sample_count, power_refresh_interval, streaming}
+        self._main_event_loop = None      # BleakProcess 主事件循环
 
         # Per-device event loops and threads
         self._event_loops: dict = {}      # mac -> asyncio.AbstractEventLoop
@@ -344,6 +361,7 @@ class BleakProcess(multiprocessing.Process):
         self._msg_queue = queue.Queue()
 
         async def _run_main():
+            self._main_event_loop = asyncio.get_running_loop()
             publisher_task = asyncio.create_task(self._publisher_task())
             try:
                 await self._main_loop()
@@ -581,6 +599,14 @@ class BleakProcess(multiprocessing.Process):
         name = cmd.get("name", "")
         service_data = cmd.get("service_data", {})
 
+        # 保存连接信息，用于异常断开后自动重连
+        self._reconnect_info[device_mac] = {
+            "cmd": cmd,
+            "attempts": 0,
+            "task": None,
+            "normal_disconnect": False,
+        }
+
         event_loop = self._event_loops.get(device_mac)
         gforce_event_loop = self._gforce_event_loop
         data_event_loop = self._data_event_loops.get(device_mac)
@@ -676,8 +702,18 @@ class BleakProcess(multiprocessing.Process):
         self._raw_bufs[device_mac] = raw_buf
         self._device_states[device_mac] = "Connected"
 
+        # 重连成功，重置重连计数
+        reconnect_info = self._reconnect_info.get(device_mac)
+        if reconnect_info is not None:
+            reconnect_info["attempts"] = 0
+
         # Create data context
-        data_ctx = SensorProfileDataCtx(gforce, device_mac, raw_buf)
+        data_ctx = SensorProfileDataCtx(
+            gforce,
+            device_mac,
+            raw_buf,
+            on_reconnect_request=lambda: self._schedule_reconnect(device_mac),
+        )
         self._data_ctxs[device_mac] = data_ctx
 
         # Start data processing loop in data_event_loop
@@ -705,6 +741,19 @@ class BleakProcess(multiprocessing.Process):
             if device_mac not in self._gforces and not disconnect_client:
                 return  # Already cleaned
 
+            # 用户主动断开时标记为正常断开，并取消正在进行的自动重连
+            if disconnect_client:
+                info = self._reconnect_info.get(device_mac)
+                if info is not None:
+                    info["normal_disconnect"] = True
+                    task = info.get("task")
+                    if task is not None:
+                        try:
+                            task.cancel()
+                        except Exception:
+                            pass
+                        info["task"] = None
+
             # Cancel data task (running in data_event_loop)
             if device_mac in self._data_tasks:
                 task = self._data_tasks.pop(device_mac, None)
@@ -750,8 +799,63 @@ class BleakProcess(multiprocessing.Process):
             self._raw_bufs.pop(device_mac, None)
             self._device_states[device_mac] = "Disconnected"
 
+            # 正常断开后清理重连信息；异常断开保留以继续自动重连
+            if disconnect_client:
+                self._reconnect_info.pop(device_mac, None)
+
         self._publish("state_changed", device_mac=device_mac, state="Disconnected")
 
+    def _schedule_reconnect(self, device_mac: str):
+        """从 watchdog 线程调用，调度一次自动重连。"""
+        info = self._reconnect_info.get(device_mac)
+        if info is None or info.get("normal_disconnect"):
+            return
+        if info.get("task") is not None:
+            return  # 已有重连任务在进行
+        if info["attempts"] >= _MAX_RECONNECT_ATTEMPTS:
+            SdkLog.e(_TAG, f"Max reconnect attempts reached for {device_mac}")
+            return
+
+        info["attempts"] += 1
+        SdkLog.i(_TAG, f"Scheduling reconnect attempt {info['attempts']} for {device_mac}")
+
+        loop = self._main_event_loop
+        if loop is None or loop.is_closed():
+            SdkLog.e(_TAG, f"Main event loop not available, cannot reconnect {device_mac}")
+            return
+
+        async def _delayed_reconnect():
+            await asyncio.sleep(_RECONNECT_DELAY_SECONDS)
+            await self._do_reconnect(device_mac)
+
+        try:
+            info["task"] = asyncio.run_coroutine_threadsafe(_delayed_reconnect(), loop)
+        except Exception as e:
+            SdkLog.exception(_TAG, f"Failed to schedule reconnect for {device_mac}: {e}")
+            info["task"] = None
+
+    async def _do_reconnect(self, device_mac: str):
+        """执行一次自动重连。"""
+        info = self._reconnect_info.get(device_mac)
+        if info is None or info.get("normal_disconnect"):
+            return
+
+        # 已经连接则无需重连
+        if device_mac in self._gforces:
+            info["task"] = None
+            return
+
+        SdkLog.i(_TAG, f"Reconnecting {device_mac}, attempt {info['attempts']}")
+        try:
+            await self._do_connect(info["cmd"])
+        except Exception as e:
+            SdkLog.exception(_TAG, f"Reconnect attempt failed for {device_mac}: {e}")
+            # 失败后会再次由 _schedule_reconnect 决定是否继续
+            self._schedule_reconnect(device_mac)
+        finally:
+            if info is not None:
+                info["task"] = None
+
     async def _do_disconnect(self, cmd: dict):
 
         device_mac = cmd["device_mac"]
@@ -1160,6 +1264,8 @@ class BleakProcess(multiprocessing.Process):
 
         result = "Error: Not supported"
         needs_restart = False
+        oym_needs_subscribe = False
+        was_streaming = ctx.isDataTransfering
 
         ntf_keys = [
             "NTF_GEST", "NTF_EMG", "NTF_EEG", "NTF_ECG", "NTF_IMU", "NTF_BRTH", "NTF_IMPEDANCE",
@@ -1220,14 +1326,19 @@ class BleakProcess(multiprocessing.Process):
                         except Exception as e:
                             SdkLog.exception(_TAG, f"_do_set_param set_function_switch failed: {device_mac}")
                             result = "ERROR: set_function_switch fail: " + str(e)
-                    elif ctx.isDataTransfering:
+                        if ctx.getChipType() == BLEChipType.OYM:
+                            oym_needs_subscribe = True
+                    elif was_streaming:
                         needs_restart = True
                         if ctx.getChipType() == BLEChipType.OYM:
-                            try:
-                                await ctx.gForce.set_subscription(ctx.notifyDataFlag)
-                            except Exception as e:
-                                SdkLog.exception(_TAG, f"_do_set_param set_subscription failed: {device_mac}")
-                                result = "ERROR: set_subscription fail: " + str(e)
+                            oym_needs_subscribe = True
+                    elif ctx.getChipType() == BLEChipType.OYM:
+                        # 未在传输时，直接更新 OYM 订阅掩码
+                        try:
+                            await ctx.gForce.set_subscription(ctx.notifyDataFlag)
+                        except Exception as e:
+                            SdkLog.exception(_TAG, f"_do_set_param set_subscription failed: {device_mac}")
+                            result = "ERROR: set_subscription fail: " + str(e)
 
         if key in ["FILTER_50HZ", "FILTER_60HZ", "FILTER_HPF", "FILTER_LPF"]:
             if value in ["ON", "OFF"]:
@@ -1239,13 +1350,28 @@ class BleakProcess(multiprocessing.Process):
                     SdkLog.exception(_TAG, f"_do_set_param setFilter failed: {device_mac} {key}={value}")
                     result = "ERROR: " + str(e)
 
-        if needs_restart:
+        if needs_restart or oym_needs_subscribe:
             try:
-                await ctx.stop_streaming()
-                await ctx.start_streaming()
+                is_oym = ctx.getChipType() == BLEChipType.OYM
+                # macOS CoreBluetooth 在流传输中 stop_notify 容易导致设备断开，
+                # 因此 OYM 设备在 CoreBluetooth 后端上直接更新订阅掩码，不启停通知。
+                oym_skip_stop_start = is_oym and _is_core_bluetooth(ctx.gForce.client)
+                if oym_skip_stop_start:
+                    SdkLog.d(_TAG, f"OYM CoreBluetooth: skip stop/start, set subscription directly for {device_mac}")
+                if was_streaming and not oym_skip_stop_start:
+                    await ctx.stop_streaming()
+                if oym_needs_subscribe and is_oym:
+                    await ctx.gForce.set_subscription(ctx.notifyDataFlag)
+                if was_streaming and not oym_skip_stop_start:
+                    await ctx.start_streaming()
             except Exception as e:
+                err_msg = str(e)
                 SdkLog.exception(_TAG, f"_do_set_param restart stream failed: {device_mac}")
-                result = "ERROR: restart stream fail: " + str(e)
+                result = "ERROR: restart stream fail: " + err_msg
+                # 如果是因为设备已经断开，直接触发自动重连
+                if "disconnected" in err_msg.lower() or "not connected" in err_msg.lower():
+                    SdkLog.w(_TAG, f"Device disconnected during setParam restart, scheduling reconnect for {device_mac}")
+                    self._schedule_reconnect(device_mac)
 
         if key == "DEBUG_LOG_PATH":
             try:

{sensor_sdk-0.2.0 → sensor_sdk-0.2.2}/sensor/gforce.py

@@ -2,6 +2,7 @@ import asyncio
 import queue
 import struct
 import platform
+import time
 from contextlib import suppress
 from datetime import datetime
 from dataclasses import dataclass
@@ -453,6 +454,8 @@ class GForce:
         self.cmd_char = cmd_char
         self.data_char = data_char
         self.responses: Dict[Command, queue.Queue] = {}
+        self.last_command_failure_time: Optional[float] = None
+        self.last_command_failure_cmd: Optional[int] = None
         self.resolution = SampleResolution.BITS_8
         self._num_channels = 8
         self._device = device
@@ -1091,6 +1094,8 @@ class GForce:
                 timeout=2
             )
         except Exception as e:
+            self.last_command_failure_time = time.time()
+            self.last_command_failure_cmd = req.cmd
             SdkLog.exception(_TAG, f"_send_request write_gatt_char failed: {req.cmd}")
             if req.has_res:
                 self.responses[req.cmd] = None

{sensor_sdk-0.2.0 → sensor_sdk-0.2.2}/sensor/sensor_data_context.py

@@ -9,7 +9,7 @@ import struct
 import math
 import threading
 import time
-from typing import Deque, List
+from typing import Deque, List, Optional
 from concurrent.futures import ThreadPoolExecutor
 import csv
 from sensor import sensor_utils
@@ -30,6 +30,8 @@ QUAT_SCALE = 1 / 1073741824.0  # 2^30
 _MAX_CONCAT_BUFFER_SIZE = 64 * 1024  # 64KB
 # data 日志队列最大长度，写盘跟不上时丢弃日志而不是阻塞解析线程
 _DATA_LOG_QUEUE_MAXSIZE = 1000
+# 包序号最大允许跳变值，超过视为非法跳变/丢包
+_MAX_ALLOWED_PACKAGE_INDEX_DELTA = 100
 
 class SensorDataType(IntEnum):
     DATA_TYPE_EEG = 0
@@ -83,7 +85,13 @@ class ReadSamplesResult(IntEnum):
 
 
 class SensorProfileDataCtx:
-    def __init__(self, gForce: GForce, deviceMac: str, buf: Queue[bytes]):
+    def __init__(
+        self,
+        gForce: GForce,
+        deviceMac: str,
+        buf: Queue[bytes],
+        on_reconnect_request: Optional[callable] = None,
+    ):
         self.featureMap = 0
         self.notifyDataFlag: DataSubscription = 0
 
@@ -150,6 +158,15 @@ class SensorProfileDataCtx:
         self._watchdog_thread.daemon = True
         self._watchdog_thread.start()
 
+        # 非法跳变监控：持续超过阈值则重启数据通知
+        self._illegal_jump_start_time: Optional[float] = None
+        self._is_restarting_stream = False
+
+        # 命令失败导致异常断开后自动重连
+        self._on_reconnect_request = on_reconnect_request
+        self._disconnected_start_time: Optional[float] = None
+        self._reconnect_requested = False
+
     def close(self):
         self._is_running = False
         if self.debugCSVWriter != None:
@@ -188,10 +205,28 @@ class SensorProfileDataCtx:
                 pass
             self._watchdog_thread = None
 
+    async def _restart_streaming(self):
+        """非法跳变持续时重启数据通知。"""
+        if self._is_restarting_stream:
+            return
+        self._is_restarting_stream = True
+        try:
+            SdkLog.w(_TAG, f"Illegal package index jump persisted > 5s, restarting data notification for {self.deviceMac}")
+            await self.stop_streaming()
+            await self.start_streaming(self._rawDataBuffer)
+            self._illegal_jump_start_time = None
+        except Exception as e:
+            SdkLog.exception(_TAG, f"Restart streaming failed for {self.deviceMac}: {e}")
+        finally:
+            self._is_restarting_stream = False
+
     def _watchdog_loop(self):
         """守护线程：监控解析线程进度，防止卡死后内存无限增长。"""
         WATCHDOG_INTERVAL = 1.0  # 检查间隔
         WATCHDOG_TIMEOUT = 5.0   # 无进度报警阈值
+        ILLEGAL_JUMP_TIMEOUT = 5.0  # 非法跳变持续阈值
+        RECONNECT_AFTER_DISCONNECT = 3.0  # 断开后等待多久尝试重连
+        RECENT_CMD_FAILURE_WINDOW = 30.0  # 命令失败多久内视为相关
         RAW_BUF_CLEAR_THRESHOLD = 1500  # 超过此值且无进度时清空
 
         while not self._watchdog_stop_event.is_set():
@@ -229,6 +264,46 @@ class SensorProfileDataCtx:
                         self._concatDataBuffer.clear()
                         # 清空后更新时间戳，避免持续报警
                         self._last_progress_time = time.time()
+
+                # 非法跳变持续超过阈值则重启数据通知
+                if (self._illegal_jump_start_time is not None
+                        and not self._is_restarting_stream
+                        and self.isDataTransfering):
+                    jump_elapsed = time.time() - self._illegal_jump_start_time
+                    if jump_elapsed > ILLEGAL_JUMP_TIMEOUT:
+                        SdkLog.w(_TAG, f"Illegal jump persisted for {jump_elapsed:.1f}s, restarting stream for {self.deviceMac}")
+                        try:
+                            asyncio.run_coroutine_threadsafe(
+                                self._restart_streaming(), self.gForce.gforce_event_loop
+                            )
+                        except Exception as e:
+                            SdkLog.exception(_TAG, f"Failed to schedule stream restart for {self.deviceMac}: {e}")
+
+                # 命令失败后设备异常断开，触发自动重连
+                if self._on_reconnect_request is not None:
+                    client = getattr(self.gForce, "client", None)
+                    is_connected = getattr(client, "is_connected", False) if client is not None else False
+                    if is_connected:
+                        self._disconnected_start_time = None
+                        self._reconnect_requested = False
+                    else:
+                        if self._disconnected_start_time is None:
+                            self._disconnected_start_time = time.time()
+                        disconnected_elapsed = time.time() - self._disconnected_start_time
+                        cmd_fail_time = getattr(self.gForce, "last_command_failure_time", None)
+                        recent_cmd_failure = (
+                            cmd_fail_time is not None
+                            and (time.time() - cmd_fail_time) < RECENT_CMD_FAILURE_WINDOW
+                        )
+                        if (disconnected_elapsed > RECONNECT_AFTER_DISCONNECT
+                                and recent_cmd_failure
+                                and not self._reconnect_requested):
+                            SdkLog.w(_TAG, f"Device disconnected after command failure, scheduling reconnect for {self.deviceMac}")
+                            self._reconnect_requested = True
+                            try:
+                                self._on_reconnect_request()
+                            except Exception as e:
+                                SdkLog.exception(_TAG, f"Reconnect request failed for {self.deviceMac}: {e}")
             except Exception as e:
                 SdkLog.exception(_TAG, f"Watchdog error: {e}")
 
@@ -408,6 +483,15 @@ class SensorProfileDataCtx:
         self.sensorDatas[SensorDataType.DATA_TYPE_EMG] = data
         self.isNewEMG = isNewEMG
 
+        # 新 EMG + OYM 芯片：默认只开 EMG，关闭 Gesture 和 IMU
+        if isNewEMG and self._chip_type == BLEChipType.OYM:
+            self.notify_map["NTF_GEST"] = "OFF"
+            self.notify_map["NTF_IMU"] = "OFF"
+            self.notify_map["NTF_GFORCE_ACC"] = "OFF"
+            self.notify_map["NTF_GFORCE_GYRO"] = "OFF"
+            self.notify_map["NTF_GFORCE_QUAT"] = "OFF"
+            self.notify_map["NTF_GFORCE_EULER"] = "OFF"
+
         # 老 EMG 设备不支持 FILTER
         if not isNewEMG:
             self.filter_map.clear()
@@ -630,7 +714,9 @@ class SensorProfileDataCtx:
             data.clear()
             self.sensorDatas[SensorDataType.DATA_TYPE_EULER] = data
 
-        self.notifyDataFlag |= DataSubscription.DNF_IMU
+        # EEG + OYM 设备默认不订阅 IMU
+        if not (self._chip_type == BLEChipType.OYM and self.hasEEG()):
+            self.notifyDataFlag |= DataSubscription.DNF_IMU
         if self._device_info is not None:
             self._device_info.AccChannelCount = 3
             self._device_info.GyroChannelCount = 3
@@ -786,6 +872,14 @@ class SensorProfileDataCtx:
             self._device_info = info
             await self.initDataTransfer(True)
 
+            # EEG + OYM 设备默认关闭 IMU
+            if self._chip_type == BLEChipType.OYM and self.hasEEG():
+                self.notify_map["NTF_IMU"] = "OFF"
+                self.notify_map["NTF_GFORCE_ACC"] = "OFF"
+                self.notify_map["NTF_GFORCE_GYRO"] = "OFF"
+                self.notify_map["NTF_GFORCE_QUAT"] = "OFF"
+                self.notify_map["NTF_GFORCE_EULER"] = "OFF"
+
             if self.hasConcatBLE():
                 self.notifyDataFlag |= DataSubscription.DNF_CONCAT_BLE
 
@@ -1489,6 +1583,7 @@ class SensorProfileDataCtx:
                 if newPackageIndex <= 2 and lastPackageIndex >= maxPackageIndex - 2:
                     packageIndex = maxPackageIndex + 1 + newPackageIndex
                 elif newPackageIndex == lastPackageIndex:
+                    self._illegal_jump_start_time = None
                     return ReadSamplesResult.Repeated
                 elif newPackageIndex < lastPackageIndex:
                     SdkLog.i(_TAG, (
@@ -1498,10 +1593,12 @@ class SensorProfileDataCtx:
                         + "|CURR_IDX|" + str(newPackageIndex)
                         + "|DELTA|" + str(lastPackageIndex - newPackageIndex)
                     ))
+                    if self._illegal_jump_start_time is None:
+                        self._illegal_jump_start_time = time.time()
                     return ReadSamplesResult.Error
 
                 deltaPackageIndex = packageIndex - lastPackageIndex
-                if deltaPackageIndex > 20:
+                if deltaPackageIndex > _MAX_ALLOWED_PACKAGE_INDEX_DELTA:
                     SdkLog.i(_TAG, (
                         "Illegal package index jump|MAC|" + str(sensorData.deviceMac)
                         + "|TYPE|" + str(sensorData.dataType)
@@ -1509,6 +1606,8 @@ class SensorProfileDataCtx:
                         + "|CURR_IDX|" + str(newPackageIndex)
                         + "|DELTA|" + str(deltaPackageIndex)
                     ))
+                    if self._illegal_jump_start_time is None:
+                        self._illegal_jump_start_time = time.time()
                     return ReadSamplesResult.Error
 
                 lostPackageCounter = deltaPackageIndex - 1
@@ -1522,7 +1621,7 @@ class SensorProfileDataCtx:
                         + "|COUNT|" + str(lostSampleCount)
                     ))
 
-                    if lostPackageCounter < 20:
+                    if lostPackageCounter < _MAX_ALLOWED_PACKAGE_INDEX_DELTA:
                         self.readSamples(data, sensorData, 0, dataGap, lostSampleCount)
 
                     sensorData.lastPackageIndex = newPackageIndex - 1
@@ -1534,6 +1633,7 @@ class SensorProfileDataCtx:
                 self.readSamples(data, sensorData, dataOffset, dataGap, 0)
 
             sensorData.lastPackageCounter += 1
+            self._illegal_jump_start_time = None
         except Exception as e:
             SdkLog.exception(_TAG, "Unexpected error")
             return ReadSamplesResult.Error

{sensor_sdk-0.2.0 → sensor_sdk-0.2.2}/sensor/sensor_profile.py

@@ -93,6 +93,11 @@ class SensorProfile:
         self._device_info: Optional[DeviceInfo] = None
         self._chip_type: BLEChipType = BLEChipType.Unknown
 
+        # 异常断开后自动恢复流状态所需信息
+        self._last_init_args: Optional[tuple] = None  # (packageSampleCount, powerRefreshInterval)
+        self._was_streaming_before_disconnect = False
+        self._auto_restoring = False
+
         # 用于在独立线程中执行用户回调，避免阻塞 BLE/数据解析线程
         # onDataCallback 使用单线程池，保证数据回调严格按到达顺序执行
         self._callback_executor = ThreadPoolExecutor(max_workers=4)
@@ -222,7 +227,8 @@ class SensorProfile:
         return self._device_state
 
     def _set_device_state(self, newState: DeviceStateEx):
-        if self._device_state != newState:
+        old_state = self._device_state
+        if old_state != newState:
             self._device_state = newState
             if newState == DeviceStateEx.Disconnected:
                 self._has_inited = False
@@ -235,6 +241,33 @@ class SensorProfile:
                     SdkLog.e(_TAG, f"Error occurred while processing state change: {e}")
                     raise RuntimeError("Set device state %s fail: %s" % (self.BLEDevice.Name , e))
 
+            # 异常断开后重连成功，自动恢复 init + 数据流
+            if (newState == DeviceStateEx.Connected
+                    and old_state == DeviceStateEx.Disconnected
+                    and self._last_init_args is not None
+                    and self._was_streaming_before_disconnect
+                    and not self._auto_restoring):
+                SdkLog.i(_TAG, f"Auto-restoring stream state for {self._device_mac}")
+                threading.Thread(target=self._auto_restore, daemon=True).start()
+
+    def _auto_restore(self):
+        """在异常断开后自动恢复 init 和数据流。"""
+        if self._auto_restoring:
+            return
+        self._auto_restoring = True
+        try:
+            package_sample_count, power_refresh_interval = self._last_init_args
+            SdkLog.i(_TAG, f"Auto-restore init for {self._device_mac}")
+            if self.init(package_sample_count, power_refresh_interval):
+                SdkLog.i(_TAG, f"Auto-restore start data notification for {self._device_mac}")
+                self.startDataNotification()
+            else:
+                SdkLog.w(_TAG, f"Auto-restore init failed for {self._device_mac}")
+        except Exception as e:
+            SdkLog.exception(_TAG, f"Auto-restore failed for {self._device_mac}: {e}")
+        finally:
+            self._auto_restoring = False
+
     @property
     def hasInited(self) -> bool:
 

{sensor_sdk-0.2.0 → sensor_sdk-0.2.2/sensor_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor_sdk-0.2.0 → sensor_sdk-0.2.2}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), "r", encoding="utf-8") as f
 
 setup(
     name="sensor-sdk",
-    version="0.2.0",
+    version="0.2.2",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",