Apple Watch陀螺仪/加速度计数据传输数分钟后无故中断求助

针对你遇到的watchOS应用运行数分钟后停止、但iPhone版本正常的问题，结合代码分析，核心原因集中在watchOS后台运行权限限制和会话类型选择上，以下是具体排查方向和解决方案：

一、核心问题：WKExtendedRuntimeSession的时长限制 #

你当前使用的WKExtendedRuntimeSession仅适用于短时间后台任务，系统默认限制运行时长为3分钟（180秒），超时后会自动终止会话，导致传感器采集和UDP发送停止。而运动数据采集这类需要长时间后台运行的场景，应该使用WKWorkoutSession——它专门为运动类应用设计，能获得更长的后台运行权限。

替换为WKWorkoutSession的代码修改 #

import WatchKit
import Foundation

class InterfaceController: WKInterfaceController {
    @IBOutlet weak var stopButton: WKInterfaceButton!
    @IBOutlet weak var startButton: WKInterfaceButton!
    
    private var workoutSession: WKWorkoutSession?
    private var host: NWEndpoint.Host = "172.16.105.162"
    private var port: NWEndpoint.Port = 20001
    private var updateTimeInterval: Double = 1/60
    
    override func awake(withContext context: Any?) {
        startButton.setEnabled(true)
        stopButton.setEnabled(false)
        MySocketManager.shared.setUpConn()
    }
    
    override func willActivate() {
        print("ACTIVATE")
    }
    
    override func didDeactivate() {
        print("DEACTIVATE")
    }
    
    @IBAction func actionStop() {
        startButton.setEnabled(true)
        stopButton.setEnabled(false)
        stopWorkoutSession()
    }
    
    @IBAction func actionStart() {
        startButton.setEnabled(false)
        stopButton.setEnabled(true)
        startWorkoutSession()
    }
    
    private func startWorkoutSession() {
        // 配置Workout会话，根据实际场景选择activityType
        let configuration = WKWorkoutConfiguration()
        configuration.activityType = .other
        configuration.locationType = .none
        
        workoutSession = WKWorkoutSession(configuration: configuration)
        workoutSession?.delegate = self
        workoutSession?.start()
        
        MySocketManager.shared.connectToUDP(host, port)
        MotionDatafetcher.shared.startDeviceMotionFetch(updateTimeInterval)
    }
    
    private func stopWorkoutSession() {
        workoutSession?.end()
        workoutSession = nil
        
        MotionDatafetcher.shared.stopFetch()
        MySocketManager.shared.cancelConnToUDP()
    }
}

extension InterfaceController: WKWorkoutSessionDelegate {
    func workoutSession(_ workoutSession: WKWorkoutSession, didChangeTo toState: WKWorkoutSessionState, from fromState: WKWorkoutSessionState, date: Date) {
        // 处理会话状态变化，异常时终止任务
        if [.ended, .failed].contains(toState) {
            stopWorkoutSession()
        }
    }
    
    func workoutSession(_ workoutSession: WKWorkoutSession, didFailWithError error: Error) {
        print("Workout会话失败：\(error.localizedDescription)")
        stopWorkoutSession()
    }
}

二、配置必要的后台权限 #

在watchOS应用的Info.plist中添加以下配置，确保后台运行权限：

1. 添加运动数据权限说明：

   <key>NSMotionUsageDescription</key>
   <string>需要获取加速度计和陀螺仪数据用于运动分析</string>
   

2. 添加后台模式支持：

   <key>UIBackgroundModes</key>
   <array>
       <string>workout-processing</string>
   </array>
   

三、优化UDP连接稳定性 #

watchOS后台网络可能被系统节流，UDP无连接特性容易出现断连，需添加重连逻辑：

class MySocketManager {
    static let shared = MySocketManager()
    private var connection: NWConnection?
    private var currentHost: NWEndpoint.Host?
    private var currentPort: NWEndpoint.Port?
    
    func setUpConn() {}
    
    func connectToUDP(_ host: NWEndpoint.Host, _ port: NWEndpoint.Port) {
        currentHost = host
        currentPort = port
        connection = NWConnection(host: host, port: port, using: .udp)
        
        connection?.stateUpdateHandler = { [weak self] state in
            switch state {
            case .ready:
                print("UDP连接成功")
            case .failed(let error):
                print("UDP连接失败：\(error.localizedDescription)")
                // 5秒后尝试重连
                DispatchQueue.global().asyncAfter(deadline: .now() + 5) {
                    guard let host = self?.currentHost, let port = self?.currentPort else { return }
                    self?.connectToUDP(host, port)
                }
            case .cancelled:
                print("UDP连接已取消")
            default: break
            }
        }
        
        connection?.start(queue: .global())
    }
    
    func sendUDP(_ message: String) {
        guard let connection = connection, connection.state == .ready else {
            // 未连接时触发重连
            guard let host = currentHost, let port = currentPort else { return }
            connectToUDP(host, port)
            return
        }
        let data = message.data(using: .utf8)!
        connection.send(content: data, completion: .contentProcessed { error in
            if let error = error {
                print("UDP发送失败：\(error.localizedDescription)")
            }
        })
    }
    
    func cancelConnToUDP() {
        connection?.cancel()
        connection = nil
    }
}

四、确保Core Motion后台采集正常 #

检查MotionDatafetcher中CMMotionManager的配置，确保后台更新不被中断：

class MotionDatafetcher {
    static let shared = MotionDatafetcher()
    private let motionManager = CMMotionManager()
    
    func startDeviceMotionFetch(_ interval: Double) {
        guard motionManager.isDeviceMotionAvailable else { return }
        motionManager.deviceMotionUpdateInterval = interval
        // 允许后台显示运动状态（提升后台优先级）
        motionManager.showsDeviceMovementDisplay = true
        motionManager.startDeviceMotionUpdates(to: .main) { [weak self] data, error in
            guard let data = data else { return }
            self?.sendMotionData(data)
        }
    }
    
    private func sendMotionData(_ data: CMDeviceMotion) {
        // 格式化传感器数据
        let accel = data.userAcceleration
        let rotation = data.rotationRate
        let message = "Accel:\(accel.x),\(accel.y),\(accel.z);Rotation:\(rotation.x),\(rotation.y),\(rotation.z)"
        MySocketManager.shared.sendUDP(message)
    }
    
    func stopFetch() {
        motionManager.stopDeviceMotionUpdates()
    }
}

内容的提问来源于stack exchange，提问作者R. Haroon