universal_ble/darwin/Classes/UniversalBle.g.swift

// Autogenerated from Pigeon (v13.0.0), do not edit directly.
// See also: https://pub.dev/packages/pigeon

import Foundation
#if os(iOS)
import Flutter
#elseif os(macOS)
import FlutterMacOS
#else
#error("Unsupported platform.")
#endif

private func isNullish(_ value: Any?) -> Bool {
  return value is NSNull || value == nil
}

private func wrapResult(_ result: Any?) -> [Any?] {
  return [result]
}

private func wrapError(_ error: Any) -> [Any?] {
  if let flutterError = error as? FlutterError {
    return [
      flutterError.code,
      flutterError.message,
      flutterError.details
    ]
  }
  return [
    "\(error)",
    "\(type(of: error))",
    "Stacktrace: \(Thread.callStackSymbols)"
  ]
}

private func nilOrValue<T>(_ value: Any?) -> T? {
  if value is NSNull { return nil }
  return value as! T?
}

/// Generated class from Pigeon that represents data sent in messages.
struct UniversalBleScanResult {
  var deviceId: String
  var name: String? = nil
  var isPaired: Bool? = nil
  var rssi: Int64? = nil
  var manufacturerData: FlutterStandardTypedData? = nil
  var manufacturerDataHead: FlutterStandardTypedData? = nil

  static func fromList(_ list: [Any?]) -> UniversalBleScanResult? {
    let deviceId = list[0] as! String
    let name: String? = nilOrValue(list[1])
    let isPaired: Bool? = nilOrValue(list[2])
    let rssi: Int64? = isNullish(list[3]) ? nil : (list[3] is Int64? ? list[3] as! Int64? : Int64(list[3] as! Int32))
    let manufacturerData: FlutterStandardTypedData? = nilOrValue(list[4])
    let manufacturerDataHead: FlutterStandardTypedData? = nilOrValue(list[5])

    return UniversalBleScanResult(
      deviceId: deviceId,
      name: name,
      isPaired: isPaired,
      rssi: rssi,
      manufacturerData: manufacturerData,
      manufacturerDataHead: manufacturerDataHead
    )
  }
  func toList() -> [Any?] {
    return [
      deviceId,
      name,
      isPaired,
      rssi,
      manufacturerData,
      manufacturerDataHead,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct UniversalBleService {
  var uuid: String
  var characteristics: [UniversalBleCharacteristic?]? = nil

  static func fromList(_ list: [Any?]) -> UniversalBleService? {
    let uuid = list[0] as! String
    let characteristics: [UniversalBleCharacteristic?]? = nilOrValue(list[1])

    return UniversalBleService(
      uuid: uuid,
      characteristics: characteristics
    )
  }
  func toList() -> [Any?] {
    return [
      uuid,
      characteristics,
    ]
  }
}

/// Generated class from Pigeon that represents data sent in messages.
struct UniversalBleCharacteristic {
  var uuid: String
  var properties: [Int64?]

  static func fromList(_ list: [Any?]) -> UniversalBleCharacteristic? {
    let uuid = list[0] as! String
    let properties = list[1] as! [Int64?]

    return UniversalBleCharacteristic(
      uuid: uuid,
      properties: properties
    )
  }
  func toList() -> [Any?] {
    return [
      uuid,
      properties,
    ]
  }
}

private class UniversalBlePlatformChannelCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
      case 128:
        return UniversalBleCharacteristic.fromList(self.readValue() as! [Any?])
      case 129:
        return UniversalBleScanResult.fromList(self.readValue() as! [Any?])
      case 130:
        return UniversalBleService.fromList(self.readValue() as! [Any?])
      default:
        return super.readValue(ofType: type)
    }
  }
}

private class UniversalBlePlatformChannelCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? UniversalBleCharacteristic {
      super.writeByte(128)
      super.writeValue(value.toList())
    } else if let value = value as? UniversalBleScanResult {
      super.writeByte(129)
      super.writeValue(value.toList())
    } else if let value = value as? UniversalBleService {
      super.writeByte(130)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

private class UniversalBlePlatformChannelCodecReaderWriter: FlutterStandardReaderWriter {
  override func reader(with data: Data) -> FlutterStandardReader {
    return UniversalBlePlatformChannelCodecReader(data: data)
  }

  override func writer(with data: NSMutableData) -> FlutterStandardWriter {
    return UniversalBlePlatformChannelCodecWriter(data: data)
  }
}

class UniversalBlePlatformChannelCodec: FlutterStandardMessageCodec {
  static let shared = UniversalBlePlatformChannelCodec(readerWriter: UniversalBlePlatformChannelCodecReaderWriter())
}

/// Flutter -> Native
///
/// Generated protocol from Pigeon that represents a handler of messages from Flutter.
protocol UniversalBlePlatformChannel {
  func getBluetoothAvailabilityState(completion: @escaping (Result<Int64, Error>) -> Void)
  func enableBluetooth(completion: @escaping (Result<Bool, Error>) -> Void)
  func startScan() throws
  func stopScan() throws
  func connect(deviceId: String) throws
  func disconnect(deviceId: String) throws
  func setNotifiable(deviceId: String, service: String, characteristic: String, bleInputProperty: Int64) throws
  func discoverServices(deviceId: String, completion: @escaping (Result<[UniversalBleService], Error>) -> Void)
  func readValue(deviceId: String, service: String, characteristic: String, completion: @escaping (Result<FlutterStandardTypedData, Error>) -> Void)
  func requestMtu(deviceId: String, expectedMtu: Int64, completion: @escaping (Result<Int64, Error>) -> Void)
  func writeValue(deviceId: String, service: String, characteristic: String, value: FlutterStandardTypedData, bleOutputProperty: Int64, completion: @escaping (Result<Void, Error>) -> Void)
  func isPaired(deviceId: String, completion: @escaping (Result<Bool, Error>) -> Void)
  func pair(deviceId: String) throws
  func unPair(deviceId: String) throws
  func getConnectedDevices(withServices: [String], completion: @escaping (Result<[UniversalBleScanResult], Error>) -> Void)
}

/// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
class UniversalBlePlatformChannelSetup {
  /// The codec used by UniversalBlePlatformChannel.
  static var codec: FlutterStandardMessageCodec { UniversalBlePlatformChannelCodec.shared }
  /// Sets up an instance of `UniversalBlePlatformChannel` to handle messages through the `binaryMessenger`.
  static func setUp(binaryMessenger: FlutterBinaryMessenger, api: UniversalBlePlatformChannel?) {
    let getBluetoothAvailabilityStateChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.getBluetoothAvailabilityState", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      getBluetoothAvailabilityStateChannel.setMessageHandler { _, reply in
        api.getBluetoothAvailabilityState() { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      getBluetoothAvailabilityStateChannel.setMessageHandler(nil)
    }
    let enableBluetoothChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.enableBluetooth", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      enableBluetoothChannel.setMessageHandler { _, reply in
        api.enableBluetooth() { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      enableBluetoothChannel.setMessageHandler(nil)
    }
    let startScanChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.startScan", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      startScanChannel.setMessageHandler { _, reply in
        do {
          try api.startScan()
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      startScanChannel.setMessageHandler(nil)
    }
    let stopScanChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.stopScan", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      stopScanChannel.setMessageHandler { _, reply in
        do {
          try api.stopScan()
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      stopScanChannel.setMessageHandler(nil)
    }
    let connectChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.connect", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      connectChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        do {
          try api.connect(deviceId: deviceIdArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      connectChannel.setMessageHandler(nil)
    }
    let disconnectChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.disconnect", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      disconnectChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        do {
          try api.disconnect(deviceId: deviceIdArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      disconnectChannel.setMessageHandler(nil)
    }
    let setNotifiableChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.setNotifiable", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      setNotifiableChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        let serviceArg = args[1] as! String
        let characteristicArg = args[2] as! String
        let bleInputPropertyArg = args[3] is Int64 ? args[3] as! Int64 : Int64(args[3] as! Int32)
        do {
          try api.setNotifiable(deviceId: deviceIdArg, service: serviceArg, characteristic: characteristicArg, bleInputProperty: bleInputPropertyArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      setNotifiableChannel.setMessageHandler(nil)
    }
    let discoverServicesChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.discoverServices", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      discoverServicesChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        api.discoverServices(deviceId: deviceIdArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      discoverServicesChannel.setMessageHandler(nil)
    }
    let readValueChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.readValue", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      readValueChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        let serviceArg = args[1] as! String
        let characteristicArg = args[2] as! String
        api.readValue(deviceId: deviceIdArg, service: serviceArg, characteristic: characteristicArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      readValueChannel.setMessageHandler(nil)
    }
    let requestMtuChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.requestMtu", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      requestMtuChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        let expectedMtuArg = args[1] is Int64 ? args[1] as! Int64 : Int64(args[1] as! Int32)
        api.requestMtu(deviceId: deviceIdArg, expectedMtu: expectedMtuArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      requestMtuChannel.setMessageHandler(nil)
    }
    let writeValueChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.writeValue", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      writeValueChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        let serviceArg = args[1] as! String
        let characteristicArg = args[2] as! String
        let valueArg = args[3] as! FlutterStandardTypedData
        let bleOutputPropertyArg = args[4] is Int64 ? args[4] as! Int64 : Int64(args[4] as! Int32)
        api.writeValue(deviceId: deviceIdArg, service: serviceArg, characteristic: characteristicArg, value: valueArg, bleOutputProperty: bleOutputPropertyArg) { result in
          switch result {
            case .success:
              reply(wrapResult(nil))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      writeValueChannel.setMessageHandler(nil)
    }
    let isPairedChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.isPaired", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      isPairedChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        api.isPaired(deviceId: deviceIdArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      isPairedChannel.setMessageHandler(nil)
    }
    let pairChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.pair", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      pairChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        do {
          try api.pair(deviceId: deviceIdArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      pairChannel.setMessageHandler(nil)
    }
    let unPairChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.unPair", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      unPairChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let deviceIdArg = args[0] as! String
        do {
          try api.unPair(deviceId: deviceIdArg)
          reply(wrapResult(nil))
        } catch {
          reply(wrapError(error))
        }
      }
    } else {
      unPairChannel.setMessageHandler(nil)
    }
    let getConnectedDevicesChannel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBlePlatformChannel.getConnectedDevices", binaryMessenger: binaryMessenger, codec: codec)
    if let api = api {
      getConnectedDevicesChannel.setMessageHandler { message, reply in
        let args = message as! [Any?]
        let withServicesArg = args[0] as! [String]
        api.getConnectedDevices(withServices: withServicesArg) { result in
          switch result {
            case .success(let res):
              reply(wrapResult(res))
            case .failure(let error):
              reply(wrapError(error))
          }
        }
      }
    } else {
      getConnectedDevicesChannel.setMessageHandler(nil)
    }
  }
}
private class UniversalBleCallbackChannelCodecReader: FlutterStandardReader {
  override func readValue(ofType type: UInt8) -> Any? {
    switch type {
      case 128:
        return UniversalBleScanResult.fromList(self.readValue() as! [Any?])
      default:
        return super.readValue(ofType: type)
    }
  }
}

private class UniversalBleCallbackChannelCodecWriter: FlutterStandardWriter {
  override func writeValue(_ value: Any) {
    if let value = value as? UniversalBleScanResult {
      super.writeByte(128)
      super.writeValue(value.toList())
    } else {
      super.writeValue(value)
    }
  }
}

private class UniversalBleCallbackChannelCodecReaderWriter: FlutterStandardReaderWriter {
  override func reader(with data: Data) -> FlutterStandardReader {
    return UniversalBleCallbackChannelCodecReader(data: data)
  }

  override func writer(with data: NSMutableData) -> FlutterStandardWriter {
    return UniversalBleCallbackChannelCodecWriter(data: data)
  }
}

class UniversalBleCallbackChannelCodec: FlutterStandardMessageCodec {
  static let shared = UniversalBleCallbackChannelCodec(readerWriter: UniversalBleCallbackChannelCodecReaderWriter())
}

/// Native -> Flutter
///
/// Generated protocol from Pigeon that represents Flutter messages that can be called from Swift.
protocol UniversalBleCallbackChannelProtocol {
  func onAvailabilityChanged(state stateArg: Int64, completion: @escaping (Result<Void, FlutterError>) -> Void) 
  func onPairStateChange(deviceId deviceIdArg: String, isPaired isPairedArg: Bool, error errorArg: String?, completion: @escaping (Result<Void, FlutterError>) -> Void) 
  func onScanResult(result resultArg: UniversalBleScanResult, completion: @escaping (Result<Void, FlutterError>) -> Void) 
  func onValueChanged(deviceId deviceIdArg: String, characteristicId characteristicIdArg: String, value valueArg: FlutterStandardTypedData, completion: @escaping (Result<Void, FlutterError>) -> Void) 
  func onConnectionChanged(deviceId deviceIdArg: String, state stateArg: Int64, completion: @escaping (Result<Void, FlutterError>) -> Void) 
}
class UniversalBleCallbackChannel: UniversalBleCallbackChannelProtocol {
  private let binaryMessenger: FlutterBinaryMessenger
  init(binaryMessenger: FlutterBinaryMessenger){
    self.binaryMessenger = binaryMessenger
  }
  var codec: FlutterStandardMessageCodec {
    return UniversalBleCallbackChannelCodec.shared
  }
  func onAvailabilityChanged(state stateArg: Int64, completion: @escaping (Result<Void, FlutterError>) -> Void)  {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBleCallbackChannel.onAvailabilityChanged", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([stateArg] as [Any?]) { _ in
      completion(.success(Void()))
    }
  }
  func onPairStateChange(deviceId deviceIdArg: String, isPaired isPairedArg: Bool, error errorArg: String?, completion: @escaping (Result<Void, FlutterError>) -> Void)  {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBleCallbackChannel.onPairStateChange", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([deviceIdArg, isPairedArg, errorArg] as [Any?]) { _ in
      completion(.success(Void()))
    }
  }
  func onScanResult(result resultArg: UniversalBleScanResult, completion: @escaping (Result<Void, FlutterError>) -> Void)  {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBleCallbackChannel.onScanResult", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([resultArg] as [Any?]) { _ in
      completion(.success(Void()))
    }
  }
  func onValueChanged(deviceId deviceIdArg: String, characteristicId characteristicIdArg: String, value valueArg: FlutterStandardTypedData, completion: @escaping (Result<Void, FlutterError>) -> Void)  {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBleCallbackChannel.onValueChanged", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([deviceIdArg, characteristicIdArg, valueArg] as [Any?]) { _ in
      completion(.success(Void()))
    }
  }
  func onConnectionChanged(deviceId deviceIdArg: String, state stateArg: Int64, completion: @escaping (Result<Void, FlutterError>) -> Void)  {
    let channel = FlutterBasicMessageChannel(name: "dev.flutter.pigeon.universal_ble.UniversalBleCallbackChannel.onConnectionChanged", binaryMessenger: binaryMessenger, codec: codec)
    channel.sendMessage([deviceIdArg, stateArg] as [Any?]) { _ in
      completion(.success(Void()))
    }
  }
}