class TrackableView: UIView {
    var counter: Int = 0
 
    override func layoutSubviews() {
        super.layoutSubviews()
 
        counter += 1;
        if (counter == 100) {
            YourAnalyticsFramework.event(name: "loop")
        }
    }
}

struct LayoutLoopHunter {
 
    struct RuntimeConstants {
        static let Prefix = “runtime”
    }
 
    static func setUp(for view: UIView, threshold: Int = 100, onLoop: @escaping () -> ()) {
        // 我们根据功能的前缀和原始类名为新类创建名称。
        let classFullName = “\(RuntimeConstants.Prefix)_\(String(describing: view.self))”
        let originalClass = type(of: view)
 
        if let trackableClass = objc_allocateClassPair(originalClass, classFullName, 0) {
            // 在当前运行时会话期间尚未创建此类。
            // 注册这个类，并且用原始视图的类来和它交换。
            objc_registerClassPair(trackableClass)
            object_setClass(view, trackableClass)
        } else if let trackableClass = NSClassFromString(classFullName) {
            // 我们之前在此运行时会话中分配了一个具有相同名称的类。
            // 我们可以从原始字符串中获取它，并以相同的方式与我们的视图交换。
            object_setClass(view, trackableClass)
        }
    }
}

static var CounterKey = "_counter"
 
...
 
objc_setAssociatedObject(trackableClass, &RuntimeConstants.CounterKey, 0, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

let layoutSubviews: @convention(block) (Any?) -> () = { nullableSelf in
    guard let _self = nullableSelf else { return }
 
    if let counter = objc_getAssociatedObject(_self, &RuntimeConstants.CounterKey) as? Int {
        if counter == threshold {
            onLoop()
        }
 
        objc_setAssociatedObject(trackableClass, &RuntimeConstants.CounterKey, counter+1, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
    }
}
let implementation = imp_implementationWithBlock(layoutSubviews)
class_addMethod(trackableClass, #selector(originalClass.layoutSubviews), implementation, "v@:")

struct objc_method {
    SEL method_name;
    char *method_types;
    IMP method_imp;
}

class_addMethod(trackableClass,#selector(originalClass.layoutSubviews), implementation, "v@:")

static var CounterKey = “_counter”
...
 
objc_setAssociatedObject(trackableClass, &RuntimeConstants.CounterKey, counter+1, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

func printAddress(_ string: UnsafeRawPointer) {
    print("\(string)")
}

let str = "test"

printAddress(str)
printAddress(str)
let closure = {
    printAddress(str)
    printAddress(str)
}
closure()
// 最后两个函数调用的地址将始终不同

let selector = #selector(originalClass.layoutSubviews)
let originalImpl = class_getMethodImplementation(originalClass, selector)
 

// @convention(c) 告知 Swift 这是一个裸函数指针（没有上下文对象）
// 所有的 Obj-C 方法函数把接收者和消息当作前两个参数
// 所以这意味着一个类型为 `() -> Void` 的方法，这与 `layoutSubview` 方法相符
typealias ObjCVoidVoidFn = @convention(c) (Any, Selector) -> Void
let originalLayoutSubviews = unsafeBitCast(originalImpl, to: ObjCVoidVoidFn.self)
originalLayoutSubviews(view, selector)

static func setUp(for view: UIView, threshold: Int = 100, onLoop: @escaping () -> ()) {
    // 我们根据功能的前缀和原始类名为新类创建名称
    let classFullName = “\(RuntimeConstants.Prefix)_\(String(describing: view.self))”
    let originalClass = type(of: view)

    if let trackableClass = objc_allocateClassPair(originalClass, classFullName, 0) {
        // 在当前运行时会话期间尚未创建此类
        // 注册这个类并将其与原始视图的类交换
        objc_registerClassPair(trackableClass)
        object_setClass(view, trackableClass)

        // 现在可以创建关联对象
        objc_setAssociatedObject(view, &RuntimeConstants.CounterKey, 0, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

        // 添加我们自己 layoutSubviews 的实现
        let layoutSubviews: @convention(block) (Any?) -> () = { nullableSelf in
            guard let _self = nullableSelf else { return }

            let selector = #selector(originalClass.layoutSubviews)
            let originalImpl = class_getMethodImplementation(originalClass, selector)

        
            // @convention(c) 告知 Swift 这是一个裸函数指针（没有上下文对象）
            // 所有的 Obj-C 方法函数把接收者和消息当作前两个参数
            // 所以这意味着一个类型为 `() -> Void` 的方法，这与 `layoutSubview` 方法相符
            typealias ObjCVoidVoidFn = @convention(c) (Any, Selector) -> Void
            let originalLayoutSubviews = unsafeBitCast(originalImpl, to: ObjCVoidVoidFn.self)
            originalLayoutSubviews(view, selector)

            if let counter = objc_getAssociatedObject(_self, &RuntimeConstants.CounterKey) as? Int {
                if counter == threshold {
                    onLoop()
                }

                objc_setAssociatedObject(view, &RuntimeConstants.CounterKey, counter+1, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            }
        }
        let implementation = imp_implementationWithBlock(layoutSubviews)
        class_addMethod(trackableClass, #selector(originalClass.layoutSubviews), implementation, “v@:“)
    } else if let trackableClass = NSClassFromString(classFullName) {
        // 我们之前在此运行时会话中分配了一个具有相同名称的类
        // 我们可以从原始字符串中获取它，并以相同的方式与我们的视图交换
        object_setClass(view, trackableClass)
    }
}

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
 
        LayoutLoopHunter.setUp(for: view) {
            print("Hello, world")
        }
    }
 
    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        view.setNeedsLayout() // loop creation
    }
}

static var ResetWorkItemKey = “_resetWorkItem”
 
...
 
if let previousResetWorkItem = objc_getAssociatedObject(view, &RuntimeConstants.ResetWorkItemKey) as? DispatchWorkItem {
    previousResetWorkItem.cancel()
}
let currentResetWorkItem = DispatchWorkItem { [weak view] in
    guard let strongView = view else { return }
    objc_setAssociatedObject(strongView, &RuntimeConstants.CounterKey, 0, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
}
DispatchQueue.main.async(execute: currentResetWorkItem)
objc_setAssociatedObject(view, &RuntimeConstants.ResetWorkItemKey, currentResetWorkItem, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

struct LayoutLoopHunter {
 
    struct RuntimeConstants {
        static let Prefix = “runtime”
 
        // Associated objects keys
        // 关联对象键
        static var CounterKey = “_counter”
        static var ResetWorkItemKey = “_resetWorkItem”
    }
 
    static func setUp(for view: UIView, threshold: Int = 100, onLoop: @escaping () -> ()) {
        // 我们根据功能的前缀和原始类名为新类创建名称。
        let classFullName = “\(RuntimeConstants.Prefix)_\(String(describing: view.self))”
        let originalClass = type(of: view)
 
        if let trackableClass = objc_allocateClassPair(originalClass, classFullName, 0) {
            // 在当前运行时会话期间尚未创建此类。
            // 注册这个类，并且用原始视图的类来和它交换。
            objc_registerClassPair(trackableClass)
            object_setClass(view, trackableClass)
 
            // 现在可以创建关联对象
            objc_setAssociatedObject(view, &RuntimeConstants.CounterKey, 0, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
 
            // 添加我们自己 layoutSubviews 的实现
            let layoutSubviews: @convention(block) (Any?) -> () = { nullableSelf in
                guard let _self = nullableSelf else { return }
 
                let selector = #selector(originalClass.layoutSubviews)
                let originalImpl = class_getMethodImplementation(originalClass, selector)
 
                // @convention(c) 告知 Swift 这是一个裸函数指针（没有上下文对象）
                // 所有的 Obj-C 方法函数把接收者和消息当作前两个参数
                // 所以这意味着一个类型为 `() -> Void` 的方法，这与 `layoutSubview` 方法相符
                typealias ObjCVoidVoidFn = @convention(c) (Any, Selector) -> Void
                let originalLayoutSubviews = unsafeBitCast(originalImpl, to: ObjCVoidVoidFn.self)
                originalLayoutSubviews(view, selector)
 
                if let counter = objc_getAssociatedObject(_self, &RuntimeConstants.CounterKey) as? Int {
                    if counter == threshold {
                        onLoop()
                    }
 
                    objc_setAssociatedObject(view, &RuntimeConstants.CounterKey, counter+1, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
                }
 
                // 为重置计数器，在每个新的 run loop 遍历中分发 work item
                if let previousResetWorkItem = objc_getAssociatedObject(view, &RuntimeConstants.ResetWorkItemKey) as? DispatchWorkItem {
                    previousResetWorkItem.cancel()
                }
                let counterResetWorkItem = DispatchWorkItem { [weak view] in
                    guard let strongView = view else { return }
                    objc_setAssociatedObject(strongView, &RuntimeConstants.CounterKey, 0, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
                }
                DispatchQueue.main.async(execute: counterResetWorkItem)
                objc_setAssociatedObject(view, &RuntimeConstants.ResetWorkItemKey, counterResetWorkItem, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
            }
            let implementation = imp_implementationWithBlock(layoutSubviews)
            class_addMethod(trackableClass, #selector(originalClass.layoutSubviews), implementation, “v@:“)
        } else if let trackableClass = NSClassFromString(classFullName) {
            // 我们之前在此运行时会话中分配了一个具有相同名称的类。
            // 我们可以从原始字符串中获取它，并以相同的方式与我们的视图交换。
            object_setClass(view, trackableClass)
        }
    }
}

protocol Queue {
  associatedtype DataType: Comparable

  /**
  将一个新元素插入到队列中。
  - 参数 item：要添加的元素。
  - 返回值：插入是否成功。
  */
  @discardableResult func add(_ item: DataType) -> Bool

  /**
  删除首个元素。
  - 返回值：被移除的元素。
  - 抛出值：QueueError 类型的错误。
  */
  @discardableResult func remove() throws -> DataType

  /**
  获取到队列中的首个元素，并将其移出队列。
  - 返回值：一个包含队列中首个元素的可选值。
  */
  func dequeue() -> DataType?

  /**
  获取队列中的首个元素，但不将它移出队列。
  - 返回值：一个包含队列中首个元素的可选值。
  */
  func peek() -> DataType?

  /**
  清空队列。
  */
  func clear() -> Void
}

enum QueueError: Error {
  case noSuchItem(String)
}

/**
 基于堆数据结构的 PriorityQueue 实现。
*/

class PriorityQueue<DataType: Comparable> {

  /**
   队列的存储。
  */
  private var queue: Array<DataType>
  
  /**
   当前队列的大小。
  */
  public var size: Int {
    return self.queue.count
  }
  
  public init() {
    self.queue = Array<DataType>()
  }
}

private extension Int {
  var leftChild: Int {
    return (2 * self) + 1
  }
  
  var rightChild: Int {
    return (2 * self) + 2
  }
  
  var parent: Int {
    return (self - 1) / 2
  }
}

extension PriorityQueue: Queue {
  @discardableResult
  public func add(_ item: DataType) -> Bool {
    self.queue.append(item)
    self.heapifyUp(from: self.queue.count - 1)
    return true
  }
  
  @discardableResult
  public func remove() throws -> DataType {
    guard self.queue.count > 0 else {
      throw QueueError.noSuchItem("Attempt to remove item from an empty queue.")
    }
    return self.popAndHeapifyDown()
  }
  
  public func dequeue() -> DataType? {
    guard self.queue.count > 0 else {
      return nil
    }
    return self.popAndHeapifyDown()
  }
  
  public func peek() -> DataType? {
    return self.queue.first
  }
  
  public func clear() {
    self.queue.removeAll()
  }
  
  /**
  弹出队列中的第一个元素，并通过将根元素移向队尾的方式恢复最小堆排序。
  - 返回值: 队列中的第一个元素。
  */
  private func popAndHeapifyDown() -> DataType {
    let firstItem = self.queue[0]
    
    if self.queue.count == 1 {
      self.queue.remove(at: 0)
      return firstItem
    }
    
    self.queue[0] = self.queue.remove(at: self.queue.count - 1)
    
    self.heapifyDown()
    
    return firstItem
  }
  
  /**
   通过将元素移向队头的方式恢复最小堆排序。
   - 参数 index: 要移动的元素的索引值。
   */
  private func heapifyUp(from index: Int) {
    var child = index
    var parent = child.parent
    
    while parent >= 0 && self.queue[parent] > self.queue[child] {
      swap(parent, with: child)
      child = parent
      parent = child.parent
    }
  }
  
  /**
   通过将根元素移向队尾的方式恢复队列的最小堆排序。
   */
  private func heapifyDown() {
    var parent = 0
    
    while true {
      let leftChild = parent.leftChild
      if leftChild >= self.queue.count {
        break
      }
      
      let rightChild = parent.rightChild
      var minChild = leftChild
      if rightChild < self.queue.count && self.queue[minChild] > self.queue[rightChild] {
        minChild = rightChild
      }
      
      if self.queue[parent] > self.queue[minChild] {
        self.swap(parent, with: minChild)
        parent = minChild
      } else {
        break
      }
    }
  }
  
  /**
   交换存储中位于两处索引值位置的元素。
   - 参数 firstIndex：第一个要交换元素的索引。
   - 参数 secondIndex：第二个要交换元素的索引。
   */
  private func swap(_ firstIndex: Int, with secondIndex: Int) {
    let firstItem = self.queue[firstIndex]
    self.queue[firstIndex] = self.queue[secondIndex]
    self.queue[secondIndex] = firstItem
  }
}

extension PriorityQueue: CustomStringConvertible {
  public var description: String {
    return self.queue.description
  }
}

centralManager?.scanForPeripherals(withServices: nil)

import UIKit

// STEP 0.00: 必须导入 CoreBluetooth framework
import CoreBluetooth

// STEP 0.0: 指定 GATT 中的 "Assigned Numbers" 为常量，这样它们会拥有更好的可读性和可维护性

// MARK: - Core Bluetooth 服务 ID
let BLE_Heart_Rate_Service_CBUUID = CBUUID(string: "0x180D")

// MARK: - Core Bluetooth 特征 ID
let BLE_Heart_Rate_Measurement_Characteristic_CBUUID = CBUUID(string: "0x2A37")
let BLE_Body_Sensor_Location_Characteristic_CBUUID = CBUUID(string: "0x2A38")

// STEP 0.1: 这个类同时采用了控制中心和外围设备的委托协议，所以必须遵守这些协议的要求
class HeartRateMonitorViewController: UIViewController, CBCentralManagerDelegate, CBPeripheralDelegate {
    
    // MARK: - Core Bluetooth 类的成员变量
    
    // STEP 0.2: 分别创建 CBCentralManager 和 CBPeripheral 的实例变量
    // 所以它们在应用程序的生命周期里持续存在
    var centralManager: CBCentralManager?
    var peripheralHeartRateMonitor: CBPeripheral?
    
    // MARK: - UI outlets / 成员变量
    
    @IBOutlet weak var connectingActivityIndicator: UIActivityIndicatorView!
    @IBOutlet weak var connectionStatusView: UIView!
    @IBOutlet weak var brandNameTextField: UITextField!
    @IBOutlet weak var sensorLocationTextField: UITextField!
    @IBOutlet weak var beatsPerMinuteLabel: UILabel!
    @IBOutlet weak var bluetoothOffLabel: UILabel!
    
    // 设置 HealthKit 
    let healthKitInterface = HealthKitInterface()
    
    // MARK: - UIViewController delegate
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // 在视图加载完成以后，通常是通过一个 nib，做所有附加的设置。
        
        // 最初，我们在进行扫描并且没有产生连接
        connectingActivityIndicator.backgroundColor = UIColor.white
        connectingActivityIndicator.startAnimating()
        connectionStatusView.backgroundColor = UIColor.red
        brandNameTextField.text = "----"
        sensorLocationTextField.text = "----"
        beatsPerMinuteLabel.text = "---"
        // 以防 Bluetooth 被关闭
        bluetoothOffLabel.alpha = 0.0
        
        // STEP 1: 为控制中心在后台创建一个并发队列
        let centralQueue: DispatchQueue = DispatchQueue(label: "com.iosbrain.centralQueueName", attributes: .concurrent)
        // STEP 2: 创建用于扫描、连接、管理和从外围设备收集数据的控制中心。
        centralManager = CBCentralManager(delegate: self, queue: centralQueue)
        
        // 从 HKHealthStore 读取心率数据
        // healthKitInterface.readHeartRateData()
        
        // 从 HKHealthStore 读取性别类型
        // healthKitInterface.readGenderType()
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // 处理任何可以重新创建的资源
    }
    
    // MARK: - CBCentralManagerDelegate methods

    // STEP 3.1: 这个方法的调用基于设备的蓝牙状态； 
    // 仅在 Bluetooth 为 .poweredOn 时才可以扫描外围设备
    func centralManagerDidUpdateState(_ central: CBCentralManager) {
        
        switch central.state {
        
        case .unknown:
            print("Bluetooth status is UNKNOWN")
            bluetoothOffLabel.alpha = 1.0
        case .resetting:
            print("Bluetooth status is RESETTING")
            bluetoothOffLabel.alpha = 1.0
        case .unsupported:
            print("Bluetooth status is UNSUPPORTED")
            bluetoothOffLabel.alpha = 1.0
        case .unauthorized:
            print("Bluetooth status is UNAUTHORIZED")
            bluetoothOffLabel.alpha = 1.0
        case .poweredOff:
            print("Bluetooth status is POWERED OFF")
            bluetoothOffLabel.alpha = 1.0
        case .poweredOn:
            print("Bluetooth status is POWERED ON")
            
            DispatchQueue.main.async { () -> Void in
                self.bluetoothOffLabel.alpha = 0.0
                self.connectingActivityIndicator.startAnimating()
            }
            
            // STEP 3.2: 扫描我们感兴趣的外围设备
            centralManager?.scanForPeripherals(withServices: [BLE_Heart_Rate_Service_CBUUID])
            
        } // END switch
        
    } // END func centralManagerDidUpdateState
    
    // STEP 4.1: 找到这个应用程序可以连接哪些感兴趣的外围设备
    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
        
        print(peripheral.name!)
        decodePeripheralState(peripheralState: peripheral.state)
        // STEP 4.2: 必须储存一个外围设备的引用到类的实例变量中
        peripheralHeartRateMonitor = peripheral
        // STEP 4.3: 因为 HeartRateMonitorViewController 采用了 CBPeripheralDelegate 协议，
        // 所以 peripheralHeartRateMonitor 必须设置他的 
        // delegate 属性为 HeartRateMonitorViewController (self)
        peripheralHeartRateMonitor?.delegate = self
        
        // STEP 5: 停止扫描以保护电池的寿命；当断开链接的时候再次扫描。
        centralManager?.stopScan()
        
        // STEP 6: 与已经发现的，感兴趣的外围设备建立连接
        centralManager?.connect(peripheralHeartRateMonitor!)
        
    } // END func centralManager(... didDiscover peripheral
    
    // STEP 7: “当一个与外围设备的连接被成功创建时调用。”
    // 只有当我们知道与外围设备的连接建立成功之后才能前往下一步
    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
        
        DispatchQueue.main.async { () -> Void in
            
            self.brandNameTextField.text = peripheral.name!
            self.connectionStatusView.backgroundColor = UIColor.green
            self.beatsPerMinuteLabel.text = "---"
            self.sensorLocationTextField.text = "----"
            self.connectingActivityIndicator.stopAnimating()
            
        }
        
        // STEP 8: 在外围设备上寻找感兴趣的服务
        peripheralHeartRateMonitor?.discoverServices([BLE_Heart_Rate_Service_CBUUID])

    } // END func centralManager(... didConnect peripheral
    
    // STEP 15: 当一个外围设备断开连接，使用适当的方法
    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
        
        // print("Disconnected!")
        
        DispatchQueue.main.async { () -> Void in
            
            self.brandNameTextField.text = "----"
            self.connectionStatusView.backgroundColor = UIColor.red
            self.beatsPerMinuteLabel.text = "---"
            self.sensorLocationTextField.text = "----"
            self.connectingActivityIndicator.startAnimating()
            
        }
        
        // STEP 16: 在这个用例中，开始扫描相同或其他的外设，只要它们是 HRM，就可以重新联机
        centralManager?.scanForPeripherals(withServices: [BLE_Heart_Rate_Service_CBUUID])
        
    } // END func centralManager(... didDisconnectPeripheral peripheral

    // MARK: - CBPeripheralDelegate methods
    
    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
        
        for service in peripheral.services! {
            
            if service.uuid == BLE_Heart_Rate_Service_CBUUID {
                
                print("Service: \(service)")
                
                // STEP 9: 在感兴趣的服务中寻找感兴趣的特征
                peripheral.discoverCharacteristics(nil, for: service)
                
            }
            
        }
        
    } // END func peripheral(... didDiscoverServices
    
    // STEP 10: 从感兴趣的服务中，确认我们所发现感兴趣的特征
    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
        
        for characteristic in service.characteristics! {
            print(characteristic)
            
            if characteristic.uuid == BLE_Body_Sensor_Location_Characteristic_CBUUID {
                
                // STEP 11: 订阅关于感兴趣特征的单次通知；
                // “当你使用这个方法去读取特征的值时，外围设备将会调用…… 
                // peripheral:didUpdateValueForCharacteristic:error:”
                //
                // Read    Mandatory
                //
                peripheral.readValue(for: characteristic)
                
            }

            if characteristic.uuid == BLE_Heart_Rate_Measurement_Characteristic_CBUUID {

                // STEP 11: 订阅关于感兴趣特征的持续通知；
                // “当你启用特征值的通知时，外围设备调用……
                // peripheral(_:didUpdateValueFor:error:)” 
                //
                // Notify    Mandatory
                //
                peripheral.setNotifyValue(true, for: characteristic)
                
            }
            
        } // END for
        
    } // END func peripheral(... didDiscoverCharacteristicsFor service
    
    // STEP 12: 每当一个特征值定期更新或者发布一次时，我们都会收到通知；
    // 阅读并解译我们订阅的特征值
    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
        
        if characteristic.uuid == BLE_Heart_Rate_Measurement_Characteristic_CBUUID {
            
            // STEP 13: 通常我们需要将 BLE 的数据解析成人类可读的格式
            let heartRate = deriveBeatsPerMinute(using: characteristic)
            
            DispatchQueue.main.async { () -> Void in
                
                UIView.animate(withDuration: 1.0, animations: {
                    self.beatsPerMinuteLabel.alpha = 1.0
                    self.beatsPerMinuteLabel.text = String(heartRate)
                }, completion: { (true) in
                    self.beatsPerMinuteLabel.alpha = 0.0
                })
                
            } // END DispatchQueue.main.async...

        } // END if characteristic.uuid ==...
        
        if characteristic.uuid == BLE_Body_Sensor_Location_Characteristic_CBUUID {
            
            // STEP 14: 通常我们需要将 BLE 的数据解析成人类可读的格式
            let sensorLocation = readSensorLocation(using: characteristic)

            DispatchQueue.main.async { () -> Void in
                self.sensorLocationTextField.text = sensorLocation
            }
        } // END if characteristic.uuid ==...
        
    } // END func peripheral(... didUpdateValueFor characteristic
    
    // MARK: - Utilities
    
    func deriveBeatsPerMinute(using heartRateMeasurementCharacteristic: CBCharacteristic) -> Int {
        
        let heartRateValue = heartRateMeasurementCharacteristic.value!
        // 转换为无符号 8 位整数数组
        let buffer = [UInt8](heartRateValue)

        // UInt8: “一个 8 位无符号整数类型。”
        
        // 在缓冲区的第一个字节（8 位）是标记（元数据，用于管理包中其余部分）；
        // 如果最低有效位（LSB）是 0，心率（bpm）则是 UInt8 格式，
        // 如果 LSB 是 1，BPM 则是 UInt16
        if ((buffer[0] & 0x01) == 0) {
            // 第二个字节：“心率的格式被设置为 UINT8”
            print("BPM is UInt8")
            // 将心率写入 HKHealthStore
            // healthKitInterface.writeHeartRateData(heartRate: Int(buffer[1]))
            return Int(buffer[1])
        } else { // 我从来没有看到过这个用例，所以我把它留给理论学家去争论
            // 第二个和第三个字节：“心率的格式被设置为 UINT16”
            print("BPM is UInt16")
            return -1
        }
        
    } // END func deriveBeatsPerMinute
    
    func readSensorLocation(using sensorLocationCharacteristic: CBCharacteristic) -> String {
        
        let sensorLocationValue = sensorLocationCharacteristic.value!
        //  转换为无符号 8 位整数数组
        let buffer = [UInt8](sensorLocationValue)
        var sensorLocation = ""
        
        // 只看 8 位
        if buffer[0] == 1
        {
            sensorLocation = "Chest"
        }
        else if buffer[0] == 2
        {
            sensorLocation = "Wrist"
        }
        else
        {
            sensorLocation = "N/A"
        }
        
        return sensorLocation
        
    } // END func readSensorLocation
    
    func decodePeripheralState(peripheralState: CBPeripheralState) {
        
        switch peripheralState {
            case .disconnected:
                print("Peripheral state: disconnected")
            case .connected:
                print("Peripheral state: connected")
            case .connecting:
                print("Peripheral state: connecting")
            case .disconnecting:
                print("Peripheral state: disconnecting")
        }
        
    } // END func decodePeripheralState(peripheralState

} // END class HeartRateMonitorViewController