HDFwear/Tools/BluetoothManager.swift

//
//  BluetoothManager.swift
//  Twear
//
//  Created by yangbin on 2021/12/6.
//
import Foundation
import CoreBluetooth
import UIKit
import SwiftUI
import SwiftDate
import AudioToolbox
import Alamofire
protocol BluetoothManagerDelegate: NSObjectProtocol {
    func didDiscover(devices: [ScanDevice])
    func didConnect(_ peripheral: CBPeripheral)
    func centralManagerDidUpdateState(_ state: Int)
    func didDisconnected()
}
//@objc protocol BluetoothSyncDelegate {
//    @objc optional func didReceiveFindCommand(status: Bool)
//    @objc optional func didConnect(_ peripheral: CBPeripheral)
//}
protocol BluetoothSyncDelegate {
    func didReceiveFindCommand(status: Bool)
    func didReceiveCameraCommand(status: SetCmd)
    func didReceiveFindPhoneCommand()
    func didReceiveBattery(value: Int, isCharging: Bool)
    func didReceiveHeartRate(value: Int)
    func didReceiveBloodOxygen()
    func didReceiveBloodPressure()
    func didReceiveSettingData()
    func didReceiveStep()
    func firstSync()
    func syncBug()
}
extension BluetoothSyncDelegate {
    func didReceiveFindCommand(status: Bool) { }
    func didReceiveCameraCommand(status: SetCmd) { }
    func didReceiveFindPhoneCommand() { }
    func didReceiveBattery(value: Int, isCharging: Bool) { }
    func didReceiveHeartRate(value: Int) { }
    func didReceiveBloodOxygen() { }
    func didReceiveBloodPressure() { }
    func didReceiveSettingData() { }
    func didReceiveStep() { }
    func firstSync() {}
    func syncBug() {}
}
class BluetoothManager: NSObject {
    //Closure
    var setCmdClosure: ((_ error: Int?) -> ())?
    
    var isManagerSync: Bool = false
    var setDataClosure: ((_ error: Int?) -> ())?
    var firmwareCallbackClosure: ((_ version: String, _ type: String, _ updateDic: [String: String], _ error: Int?) -> ())?
    var firmwareAlert: Bool = true
    var firmwareAlertView: FirmwareRemindView?
    
    var delegateList: [BluetoothManagerDelegate] = []
    var syncDelegateList: [BluetoothSyncDelegate] = []
    
    typealias SetCmdSyncClosure = (_ error: Error?) -> Void
    var setSyncClosure: SetCmdSyncClosure?
     
    typealias HeartRateClosure = (_ hrArray: [HeartRateModel], _ error: Int?) -> Void
    var heartRateClosure: HeartRateClosure?
    typealias BloodPressureClosure = (_ bpArray: [BloodPressureModel], _ error: Int?) -> Void
    var bloodPressureClosure: BloodPressureClosure?
    typealias BloodOxygenClosure = (_ boArray: [BloodOxygenModel], _ error: Int?) -> Void
    var bloodOxygenClosure: BloodOxygenClosure?
    typealias SleepClosure = (_ sleepArray: [SleepModel], _ error: Int?) -> Void
    var sleepClosure: SleepClosure?
    typealias StepClosure = (_ stepArray: [StepModel], _ error: Int?) -> Void
    var stepClosure: StepClosure?
    typealias TrainClosure = (_ trainArray: TrainModel?, _ error: Int?) -> Void
    var trainClosure: TrainClosure?
    typealias PressureClosure = (_ pressureArray: [PressureModel], _ error: Int?) -> Void
    var pressureClosure: PressureClosure?
    typealias MettClosure = (_ mettArray: [MettModel], _ error: Int?) -> Void
    var mettClosure: MettClosure?
    
    typealias DialProgressClosure = (_ progress: Int) -> Void
    var dialProgressClosure: DialProgressClosure?
    typealias DialClosure = (_ error: Int?) -> Void
    var dialClosure: DialClosure?
    
    typealias CustomDialProgressClosure = (_ progress: Int) -> Void
    var customProgressClosure: DialProgressClosure?
    typealias CustomDialClosure = (_ error: Int?) -> Void
    var customClosure: DialClosure?
    
    typealias SyncRTKProgressClosure = (_ progress: Int) -> Void
    var syncRTKProgressClosure: SyncRTKProgressClosure?
    typealias SyncRTKClosure = (_ error: Error?) -> Void
    var syncRTKClosure: SyncRTKClosure?
    
    typealias ContactProgressClosure = (_ progress: Int) -> Void
    var contactProgressClosure: ContactProgressClosure?
    
    var audioPlayer:AVAudioPlayer = AVAudioPlayer()
    
    static let shared = BluetoothManager()
    
//    weak var delegate: BluetoothManagerDelegate?
    
    var manger: MTKBleManager?
    var peripheral: CBPeripheral? = nil
//    private var conPeripheral: CBPeripheral? = nil //已连接的
    var platform: Platform = .other
    
    //CBCentralManager
    private var centralManger: CBCentralManager? = nil
    private var peripheralDic: [String: CBPeripheral] = [:]
    private var deviceArray: [ScanDevice] = []
    private var connectedPerArray: [CBPeripheral] = []
    
    private var contactArray: [ContactModel] = []
    
    
    //mergeData
    var totalBytes: [UInt8] = []
    var totalLength: Int = 0
    var mergeLength: Int = 0
    
    //sync
    var isSyncReceived: Bool = false //是否收到同步data
    var isSync: Bool = false //是否在同步中
    var isSyncType: SyncType = .other  //正在同步的指令
    var isNextSync: Bool = false //是否有下一个同步包
//    private var 
    
    override init() {
        super.init()
//        manger.registerClientProfile(BLEConfig.MTKServerUUID, clientProfileDelegate: self)
//        manger.registerClientProfile(BLEConfig.MTKBasServerUUID, clientProfileDelegate: self)
//        manger.registerClientProfile(BLEConfig.MTKDialServerUUID, clientProfileDelegate: self)
//        FmpGattClient.getInstance()
        manger = MTKBleManager.sharedInstance() as? MTKBleManager
        platform = CurDevice.platform
        setupManger(nil)
//        registerClientProfile()
        
    }
    private func setupManger(_ peripheral: CBPeripheral?) {
        if peripheral == nil  {
            if  CurDevice.uuid == "" {
                return
            } else {
                registerClientProfile()
            }
        } else {
            registerClientProfile()
        }
    }
    
    private func registerClientProfile() {
        switch platform {
        case ._828:
            manger?.registerClientProfile(BLEConfig.ServerUUID, clientProfileDelegate: self)
        default:
            break
        }
    }
    
    func registerDelegate(_ delegate: BluetoothManagerDelegate) {
        delegateList.append(delegate)
        print(delegateList)
//        print(NSStringFromClass(type(of: delegate)))
    }
    
    func unRegisterDelegate(_ delegate: BluetoothManagerDelegate) {
        delegateList.removeAll{ type(of: $0) == type(of: delegate) }
    }
    
    func registerSyncDelegate(_ delegate: BluetoothSyncDelegate) {
        syncDelegateList.append(delegate)
    }
    func unRegisterSyncDelegate(_ delegate: BluetoothSyncDelegate) {
        syncDelegateList.removeAll{ type(of: $0) == type(of: delegate) }
    }
    func clearDelegate() {
        delegateList.removeAll()
        syncDelegateList.removeAll()
    }
    
    func startScanning() {
        print("开始扫描")
        peripheralDic = [:]
        deviceArray = []
        centralManger = CBCentralManager(delegate: self, queue: nil)
        manger?.startScanning()
//mClientProfileDic    __NSDictionaryM *    1 key/value pair    0x0000000281a694c0
    }
    
    func stopScanning() {
        if centralManger != nil {
            if centralManger!.isScanning {
                centralManger?.stopScan()
            }
            centralManger = nil
        }
        manger?.stopScanning()
        
    }
    
    func connect(peripheral: CBPeripheral) {
//        setupManger(peripheral)
        let name = peripheral.name
        // 这里是根据名字来判断其平台类型
        platform = ._828
        registerClientProfile()
        manger?.connectPeripheral(peripheral)
    }
    
    func reconnectPer() {
        if self.peripheral != nil {
            connect(peripheral: self.peripheral!)
        }
    }
    
    
    
    
    func reConnect() {
        startScanning()
    }
    
    func forgetPeripheral() {
        print("forgetPeripheral")
        manger?.forgetPeripheral()
//        let menstrual = .menstrual
        manger = nil
//        MTKBleManager.sharedInstance() = nil
        manger = MTKBleManager.sharedInstance() as? MTKBleManager
        
        OTAPeripheral = nil
        peripheral = nil
        let device = DeviceModel()
//        device.menstrual = menstrual
        AdminHelper.shared.updateDevice(device)
    }
    
    func disconnect() {
        for per in connectedPerArray {
            manger?.disconnectPeripheral(per)
        }
        
//        manger.disconnectPeripheral()
//        manger.foundPeripherals = []
//        manger.connectPeripherals = []
//        manger.connectedService = []
//        manger.tempPeripheral = nil
//        mangerperipheral
    }
    
    func pairFail() {
        print("pairFail")
        disconnect()
//        peripheral = nil
//        manger.peripheral = nil
        manger?.foundPeripherals = nil
        manger?.tempPeripheral = nil
        manger?.connectedService = nil
        manger?.connectPeripherals = nil
//        if centralManger != nil {
//            if centralManger!.isScanning {
//                centralManger?.stopScan()
//            }
//            centralManger = nil
//        }
        connectedPerArray = []
    }
    
    //MARK: - 设置
    func getSettingData(completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getSettingCmd()
        self.setDataClosure = completion
//        print("??? --- \(setCmdClosure)")
        sendData(data)
    }
        
    
    func setUserInfo(_ user: UserInfoModel, completion: ((_ error: Int?) -> ())? = nil) {
//        let data = BleMessage.shared.getUserCmd(user)
//        self.setCmdClosure = completion
//        sendData(data)
        newSetUserInfo(user, completion: completion)
    }
    
    
    func setLanguage(_ language: AppSettings.Language, timeFormat: TimeFormat, screenOnTime: Int, pair: UInt8, completion: ((_ error: Int?) -> ())? = nil) {
        let lan: UInt8 = language == .Chinese ? 0x00 : 0x01
        newSetLanguage(lan: lan, completion: completion)
    }
    
    func setTime(format: TimeFormat, completion: ((_ error: Int?) -> ())? = nil) {
        newSetTime(completion: completion)
    }
    func setWeather(_ array: [WeatherModel], completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getWeatherCmd(array)
        self.setCmdClosure = completion
        sendData(data)
    }
  
    func syncContacts(_ array: [ContactModel], progress: @escaping ContactProgressClosure, completion: ((_ error: Int?) -> ())? = nil) {
        contactArray = array
//        let data = BleMessage.shared.getSyncContactsCmd(array, num: num)
        contactProgressClosure = progress
        self.setCmdClosure = completion
        print("同步联系人1-2")
        syncSubContacts(Array(array[0...1]), num: 1)
//        sendData(data)
    }
    
    func syncSubContacts(_ array: [ContactModel], num: Int) {
        let data = BleMessage.shared.getSyncContactsCmd(array, num: num)
        sendData(data)
    }
    
    func setCard(_ string: String, type: Int, completion: @escaping(_ error: Int?) -> ()) {
        let data = BleMessage.shared.getCardCmd(string, type: type)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    func setPay(_ string: String, type: Int, completion: @escaping(_ error: Int?) -> ()) {
        let data = BleMessage.shared.getPayCmd(string, type: type)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    func setMessagePush(_ push: MessagePushModel, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getMessagePush(push)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    func setAlarmClock(_ array: [AlarmClockModel], completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getAlarmClockCmd(array)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    func setDrinkWaterRemind(_ remind: RemindModel, completion: ((_ error: Int?) -> ())? = nil)  {
        let data = BleMessage.shared.getDrinkWaterCmd(remind)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    func setSedentaryRemind(_ remind: RemindModel, completion: ((_ error: Int?) -> ())? = nil)  {
        let data = BleMessage.shared.getSedentaryCmd(remind)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    func setNotDisturb(remind: RemindModel, completion: @escaping(_ error: Int?) -> ()) {
//        let data = BleMessage.shared.getNotDisturbCmd(remind)
//        self.setCmdClosure = completion
//        sendData(data)
        newSetNotDisturb(remind: remind, completion: completion)
    }
    
    func setWristSense(_ bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        newSetWristSense(bool: bool, completion: completion)
    }
    
    func setAutoMeasure(_ bool: Bool, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getAutoMeasureCmd(bool)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    func setMenstrual(_ menstrual: MenstrualCalendarModel, completion: ((_ error: Int?) -> ())? = nil) {
        let data = BleMessage.shared.getMenstrualCmd(menstrual)
        self.setCmdClosure = completion
        sendData(data)
    }
    
    
    func syncLanguage() {
        let lan: UInt8 = AppSettings.shared.language == .Chinese ? 0x00 : 0x01
        newSetLanguage(lan: lan)
    }
    func syncBase(language: AppSettings.Language, timeFormat: TimeFormat) {
        
    }
    
    func syncTime(format: TimeFormat) {
        let data = BleMessage.shared.getTimeCmd()
        sendData(data)
    }
    
    func openCamera(_ status: Bool) {
        let data = BleMessage.shared.getCameraCmd(status)
        sendData(data)
    }
    
    func findDevice(_ status: Bool) {
        switch platform {
        case ._828:
            if status {
                let data = BleMessage.shared.getFindCmd(status)
                sendData(data)
            }
        case .other:
            break
        }
    }
    
    func queryBattery() {
        let data = BleMessage.shared.getBatteryCmd()
        sendData(data)
    }
    
    //MARK: - 表盘, 固件升级
    func getFirmwareVersion(isAlert: Bool = true, closure: @escaping(_ version: String, _ type: String, _ updateDic: [String: String], _ error: Int?) -> ()) {
        firmwareCallbackClosure = closure
        firmwareAlert = isAlert
        let data = BleMessage.shared.getFirmwareCmd()
        sendData(data)
    }
    
    
    
    var OTAProfile: RTKOTAProfile? = nil
    var OTAPeripheral: RTKOTAPeripheral? = nil
    var DFUPeripheral: RTKMultiDFUPeripheral? = nil
    var upgradeBins: [RTKOTAUpgradeBin] = []
    var isFirmwareUpdate: Bool = false
    
    
    func syncFileWith(path: String, isFirmware: Bool = false, progress: @escaping SyncRTKProgressClosure, completion: @escaping SyncRTKClosure) {
        isFirmwareUpdate = isFirmware
        if OTAPeripheral == nil {
            return
        }
        startSyncDial()
        syncRTKProgressClosure = progress
        syncRTKClosure = completion
   
        do {
            upgradeBins = try RTKOTAUpgradeBin.imagesExtracted(fromMPPackFilePath: path)
        } catch {
            print("fail")
            return
        }
        if upgradeBins.count == 1 {
            if !(upgradeBins.last!.icDetermined) {
                upgradeBins.last?.assertAvailable(for: OTAPeripheral!)
            }
        }
        if OTAPeripheral!.canUpgradeSliently && !OTAPeripheral!.isRWS {
            let peripheral = OTAProfile!.dfuPeripheral(of: OTAPeripheral!)
            DFUPeripheral = peripheral as? RTKMultiDFUPeripheral
            DFUPeripheral!.delegate = self
            OTAProfile?.connect(to: DFUPeripheral!)
        }
        
    }
    
    
    func toUpgradeImages() -> [RTKOTAUpgradeBin] {
        if OTAPeripheral == nil {
            return []
        }
        switch OTAPeripheral?.activeBank.rawValue {
        case 0:
            let imagesForBank1: [RTKOTAUpgradeBin] = self.upgradeBins.filter{$0.upgradeBank == .bank1}
            if imagesForBank1.count > 0 {
                return []
            } else {
                return self.upgradeBins
            }
        case 1:
            return self.upgradeBins.filter{$0.upgradeBank == .bank1 || $0.upgradeBank == .unknown}
        case 2:
            return self.upgradeBins.filter{$0.upgradeBank == .singleOrBank0 || $0.upgradeBank == .unknown}
        default:
            return self.upgradeBins
        }
    }
    
    
    
    var syncDialIndex: Int = 0
    var dialLength: Int = 0
    var dialFileContents: [String] = []
    var dialDirectoryPath: String = ""
//    var dialRemainData: Data = Data()
    
    func syncDialWith(path: String, progress: @escaping DialProgressClosure, completion: @escaping DialClosure) {
        guard let contentsOfPath = try? FileManager.default.contentsOfDirectory(atPath: path), contentsOfPath.count > 0  else {
            return
        }
        dialDirectoryPath = path
        dialFileContents = contentsOfPath
        dialProgressClosure = progress
        dialClosure = completion
        dialLength = contentsOfPath.count
        syncDialIndex = 0
            
        sendDialData(BleMessage.shared.getSyncDialCmd(bytes: [0x02]))
    }
    
    
    
    func sendNextSyncData() {
        if syncDialIndex < dialLength {
            guard var dataStr = try? String.init(contentsOfFile: "\(dialDirectoryPath)/\(dialFileContents[syncDialIndex])", encoding: .utf8), dataStr.count > 0 else {
                return
            }
            dataStr = dataStr.replacingOccurrences(of: "\n", with: "").replacingOccurrences(of: "\r", with: "")
            sendDialData(BleMessage.shared.getSyncDialCmd(bytes: dataStr.hexaBytes))
            if dialProgressClosure != nil {
                dialProgressClosure?(Int(Float(syncDialIndex)/Float(dialLength)*100))
            }
        } else if syncDialIndex == dialLength {
            if dialProgressClosure != nil {
                dialProgressClosure?(100)
            }
            sendDialData(BleMessage.shared.getSyncDialCmd(bytes: [0x03]))
            if dialClosure != nil {
                dialClosure?(nil)
            }
        } else {
            return
        }
        
       
        syncDialIndex += 1
    }
    
//    var syncDialIndex: Int = 0
//    var dialLength: Int = 0
    var customDialData: Data = Data()
    var isSyncDial: Bool = false
    
//    var dialDirectoryPath: String = ""
    
    func syncCustomDial(_ data: Data, colorStyle: Int = 0, position: Int = 0, progress: @escaping CustomDialProgressClosure, completion: @escaping CustomDialClosure) {
        if data.count < 54 {
            return
        }
        customProgressClosure = progress
        customClosure = completion
//        let headerBytes = Array([UInt8](data)[0..<54])
        customDialData = data//Data(bytes: Array([UInt8](data)[54..<data.count]), count: data.count-54)
        syncDialIndex = 0
        dialLength = customDialData.count/240 + (customDialData.count%240 == 0 ? 0 : 1) + 1
//        var mdata = Data(repeating: 0x00, count: 120-13)
//        mdata.append(contentsOf: [UInt8](data))
        startSyncDial()
        sendCustomDialData(BleMessage.shared.getCustomDialCmd(bytes: [UInt8](data), color: colorStyle, position: position))
    }
    
    func startSyncDial() {
        isSyncDial = true
        if GCDTimer.shared.isExistTimer(WithTimerName: "SyncDial") {
            GCDTimer.shared.cancleTimer(WithTimerName: "SyncDial")
        }
        GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "SyncDial", timeInterval: 8, queue: .main, repeats: true) {
            if self.isSyncDial {
                self.isSyncDial = false
                if self.customClosure != nil {
                    self.customClosure?(-1002)
                    self.customClosure = nil
                }
                if self.syncRTKClosure != nil {
                    self.syncRTKClosure?(NSError(domain: "-1002", code: -1002, userInfo: nil))
                    self.syncRTKClosure = nil
                }
            }
        }
    }
//    func startSyncHealthData(closure: Any?, data: Data, cmd: SyncCmd) {
//        if !isSync {
//            GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "SyncInterval", timeInterval: 0.1, queue: .main, repeats: false) {
//                self.clearClosures(closure: closure)
//                self.startSyncTimer()
//                self.isNextSync = false
//                self.isSync = true
//                self.isSyncType = cmd
//                self.sendData(data)
//            }
//        } else {
//            switch closure {
//            case is BloodPressureClosure:
//                if bloodPressureClosure == nil {
//                    bloodPressureClosure = closure as? BloodPressureClosure
//                    bloodPressureClosure?([], -1002)
//                    bloodPressureClosure = nil
//                }
//            case is HeartRateClosure:
//                if heartRateClosure == nil {
//                    heartRateClosure = closure as? HeartRateClosure
//                    heartRateClosure?([], -1002)
//                    heartRateClosure = nil
//                }
//            case is BloodOxygenClosure:
//                if bloodOxygenClosure == nil {
//                    bloodOxygenClosure = closure as? BloodOxygenClosure
//                    bloodOxygenClosure?([], -1002)
//                    bloodOxygenClosure = nil
//                }
//            case is SleepClosure:
//                if sleepClosure == nil {
//                    sleepClosure = closure as? SleepClosure
//                    sleepClosure?([], -1002)
//                    sleepClosure = nil
//                }
//            case is StepClosure:
//                if stepClosure == nil {
//                    stepClosure = closure as? StepClosure
//                    stepClosure?([], -1002)
//                    stepClosure = nil
//                }
//            case is TrainClosure:
//                if trainClosure == nil {
//                    trainClosure = closure as? TrainClosure
//                    trainClosure?(nil, -1002)
//                    trainClosure = nil
//                }
//            case is PressureClosure:
//                if pressureClosure == nil {
//                    pressureClosure = closure as? PressureClosure
//                    pressureClosure?([], -1002)
//                    pressureClosure = nil
//                }
//            case is MettClosure:
//                if mettClosure == nil {
//                    mettClosure = closure as? MettClosure
//                    mettClosure?([], -1002)
//                    mettClosure = nil
//                }
//            default:
//                break
//            }
//        }
//    }
    
    
    func syncBug() {
//        if GCDTimer.s
        GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "syncBug", timeInterval: 25, queue: .main, repeats: false) {
            print("同步超时")
            self.isSync = false
            self.isSyncType = .other
            self.isSyncReceived = false
            for delegate in self.syncDelegateList {
                delegate.syncBug()
            }
        }
    }
    
    //MARK: - 解析数据
    //心率
    func parseHistoryHeartRate(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            heartRateClosure?([], nil)
            return
        }
        let hrArray = HeartRateModel.toHeartRateArray(bytes)
        heartRateClosure?(hrArray, nil)
    }
    //血压
    func parseHistoryBloodPressure(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            bloodPressureClosure?([], nil)
            return
        }
        let bpArray = BloodPressureModel.toBloodPressureArray(bytes)
        bloodPressureClosure?(bpArray, nil)
    }
    //血氧
    func parseHistoryBloodOxygen(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            bloodOxygenClosure?([], nil)
            return
        }
        let boArray = BloodOxygenModel.toBloodOxygenArray(bytes)
        bloodOxygenClosure?(boArray, nil)
    }
    //睡眠
    func parseHistorySleep(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            sleepClosure?([], nil)
            return
        }
        let sleepArray = SleepModel.toSleepArray(bytes)
        sleepClosure?(sleepArray, nil)
    }
    //计步
    func parseHistoryStep(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            stepClosure?([], nil)
            return
        }
        let stepArray = StepModel.toStepArray(bytes)
        stepClosure?(stepArray, nil)
    }
    //训练
    func parseHistoryTrain(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            trainClosure?(nil, 2000)
            return
        }
       
        let train = TrainModel.toTrainModel(bytes)
        train.add()
        if !isNextSync && !isSync {
            trainClosure?(train, nil)
        }
    }
    
    //压力
    func parseHistoryPressure(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            pressureClosure?([], nil)
            return
        }
        let pressureArray = PressureModel.toPressureArray(bytes)
        pressureClosure?(pressureArray, nil)
    }
    
    //梅脱
    func parseHistoryMett(_ bytes: [UInt8]) {
        if bytes.count == 0 {
            mettClosure?([], nil)
            return
        }
        let mettArray = MettModel.toMettArray(bytes)
        mettClosure?(mettArray, nil)
    }
    
    func parseRealTimeSteps(_ bytes: [UInt8]) {
        if bytes.count > 0 {
            print(StepModel.toStepModel(bytes))
            StepModel.toStepModel(bytes).realTimeAdd()
            for delegate in syncDelegateList {
                delegate.didReceiveStep()
            }
        }
    }
    
    func parseRealTimeBloodOxygen(_ bytes: [UInt8]) {
        if bytes.count == 1 {
            BloodOxygenModel(value: Int(bytes[0]), date: DateInRegion().date).realTimeAdd()
            for delegate in syncDelegateList {
                delegate.didReceiveBloodOxygen()
            }
        }
    }
    func parseRealTimeBloodPressure(_ bytes: [UInt8]) {
        if bytes.count == 2 {
            BloodPressureModel(dbp: Int(bytes[1]), sbp: Int(bytes[0]), date: DateInRegion().date).realTimeAdd()
            for delegate in syncDelegateList {
                delegate.didReceiveBloodPressure()
            }
        }
    }
    
    
    func parseRealTimeHeartRate(_ bytes: [UInt8]) {
        if bytes.count == 1 {
            HeartRateModel(value: Int(bytes[0]), date: DateInRegion().date).realTimeAdd()
            for delegate in syncDelegateList {
                delegate.didReceiveHeartRate(value: Int(bytes[0]))
            }
        }
    }
    
    private func parseSyncData(_ key: SyncCmd?, bytes: [UInt8]) {
        stopSyncTimer(BLEConfig.SyncHealthTimer)
        if !isNextSync {
            isSync = false
            isSyncType = .other
        }
        
        switch key {
        case .sleep:
            parseHistorySleep(bytes)
        case .hr:
            parseHistoryHeartRate(bytes)
        case .bp:
            parseHistoryBloodPressure(bytes)
        case .bo:
            parseHistoryBloodOxygen(bytes)
        case .step:
            parseHistoryStep(bytes)
        case .train:
            parseHistoryTrain(bytes)
        case .pressure:
            parseHistoryPressure(bytes)
        case .mett:
            parseHistoryMett(bytes)
        case .bo_rt:
            parseRealTimeBloodOxygen(bytes)
        case .bp_rt:
            parseRealTimeBloodPressure(bytes)
        case .hr_rt:
            parseRealTimeHeartRate(bytes)
        case .step_rt:
            parseRealTimeSteps(bytes)
        default:
            break
        }
    }
    private func parseSettingData(_ data: Data) {
        let bytes = Array([UInt8](data)[13..<data.count])
        let admin = AdminHelper.shared.loadLocalAdminData()
        
        var alarmClocks: [AlarmClockModel] = []
//        let emptyAlarm = [UInt8](repeating: 0, count: 30)
//        if Array([UInt8](bytes)[0..<30]) != emptyAlarm {
            for i in 0..<5 {
                if let alarmClock = AlarmClockModel.toAlarmClock(Array(bytes[i*5..<i*5+5])) {
                    alarmClocks.append(alarmClock)
                }
            }
//        }
        admin.userInfo.alarmClocks = alarmClocks
        admin.userInfo.sedentary = RemindModel.toRemindModel(Array(bytes[25..<31]))
        admin.userInfo.gender = Int(bytes[33])
        admin.userInfo.age = Int(bytes[34])
        admin.userInfo.height = Int(bytes[35])
        admin.userInfo.weight = Int(bytes[36])
        admin.userInfo.stepsGoal = bytesToInt(Array(bytes[37..<40]).reversed())
        admin.device.disturb = RemindModel.toRemindModel(Array(bytes[42..<47]))
        admin.userInfo.drink = RemindModel.toRemindModel(Array(bytes[57..<65]))
        admin.userInfo.push = MessagePushModel(value: bytesToInt(Array(bytes[65..<67])))
        admin.userInfo.wrist = Int(bytes[72]) == 1
        if bytes.count > 75 {
            admin.userInfo.isDailSync = Int(bytes[74]) == 1
            admin.userInfo.timeFormat = Int(bytes[76])
        }
       
        //74表盘
        //75语言
        //76时间格式
        
//        1, 24, 175, 65, 16, 39,
//        1, 24, 175, 65, 16, 39, 0,
        AdminHelper.shared.savaAdminInfo(admin)
        
        for delegate in syncDelegateList {
            delegate.didReceiveSettingData()
        }
    }
    private func parseDeviceData() {
        
    }
    
    private func parseSetData(_ key: SetCmd?, data: Data) {
//        print("\(key) --- \(setCmdClosure)")
        switch key {
        case .firmware:
            print("!!firmware!!!!\([UInt8](data))")
        case .firmware_return:
            let version = "\([UInt8](data)[13]).\([UInt8](data)[14]).\([UInt8](data)[15])"
            let type = String(format:"%04d",[UInt8](data)[19])
            let device = CurDevice
            device.version = version
            device.type = type
            AdminHelper.shared.updateDevice(device)
            queryLatestVersion(version: version, type: type)
            
            print("!!firmware!!!!\([UInt8](data))")
        case .alarmClock:
            if isManagerSync {
                isManagerSync = false
                self.syncDrinkRemind()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
            print("!!alarmClock!!!!\([UInt8](data))")
        case .set_return:
            parseSettingData(data)
            if setDataClosure != nil {
                setDataClosure?(nil)
                setDataClosure = nil
            }
            print("!!!!!!!\([UInt8](data))")
        case .wrist://用户信息 --- 单位 --- 抬腕亮屏 --- 整点测量 --- 闹钟 --- 喝水 --- 久坐
            if isManagerSync {
                isManagerSync = false
                self.syncAutoMeasure()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .autoMeasure:
            if isManagerSync {
                isManagerSync = false
                self.syncAlarmClocks()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .user:
            if isManagerSync {
                isManagerSync = false
                if CurDevice.name.contains("P8GT") {
                    self.syncDeivceLanguage()
                } else {
                    self.syncUnit()
                }
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .unit:
            if isManagerSync {
                isManagerSync = false
                self.syncWristSense()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .push:
            if isManagerSync {
                isManagerSync = false
                self.setMenstrualStatus()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .menstrual:
            if isManagerSync {
                isManagerSync = false
                self.firstSyncDone()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .time:
            if isManagerSync {
                isManagerSync = false
                self.syncMessagePush()
//                self.setMenstrualStatus()
            }
            
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .setting:
            print("!!setting!!!!\([UInt8](data))")
        case .card, .pay:
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .custom:
            if !isSyncDial { return }
            syncDialIndex += 1
            startSyncDial()
//            print("\(syncDialIndex) ---- \(dialLength)")
            if syncDialIndex == dialLength {
                isSyncDial = false
                if GCDTimer.shared.isExistTimer(WithTimerName: "SyncDial") {
                    GCDTimer.shared.cancleTimer(WithTimerName: "SyncDial")
                }
                if customClosure != nil {
                    customClosure?(nil)
                }
            } else if syncDialIndex < dialLength {
                let i = syncDialIndex-1
                print("\(i)==\(customDialData.count)")
                sendCustomDialData(customDialData[i*240..<min(i*240+240, customDialData.count)])
            }
            if customProgressClosure != nil {
                customProgressClosure?(syncDialIndex*100/dialLength)
            }
            
        case .contact:
//            if setCmdClosure != nil {
                setCmdClosure?(nil)
//                setCmdClosure = nil
//            }
        case .contact1:
            print("同步联系人3-4")
            syncSubContacts(Array(contactArray[2...3]), num: 2)
            contactProgressClosure?(25)
        case .contact2:
            print("同步联系人5-6")
            syncSubContacts(Array(contactArray[4...5]), num: 3)
            contactProgressClosure?(50)
        case .contact3:
            print("同步联系人7-8")
//            if setCmdClosure != nil {
//                            setCmdClosure?(nil)
//                            setCmdClosure = nil
//                        }
            syncSubContacts(Array(contactArray[6...7]), num: 4)
            contactProgressClosure?(75)
//            if setCmdClosure != nil {
//                setCmdClosure?(nil)
//                setCmdClosure = nil
//            }
        case .battery:
            if setCmdClosure != nil { //contact4
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
            print("????")
        case .disturb:
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .drink:
            if isManagerSync {
                isManagerSync = false
                self.syncSedentaryRemind()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .sedentary:
            if isManagerSync {
                isManagerSync = false
                self.syncDeviceTime()
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
            
        case .language:
            if isManagerSync {
                isManagerSync = false
                if CurDevice.name.contains("P8GT") {
                    self.syncUnit()
                } else {
                    self.syncDeviceTime()
                }
            }
            if setCmdClosure != nil {
                setCmdClosure?(nil)
                setCmdClosure = nil
            }
        case .takePicture, .exitCamera:
            for delegate in syncDelegateList {
                delegate.didReceiveCameraCommand(status: key!)
            }
        case .openCamera:
//            print("收到打开箱机")
            if !IsCameraOpen {
                SystemAuth.authCamera  { isAuth in
                    if let curVC = UIViewController.getCurrentViewController() {
                        if isAuth {
                            let vc = UIStoryboard.loadViewControllerIdentifier(storyboardName: "Setting", identifier: "CameraViewController")
                            vc.modalPresentationStyle = .fullScreen
                            curVC.present(vc, animated: true, completion: nil)
                            
                            IsCameraOpen = true
                        } else {
                            curVC.showAlert(title: LocString("提示"), message: LocString("请在“设置-隐私-相机”选项中,允许'YTWatch'访问你的相机"), cancelText: nil, confirm: nil)
                        }
                    }
                }
            }
        case .find_phone_start:
            if GCDTimer.shared.isExistTimer(WithTimerName: "FindPhoneTimer") {
                GCDTimer.shared.cancleTimer(WithTimerName: "FindPhoneTimer")
            }
            GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "FindPhoneTimer", timeInterval: 20, queue: .main, repeats: false) {
                self.audioPlayer.stop()
                AudioServicesRemoveSystemSoundCompletion(kSystemSoundID_Vibrate)
                AudioServicesDisposeSystemSoundID(kSystemSoundID_Vibrate)
            }
            //        func playAlarmVoiceAction() {
            let session = AVAudioSession.sharedInstance()
            //在音频播放前，首先创建一个异常捕捉语句
            do {
                //启动音频会话管理，此时会阻断后台音乐播放
                try session.setActive(true)
                //设置音频播放类别，表示该应用仅支持音频播放
                try session.setCategory(AVAudioSession.Category.playback)
                let path = Bundle.main.path(forResource: "Sound1", ofType: "wav")
                
                //将字符串路径转化为网址路径
                let soundUrl = URL(fileURLWithPath: path!)
                
                try audioPlayer = AVAudioPlayer(contentsOf:soundUrl)
                audioPlayer.prepareToPlay()//为音频播放做好准备
                audioPlayer.volume = 1.0//设置音量
                audioPlayer.numberOfLoops = -1//是否循环播放
                audioPlayer.play()
            } catch {
                print(error)
            }
            let soundID: SystemSoundID = kSystemSoundID_Vibrate
            let observer = UnsafeMutableRawPointer(Unmanaged.passUnretained(self).toOpaque())
            AudioServicesAddSystemSoundCompletion(soundID, nil, nil, {
                (soundID, inClientData) -> Void in
                let mySelf = Unmanaged<BluetoothManager>.fromOpaque(inClientData!).takeUnretainedValue()
                mySelf.audioServicesPlaySystemSoundCompleted(soundID: soundID)
            }, observer)
            AudioServicesPlaySystemSound(kSystemSoundID_Vibrate)
        case .find_phone_stop:
            self.audioPlayer.stop()
            AudioServicesRemoveSystemSoundCompletion(kSystemSoundID_Vibrate)
            AudioServicesDisposeSystemSoundID(kSystemSoundID_Vibrate)
        case .find_device:
            for delegate in syncDelegateList {
                delegate.didReceiveFindPhoneCommand()
            }
        case .sync:
            print("同步")
        case .weather:
            print("同步天气????????")
        case .none:
            print("")
        case .dial:
            print("")
        case .battery_return:
            if GCDTimer.shared.isExistTimer(WithTimerName: "queryBattary") {
                GCDTimer.shared.cancleTimer(WithTimerName: "queryBattary")
            }
            if data.count > 13 {
                Battery = Int([UInt8](data)[13])
                var isCharging = false
                if data.count > 14 {
                    isCharging = [UInt8](data)[14] == 2
                }
     
                for delegate in syncDelegateList {
                    delegate.didReceiveBattery(value: Battery, isCharging: isCharging)
                }
            }
     
        }
    }
    //音频结束时的回调
     func audioServicesPlaySystemSoundCompleted(soundID: SystemSoundID) {
         print("Completion")
         AudioServicesPlaySystemSound(kSystemSoundID_Vibrate)
     }
    
    private func sendCustomDialData(_ data: Data) {
        if !isSyncDial { return }
        if peripheral == nil || data.count == 0 {
            return
        }
//        print("\(data.count)----\([UInt8](data))")
        if let services = peripheral?.services {
            for service in services {
                if service.uuid.uuidString == BLEConfig.ServerUUID {
                    if service.characteristics == nil {
                        return
                    }
                    for char in service.characteristics! {
                        if char.uuid.uuidString == BLEConfig.WriteUUID {
//                            print("自定义表盘发送: \([UInt8](data))")
                            peripheral?.writeValue(data, for: char, type: .withResponse)
                        }
                    }
                }
            }
        }
    }
    
    private func sendDialData(_ data: Data) {
        if peripheral == nil || data.count == 0 {
            return
        }
        if let services = peripheral?.services {
            for service in services {
                if service.uuid.uuidString == BLEConfig.MTKDialServerUUID {
                    if service.characteristics == nil {
                        return
                    }
                    for char in service.characteristics! {
                        if char.uuid.uuidString == BLEConfig.MTKDialWriteUUID {
                            if data.count <= 180 {
                                print([UInt8](data))
                                peripheral?.writeValue(data, for: char, type: .withResponse)
                            } else {
                                let n = data.count/180 + (data.count%180 == 0 ? 0 : 1)
                                for i in 0..<n {
                                    peripheral?.writeValue(data[i*180..<min(i*180+180, data.count)], for: char, type: .withResponse)
                                }
                                
                            }
                        }
                    }
                }
            }
        }
    }
    
    
    
    
    //MARK: - 同步计时器
    func startSyncTimer() {
        stopSyncTimer(BLEConfig.SyncHealthTimer)
        
            GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: BLEConfig.SyncHealthTimer, timeInterval: 3, queue: .main, repeats: false) {[weak self] in
                print("同步超时")
    //            if !self.isSyncReceived {
                self?.syncReceiveFail()
    //            }
            }
            print("开始同步计时")
        
 
//        if GCDTimer.shared.isExistTimer(WithTimerName: BLEConfig.SyncHealthTimer) {
//
//        }
        
    }
    
    func stopSyncTimer(_ name: String) {
        isSyncReceived = false
        if GCDTimer.shared.isExistTimer(WithTimerName: name) {
            GCDTimer.shared.cancleTimer(WithTimerName: name)
            print("停止同步计时")
        }
    }
    
    func syncReceiveFail() {
        print("同步失败")
//        stopSyncTimer(BLEConfig.SyncHealthTimer)
        isSync = false
        isSyncType = .other
        heartRateClosure?([], -1001)
        bloodPressureClosure?([], -1001)
        bloodOxygenClosure?([], -1001)
        sleepClosure?([], -1001)
        stepClosure?([], -1001)
        trainClosure?(nil, -1001)
        pressureClosure?([], -1001)
        mettClosure?([], -1001)
    }
    
    func clearClosures(closure: Any?) {
        heartRateClosure = nil
        bloodPressureClosure = nil
        bloodOxygenClosure = nil
        sleepClosure = nil
        stepClosure = nil
        trainClosure = nil
        pressureClosure = nil
        mettClosure = nil
        switch closure {
        case is BloodPressureClosure:
            bloodPressureClosure = closure as? BloodPressureClosure
        case is HeartRateClosure:
            heartRateClosure = closure as? HeartRateClosure
        case is BloodOxygenClosure:
            bloodOxygenClosure = closure as? BloodOxygenClosure
        case is SleepClosure:
            sleepClosure = closure as? SleepClosure
        case is StepClosure:
            stepClosure = closure as? StepClosure
        case is TrainClosure:
            trainClosure = closure as? TrainClosure
        case is PressureClosure:
            pressureClosure = closure as? PressureClosure
        case is MettClosure:
            mettClosure = closure as? MettClosure
        default:
            break
        }
        
    }
    
}
extension BluetoothManager: ClientProfileDelegate {
    func onCentralManagerStateChange(_ state: Int32) {
//        var managerState: CBCentralManagerState = .unknown
        switch state {
        case 0:
//            managerState = .unknown
            print("unknown")
        case 1:
//            managerState = .resetting
            print("resetting")
        case 2:
//            managerState = .unsupported
            print("unsupported")
        case 3:
//            managerState = .unauthorized
            print("unauthorized")
        case 4:
//            managerState = .poweredOff
            print("poweredOff")
            if DeviceIsConnected {
                DeviceIsConnected = false
                for delegate in delegateList {
                    delegate.didDisconnected()
                }
            }
        case 5:
            print("poweredOn")
//            managerState = .poweredOn
            centralManger?.scanForPeripherals(withServices: nil, options: nil)
        default:
            print(" ")
        }
        
        for delegate in delegateList {
            delegate.centralManagerDidUpdateState(Int(state))
        }
    }
    
    func onConnected(_ peripheral: CBPeripheral!) {
        print("已经连接: \(peripheral.identifier.uuidString)--\(peripheral.name ?? "")")
    
        stopScanning()
        connectedPerArray.append(peripheral)
        self.peripheral = peripheral
        peripheral.discoverServices(nil)
        
        var delayTime: Double = 2
        
        if CurDevice.uuid == "" {
            var mac = ""
            for device in deviceArray {
                if peripheral!.identifier.uuidString == device.peripheral.identifier.uuidString {
                    mac = device.mac
                }
            }
            
            let admin = AdminHelper.shared.loadLocalAdminData()
            if admin.userInfo.mac != mac {
                print("不同设备")
                admin.userInfo.mac = mac
                admin.userInfo.dailVersion = "0"
                admin.userInfo.isDailSync = false
                admin.userInfo.dailIndex = -1
                admin.userInfo.dialIndexPath = ""
                admin.userInfo.customDial = ""
//                admin.userInfo.dialNumDic = [:]
            }
            admin.device = DeviceModel(uuid: peripheral!.identifier.uuidString, name: peripheral!.name ?? "", platform: platform, mac: mac)
            
            AdminHelper.shared.savaAdminInfo(admin)
//            AdminHelper.shared.updateDevice(DeviceModel(uuid: peripheral!.identifier.uuidString, name: peripheral!.name ?? "", platform: platform, mac: mac))
            delayTime = 3
            GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "SyncLanguage", timeInterval: 2, queue: .main, repeats: false) {
                self.syncLanguage()
            }
        }
        
        if platform == ._828 {
            print("828连接")
            OTAProfile = RTKOTAProfile(delegate: self)
            startSync828(delayTime)
        }
        
        DeviceIsConnected = true
//        MusicManager.shared.controlMusic()
        for delegate in delegateList {
            delegate.didConnect(peripheral)
        }
  
//        GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "FirstSync", timeInterval: 5+delayTime, queue: .main, repeats: false) {
//            self.syncBug()
//            for delegate in self.syncDelegateList {
//                delegate.firstSync()
//            }
//        }
//
        isFirstSync = true
    }
    
    func onDisconnected() {
        for delegate in delegateList {
            delegate.didDisconnected()
        }
        print("断开连接1")
    }
    
    func onServiceDiscovered(_ periphearl: CBPeripheral!, error: Error!) {
//        print("已经连接2")
    }
    
    func onCharacteristicDiscovered(_ peripheral: CBPeripheral!, for service: CBService!, error err: Error!) {
        if service.characteristics == nil {
            return
        }
        for char in service.characteristics! {
            let uuid = char.uuid.uuidString
            switch uuid {
            case BLEConfig.MTKReadUUID, BLEConfig.MTKBasReadUUID, BLEConfig.MTKDialReadUUID, BLEConfig.ReadUUID:
                peripheral.setNotifyValue(true, for: char)
            default:
                break
            }
        }
    }
    //MARK: - 接收数据
    func onUpdateValue(forCharacteristic peripheral: CBPeripheral!, for characteristic: CBCharacteristic!, error err: Error!) {
        guard let data = characteristic.value, data.count >= 0 else {
            return
        }
        
        switch characteristic.uuid.uuidString {
        case BLEConfig.MTKBasReadUUID:
            print("电量------\([UInt8](data))")
            Battery = Int([UInt8](data)[0])
            for delegate in syncDelegateList {
                delegate.didReceiveBattery(value: Battery, isCharging: false)
            }
        case BLEConfig.MTKDialReadUUID:
            print("表盘------\([UInt8](data))")
            let bytes = [UInt8](data)
            if bytes.count > 13 {
                if bytes[13] == 1 {
                    sendNextSyncData()
                } else if bytes[13] == 2 {
//                    sendDialData(dialRemainData)
                }
            }
        case BLEConfig.ReadUUID:
            print("?????????????\([UInt8](data))")
            mergeData(data)
        default:
            mergeData(data)
        }
    }
    
    func mergeData(_ data: Data) {
        let bytes = [UInt8](data)
        print(bytes)
        isSyncReceived = true
        if bytes[0] == 0xED && bytes[1] == 0x7E {
//            if bytes.count > 10, BleCmd(rawValue: bytes[8]) == .sync {
//                if isSync {
//                    if SyncCmd(rawValue: bytes[10]) != isSyncType {
//                        syncReceiveFail()
//                    } else {
//                        isNextSync = bytes[1] == 112
//                        startSyncTimer()
//                        isSyncReceived = true
//                    }
//                }
//            }
            // 内容长度加上其他位的长度
            totalLength = Int(UInt16(bytes[8]) << 8 | UInt16(bytes[9])) + 12
            if data.count == totalLength {
                parseData(bytes)
            } else {
                totalBytes = []
                totalBytes.append(contentsOf: bytes)
                mergeLength = bytes.count
            }
        } else {
            if isSync {
                if isSyncReceived {
                    startSyncTimer()
                    isSyncReceived = true
                }
            }
            totalBytes.append(contentsOf: bytes)
            mergeLength += bytes.count
            if mergeLength == totalLength {
                parseData(totalBytes)
            }
        }
        
        
    }
    
    
    func onCharacteristicWrite() {
//        print("已经连接5")
    }
    
    func onReadRssi(_ peripheral: CBPeripheral!, rssiValue rssi: Int32, error err: Error!) {
//        print("已经连接6")
    }
}
extension BluetoothManager: CBCentralManagerDelegate {
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        switch central.state {
        case .unknown:
            print("unknown1")
        case .resetting:
            print("resetting1")
        case .unsupported:
            print("unsupported1")
        case .unauthorized:
            if let curVC = UIViewController.getCurrentViewController() {
                curVC.showAlert(title: LocString("提示"), message: LocString("请在“设置-隐私-蓝牙”选项中,允许'YTWatch'使用蓝牙"), cancelText: nil, confirm: nil)
            }
            print("unauthorized1")
        case .poweredOff:
            print("poweredOff1")
        case .poweredOn:
            print("poweredOn1")
            centralManger?.scanForPeripherals(withServices: nil, options: nil)
        @unknown default:
            print(" ")
        }
        
        for delegate in delegateList {
            delegate.centralManagerDidUpdateState(central.state.rawValue)
        }
        
    }
    
    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
        if peripheralDic.keys.contains(peripheral.identifier.uuidString) {
            return
        }
//        if peripheral.name?.range(of: "You 1_LE") != nil || peripheral.name?.range(of: "Pro_LE") != nil || peripheral.name?.range(of: "MTB025B") != nil || peripheral.name?.range(of: "MTB033B") != nil || peripheral.name?.range(of: "hq7") != nil || peripheral.name?.range(of: "D09") != nil || peripheral.name?.range(of: "P8GT") != nil || peripheral.name?.range(of: "hq8") != nil || peripheral.name?.range(of: "Watch 8") != nil || peripheral.name?.range(of: "D07") != nil || peripheral.name?.range(of: "S7 NO.1") != nil || peripheral.name?.range(of: "G7 Pro Max Gameboy") != nil {
        if peripheral.name?.range(of: "2040XY-RTK0001") != nil {
            peripheralDic[peripheral.identifier.uuidString] = peripheral
            //        print(peripheral.name)key    String    "kCBAdvDataServiceData"
  
            if let data = advertisementData["kCBAdvDataManufacturerData"] as? Data {
                var mac = data.hexToString(":")
                mac = mac.substring(fromIndex: mac.length-17)
                deviceArray.append(ScanDevice(peripheral, mac: mac))
                for delegate in delegateList {
                    delegate.didDiscover(devices: deviceArray)
                }
            } else {
                // 该设备无值
//                if let json = advertisementData["kCBAdvDataServiceData"] {
//                    if let dic = json as? Dictionary<CBUUID, Data> {
//                        if let data = dic.values.first {
//                            var mac = data.hexToString(":")
//                            mac = mac.substring(fromIndex: mac.length-17)
                            deviceArray.append(ScanDevice(peripheral, mac: "111"))
                            for delegate in delegateList {
                                delegate.didDiscover(devices: deviceArray)
                            }
//                        }
//                    }
//                }
            }
        }
    }
}
extension BluetoothManager: RTKMultiDFUPeripheralDelegate, RTKLEProfileDelegate {
    func profileManagerDidUpdateState(_ profile: RTKLEProfile) {
        if profile.centralManager.state == .poweredOn && self.peripheral != nil {
//            print("RTK??????????????")
            OTAPeripheral = OTAProfile?.instantiatePeripheral(with: self.peripheral!) as? RTKOTAPeripheral
            OTAProfile?.connect(to: OTAPeripheral!)
        }
    }
    
    func dfuPeripheral(_ peripheral: RTKDFUPeripheral, didSend length: UInt, totalToSend totalLength: UInt) {
        print("\(length) ---- \(totalLength)")
        startSyncDial()
        syncRTKProgressClosure?(Int(Float(length)/Float(totalLength)*100))
    }
    
    func profile(_ profile: RTKLEProfile, didConnect peripheral: RTKLEPeripheral) {
        if peripheral == self.DFUPeripheral {
            DFUPeripheral?.upgradeImages(self.toUpgradeImages(), inOTAMode: false)
        }
    }
    func dfuPeripheral(_ peripheral: RTKDFUPeripheral, didFinishWithError err: Error?) {
//        if err != nil {
        print("dfuPeripheral  \\ \(err)")
            isSyncDial = false
            if GCDTimer.shared.isExistTimer(WithTimerName: "SyncDial") {
                GCDTimer.shared.cancleTimer(WithTimerName: "SyncDial")
            }
            syncRTKClosure?(err)
//        }
    }
    
    func dfuPeripheral(_ peripheral: RTKDFUPeripheral, shouldWaitForDisconnectionOnCompleteSend image: RTKOTAUpgradeBin) -> Bool {
        return isFirmwareUpdate
    }
    
}
extension BluetoothManager: XMLParserDelegate {
    private func queryLatestVersion(version: String, type: String) {
        Alamofire.request("http://hodafone.com.cn/qwear/update/\(type)/version.xml").responseData { responseData in
            if responseData.response?.statusCode == 404 {
                self.firmwareCallbackClosure?(version, type, [:], nil)
            } else {
                if let data = responseData.data {
                    let parser = XMLParser(data: data)
                    parser.delegate = self
                    parser.parse()
                }
            }
           
            
        }
    }
    func parser(_ parser: XMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String : String] = [:]) {
        let device = CurDevice
        if elementName == "product" {
            if let least = attributeDict["least"], let file = attributeDict["file"], let id = attributeDict["id"] {
                if CurDevice.version.checkVersion(least) {
                    print("需要升级")
                    firmwareCallbackClosure?(device.version, device.type, ["least": least, "file": file, "id": id], nil)
                    if let curVC = UIViewController.getCurrentViewController(), !(curVC is FirmwareUpdateVC) {
//                        print(NSStringFromClass(type(of: curVC)))
                        if firmwareAlert {
                            if firmwareAlertView == nil {
                                firmwareAlertView = FirmwareRemindView(title: LocString("版本更新"), detail: LocString("监测到你的手表当前使用的不是最新版本固件，为了不影响手表的正常使用，并给你带来更好的用户体验，请务必将手表更新至最新固件版本。"), sureText: LocString("去更新"))
                                self.firmwareAlertView?.show()
                                self.firmwareAlertView?.clickClosure = {[weak self] index in
                                    self?.firmwareAlertView = nil
                                    let vc = UIStoryboard.loadViewControllerIdentifier(storyboardName: "Setting", identifier: "FirmwareUpdateVC")
                                    curVC.navigationController?.pushViewController(vc, animated: true)
                                }
                            }
         
                        }
                    }
                } else {
                    firmwareCallbackClosure?(device.version, device.type, [:], nil)
                }
                
            }
        }
        
//        func parser(_ parser: XMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String : String] = [:]) {
//            if elementName == "product"{
//                print(attributeDict)
//                if let least = attributeDict["least"] {
//                    latestVersion = least
//                    checkUpdate()
//                }
//                if let file = attributeDict["file"] {
//                    downLoadUrlPath = file
//                }
//                if let id = attributeDict["id"] {
//                    self.id = id
//                }
//
//            }
//        }
    }
}
extension BluetoothManager {
    private func startSync828(_ delayTime: Double) {
        self.syncBug()
        isFirstSync = true
        GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "SyncTime", timeInterval: delayTime, queue: .main, repeats: false) {
            self.syncUserInfo()
        }
//        GCDTimer.shared.scheduledDispatchTimerNotNow(WithTimerName: "SyncTime", timeInterval: delayTime, queue: .main, repeats: false) {
//            self.syncDeviceTime()
//        }
    }
    
//828:  用户信息 --- 单位 --- 抬腕亮屏 --- 整点测量 --- 闹钟 --- 喝水 --- 久坐 --- 时间 --- 消息通知 --- 月经
    
//P8GT  用户信息 --- 语言 --- 单位 --- 抬腕亮屏 --- 整点测量 --- 闹钟 --- 喝水 --- 久坐 --- 时间 --- 消息通知 --- 月经
    
    func syncUserInfo() {
        print("用户信息")
        let user = UserInfo
        self.setUserInfo(user, completion: nil)
        self.isManagerSync = true
    }
    
    func syncUnit() {
        print("同步单位")
        let user = UserInfo
        newSetDistanceUnit(unit:DistanceUnit(rawValue: UInt8(user.distanceUnit))!) { [weak self] error in
            if error == nil {
                self?.newSetTemperatureUnit(unit: TemperatureUnit(rawValue: UInt8(user.temperatureUnit))!) { error in
                    
                }
            }
        }
        self.isManagerSync = true
    }
    
    func syncWristSense() {
        print("同步抬腕亮屏")
        let user = UserInfo
        self.setWristSense(user.wrist, completion: nil)
        self.isManagerSync = true
    }
    
    func syncAutoMeasure() {
        print("同步整点测量")
        let user = UserInfo
        self.setAutoMeasure(user.autoMasure, completion: nil)
        self.isManagerSync = true
    }
    
    func syncAlarmClocks() {
        print("同步闹钟")
        let user = UserInfo
        self.setAlarmClock(user.alarmClocks, completion: nil)
        self.isManagerSync = true
    }
    
    func syncDrinkRemind() {
        print("同步喝水")
        let user = UserInfo
        self.setDrinkWaterRemind(user.drink, completion: nil)
        self.isManagerSync = true
    }
    
    func syncSedentaryRemind() {
        print("同步久坐")
        let user = UserInfo
        self.setSedentaryRemind(user.sedentary, completion: nil)
        self.isManagerSync = true
    }
    
    func syncDeviceTime() {
        print("同步时间")
        let user = UserInfo
        self.setTime(format: TimeFormat(rawValue: UInt8(user.timeFormat))!, completion: nil)
        self.isManagerSync = true
    }
    
    func syncDeivceLanguage() {
        let admin = AdminHelper.shared.loadLocalAdminData()
        print("同步语言")
        let curLanguage = AppSettings.Language(rawValue: admin.device.languageRaw)!
        self.setLanguage(curLanguage, timeFormat: TimeFormat(rawValue: UInt8(admin.userInfo.timeFormat))!, screenOnTime: 5, pair: 0, completion: nil)
        self.isManagerSync = true
    }
    
    func syncMessagePush() {
        let user = UserInfo
        print("同步消息推送")
        BluetoothManager.shared.setMessagePush(user.push, completion: nil)
        self.isManagerSync = true
    }
    
    func setMenstrualStatus() {
        print("同步月经")
//        print(MenstrualCalendarModel.getAllDate())
        let menstrual = MenstrualCalendarModel.getAllDate()
        let selectedDate = DateInRegion().date.dateAtStartOf(.day)
        let menstrualModel: MenstrualModel = UserInfo.menstrual
        if menstrual.count > 0 {
            if let model = MenstrualCalendarModel.getDate(DateInRegion().date.dateAtStartOf(.day)) {
                self.setMenstrual(model, completion: nil)
                self.isManagerSync = true
            } else {
                let n: Int = (selectedDate - MenstrualCalendarModel.getLastMenstrual()!.date!.dateAtStartOf(.day)).in(.day) ?? 0
                for i in 0..<n {
                    let menstrualData = MenstrualCalendarModel()
                    let date = selectedDate - i.days
                    let result = getDateTypeAndPosition(menstrualModel, date: date)
                    menstrualData.date = date
                    menstrualData.position = result.position
                    menstrualData.type = result.type
                    menstrualData.dateStr = date.toString(.custom("yyyy.MM.dd"))
                    menstrualData.whichDay = result.whichDay
                    menstrualData.days = result.days
                    menstrualData.add()
                }
                if let model1 = MenstrualCalendarModel.getDate(DateInRegion().date.dateAtStartOf(.day)) {
                    self.setMenstrual(model1, completion: nil)
                    self.isManagerSync = true
                }
            }
        }
        if let model = MenstrualCalendarModel.getDate(DateInRegion().date.dateAtStartOf(.day)) {
            self.setMenstrual(model, completion: nil)
            self.isManagerSync = true
        } else {
            firstSyncDone()
        }
    }
    
  
    
//    func syncDeviceTime() {
//        let device = CurDevice
//        print("同步时间")
//        self.setTime(format: TimeFormat(rawValue: UInt8(device.timeFormat))!) {[weak self] error in
//            self?.syncDeivceLanguage()
//        }
//    }
    
    func firstSyncDone() {
        for delegate in self.syncDelegateList {
            delegate.firstSync()
        }
    }
    
    
}