@iotize/device-com-ble.cordova 3.6.2-alpha.2 → 3.6.4

package/src/ios/BLECom.swift

@@ -1,732 +1,744 @@
-//
-//  Copyright 2018 IoTize SAS Inc.  Licensed under the MIT license. 
-//
-//  BLECom.swift
-//  device-com-ble.cordova BLE Cordova Plugin
-//
-
-import Foundation
-import CoreBluetooth
-
-// Custom debug print functions
-
-public func printBLE(_ object: Any...) {
-    #if true
-    for item in object {
-        Swift.print("BLE:", item)
-    }
-    #endif
-}
-
-public func printBLE(_ object: Any) {
-    #if true
-    Swift.print("BLE:", object)
-    #endif
-}
-
-
-struct IoTizeBleError: Error {
-    
-    let code: Int
-    let message: String
-    
-    init(code: Int, message: String) {
-        self.code = code
-        self.message = message
-    }
-    
-    static func BleUnsupported() -> IoTizeBleError { return IoTizeBleError(code:100, message:"Bluetooth is not supported")}
-    static func BleUnauthorized() -> IoTizeBleError { return IoTizeBleError(code:101, message:"Bluetooth is not authorized")}
-    static func BlePoweredOff() -> IoTizeBleError { return IoTizeBleError(code:102, message:"Bluetooth is powered off")}
-    static func BleResetting() -> IoTizeBleError { return IoTizeBleError(code:103, message:"Bluetooth is resetting")}
-    static func BleUnknown() -> IoTizeBleError { return IoTizeBleError(code:104, message:"Bluetooth is in an unknown state")}
-    
-    static func PeripheralConnectionFailed(peripheral: CBPeripheral, error: Error?) -> IoTizeBleError { return IoTizeBleError(code:200, message:"Connection to \(peripheral.name ?? "unknown peripheral") failed: \(error?.localizedDescription ?? "unknown")" )}
-    static func NoDeviceConnected() -> IoTizeBleError { return IoTizeBleError(code:201, message:"No Device Connected")}
-    
-    static func ServiceDiscoveryFailed(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:300, message:"Failed to discover services for \(peripheral.name ?? "unknown peripheral")" )}
-    static func CharacteristicsDiscoveryFailed(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:301, message:"Failed to discover characteristics for \(peripheral.name ?? "unknown peripheral")" )}
-    static func CharacteristicSPPNotFound(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:302, message:"Characteristic SPP not found for \(peripheral.name ?? "unknown peripheral")" )}
-    static func CharacteristicNotifyChangeFailed() -> IoTizeBleError { return IoTizeBleError(code:304, message:"Failed to set notification for characteristic" )}
-    static func BleVersionIsOld(version: String) -> IoTizeBleError { return IoTizeBleError(code:303, message:"BLE firmware version is too old: \(version)" )}
-    
-    static func InvalidWriteData(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:403, message:"Invalid write data for \(peripheral.name ?? "unknown peripheral")" )}
-    static func TimedOutRequest(msg: String) -> IoTizeBleError { return IoTizeBleError(code:404, message:"Waiting for response timed out, txData: " + msg )}
-        
-}
-
-enum CordovaBLEErrorCode: CustomStringConvertible {
-    case InternalError
-    case IllegalArgument
-    
-    var description: String {
-        switch self {
-        case .InternalError: return "CordovaBLEErrorInternalError"
-        case .IllegalArgument: return "CordovaBLEErrorIllegalArgument"
-        }
-    }
-}
-
-struct CordovaBLEError: Error {
-    var code: CordovaBLEErrorCode
-    var message: String
-    
-    init(_ code: CordovaBLEErrorCode, _ message: String) {
-        self.code = code
-        self.message = message
-    }
-    
-    func toJSON() -> [AnyHashable: Any] {
-        return ["code": code.description, "message": message]
-    }
-    
-    static func InternalError(_ message: String) -> CordovaBLEError {return CordovaBLEError(.InternalError, message)}
-    
-    static func IllegalArgument(_ message: String) -> CordovaBLEError {return CordovaBLEError(.IllegalArgument, message)}
-}
-
-struct BLEAction {
-    var id: String
-    var action: () -> Void
-    
-    init(_ id: String, _ action: @escaping () -> Void) {
-        self.id = id
-        self.action = action
-    }
-}
-
-//Main class handling the plugin functionalities.
-@objc(BLECom) class BLECom : CDVPlugin {
-    
-    var bleActionQueue: Queue<BLEAction>!
-    
-    var isHandlingQueue = false
-    
-    var bleController: BLEManager!
-    var lastError: IoTizeBleError?
-    
-    //
-    override func pluginInitialize(){
-        bleController = BLEManager()
-        bleActionQueue = Queue<BLEAction>()
-    }
-    
-    //helper to return an empty response
-    func sendSuccessWithoutResponse(command: CDVInvokedUrlCommand) {
-        let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK)
-        
-        self.commandDelegate!.send(pluginResult, callbackId: command.callbackId)
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }
-    }
-    
-    //helper to return a string 
-    func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: String){
-        let pluginResult =  CDVPluginResult(
-            status: CDVCommandStatus_OK,
-            messageAs: result
-        )
-        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }
-    }
-    
-    //helper to return a boolean 
-    private func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: Bool) {
-        let pluginResult = CDVPluginResult(
-            status: CDVCommandStatus_OK,
-            messageAs: result
-        )
-        self.commandDelegate!.send(pluginResult, callbackId: command.callbackId)
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }
-    }
-    
-    //helper to return a JSon object 
-    func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: DiscoveredDeviceType){
-        let pluginResult =  CDVPluginResult(
-            status: CDVCommandStatus_OK,
-            messageAs: result.ToJSON()
-        )
-        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }
-    }
-    
-    //helper to return a String with keeping the callback
-    func sendSuccessWithMultipleResponse(command: CDVInvokedUrlCommand, result: String){
-        let pluginResult =  CDVPluginResult(
-            status: CDVCommandStatus_OK,
-            messageAs: result
-        )
-        pluginResult!.setKeepCallbackAs(true);
-        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId )
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }
-    }
-    
-    //helper to return a JSon DiscoveredDeviceType object with keeping the callback
-    func sendSuccessWithMultipleResponse(command: CDVInvokedUrlCommand, result: DiscoveredDeviceType){
-        let pluginResult =  CDVPluginResult(
-            status: CDVCommandStatus_OK,
-            messageAs: result.ToJSON()
-        )
-        pluginResult!.setKeepCallbackAs(true);
-        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId )
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }
-    }
-    //helper to return a JSon Array object object
-    func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: [[AnyHashable: Any]]) {
-        let pluginResult =  CDVPluginResult(
-            status: CDVCommandStatus_OK,
-            messageAs: result
-        )
-        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId )
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }    }
-    
-    //helper to send back an error
-    func sendError(command: CDVInvokedUrlCommand, result: String){
-        let pluginResult =  CDVPluginResult(
-            status: CDVCommandStatus_ERROR,
-            messageAs: result
-        )
-        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }    }
-    
-    func sendError(command: CDVInvokedUrlCommand, result: CordovaBLEError){
-        let pluginResult =  CDVPluginResult(
-            status: CDVCommandStatus_ERROR,
-            messageAs: result.toJSON()
-        )
-        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
-        if (bleActionQueue.first?.id == command.callbackId) {
-            removeFromQueue()
-        }
-    }
-    
-    
-    //Is BLE available
-    @objc(checkAvailable:)
-    func checkAvailable(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            DispatchQueue.main.async {
-                
-                //from ios5
-                if ( floor(NSFoundationVersionNumber) <= floor(NSFoundationVersionNumber_iOS_5_1) ){
-                    self.sendError(command: command, result: IoTizeBleError.BleUnsupported().message)
-                }
-                
-                //check State
-                self.bleController.checkState(completion: {
-                    (error: IoTizeBleError?) -> () in
-                    
-                    DispatchQueue.main.async {
-                        
-                        if (error != nil){
-                            self.lastError = error
-                            self.sendError(command: command, result: error!.message)
-                        }
-                        else {
-                            self.sendSuccessWithSingleResponse(command: command, result: true)
-                        }
-                        
-                    }
-                })
-            }
-        })
-    }
-    
-
-    //Start scanning  IoTize devices    
-    @objc(startScan:)
-    func startScan(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            if (!self.isReady()){
-                
-                DispatchQueue.main.async {
-                    Thread.sleep(forTimeInterval: 0.01)
-                    self.startScan(command: command)
-                }
-                return
-            }
-            
-            self.bleController.beginScan(completion: {
-                (result: Any, error: IoTizeBleError?) -> () in
-                
-                DispatchQueue.main.async {
-                    
-                    if (error != nil){
-                        self.lastError = error
-                        self.sendError(command: command, result: error!.message)
-                    }
-                    else if let resultString = result as? String{
-                        self.sendSuccessWithMultipleResponse(command: command, result: resultString)
-                    } else if let resultDiscoveredDevice = result as? DiscoveredDeviceType {
-                        self.sendSuccessWithMultipleResponse(command: command, result: resultDiscoveredDevice)
-                    } else if let resultDevice = result as? CBPeripheral {
-                        self.sendSuccessWithMultipleResponse(command: command, result: CBPeripheralConverter.toDiscoveredDeviceType(device: resultDevice))
-                    } else {
-                    }
-                }
-            })
-        })
-    }
-    
-    //Stop scanning 
-    @objc(stopScan:)
-    func stopScan(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            bleController.stopScan();
-            self.sendSuccessWithSingleResponse(command: command, result: "OK")
-        })
-    }
-    
-    
-    //Connect to a device using its UUID
-    @objc(connectAndDiscoverTapServices:)
-    func connectAndDiscoverTapServices(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            //we need the UUID of the device
-            if (command.arguments.count == 0){
-                let error = CordovaBLEError.IllegalArgument("Missing arguments")
-                self.sendError(command: command, result: error)
-                return
-            }
-            
-            let deviceUUID = command.arguments[0] as? String ?? ""
-            
-            bleController.useBLETapPeripheral = true
-            
-            bleController.connectWithUUID(device: deviceUUID, completion: {
-                (state: Any?, error: IoTizeBleError?) -> () in
-                
-                DispatchQueue.main.async {
-                    
-                    if (error != nil){
-                        self.lastError = error
-                        self.sendError(command: command, result: error!.message)
-                    }
-                    else {
-                        //printBLE("##> Sending Connected Ok")
-                        let _state = state as? String
-
-                        self.sendSuccessWithMultipleResponse(command: command, result: _state ?? "") // keep callback
-                    }
-                }
-                })
-        })
-    }
-    
-    
-    @objc(connect:)
-    func connect(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            //we need the UUID of the device
-            if (command.arguments.count == 0){
-                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
-                return
-            }
-            
-            let deviceUUID = command.arguments[0] as? String ?? ""
-            
-            bleController.useBLETapPeripheral = false
-            
-            bleController.connectWithUUID(device: deviceUUID, completion: {
-                (state: Any?, error: IoTizeBleError?) -> () in
-                
-                DispatchQueue.main.async {
-                    
-                    if (error != nil){
-                        self.lastError = error
-                        self.sendError(command: command, result: error!.message)
-                    }
-                    else {
-                        //printBLE("##> Sending Connected Ok")
-                        let _state = state as? String
-
-                        self.sendSuccessWithMultipleResponse(command: command, result: _state ?? "") // keep callback
-                    }
-                }
-                })
-        })
-    }
-    
-    //Disconnect from a device using its name
-    @objc(disConnect:)
-    func disConnect(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: { [self] in
-            //we need the name of the device
-            if (command.arguments.count == 0){
-                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
-                return
-            }
-                    
-            bleController.disconnect( completion: {
-                (error: IoTizeBleError?) -> () in
-                
-                DispatchQueue.main.async {
-                    
-                    if (error != nil){
-                        self.lastError = error
-                        self.sendError(command: command, result: error!.message)
-                    }
-                    else {
-                        self.sendSuccessWithSingleResponse(command: command, result: "OK")
-                    }
-                }
-            })
-        })
-    }
-    
-    //Retrieve additional information
-    @objc(getLastError:)
-    func getLastError(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            let msg: String = (lastError != nil) ? (lastError!.message) : ""
-            self.sendSuccessWithSingleResponse(command: command, result: msg)
-        })
-    }
-    
-    //Send Data to device
-    @objc(sendRequest:)
-    func sendRequest(command: CDVInvokedUrlCommand) {
-        
-        addToQueue(command: command, bleAction: {[self] in
-            printBLE("##> SendRequest")
-            //we need data to send
-            if (command.arguments.count == 1){
-                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
-                return
-            }
-            
-            let data = command.arguments[1] as? String ?? ""
-            
-            bleController.sendRequest(data: data, completion: {
-                (response: Any, error: IoTizeBleError?) -> () in
-                
-                DispatchQueue.main.async {
-                    
-                    if (error != nil){
-                        self.lastError = error
-                        self.sendError(command: command, result: error!.message)
-                    }
-                    else {
-                        if let responseString = response as? String {
-                            self.sendSuccessWithSingleResponse(command: command, result: responseString)
-                        }
-                        else if let responseDiscoveredDevice = response as? DiscoveredDeviceType {
-                            self.sendSuccessWithSingleResponse(command: command, result: responseDiscoveredDevice)
-                        } else if let responseDevice = response as? CBPeripheral {
-                            self.sendSuccessWithSingleResponse(command: command, result: CBPeripheralConverter.toDiscoveredDeviceType(device: responseDevice))
-                        }
-                    }
-                }
-            })
-        })
-    }
-    
-    @objc(isConnected:)
-    func isConnected(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: { [self] in
-            var status: Bool ;
-            
-            if (command.arguments.count < 1) {
-                let error = CordovaBLEError.IllegalArgument("Missing arguments")
-                self.sendError(command: command, result: error)
-            }
-            
-            let deviceUUID = command.arguments[0] as? String ?? ""
-            do {
-                status = try bleController.isConnected(deviceUUID)
-                self.sendSuccessWithSingleResponse(command: command, result: status)
-            }
-            catch {
-                if (error is CordovaBLEError) {
-                    self.sendError(command: command, result: (error as! CordovaBLEError))
-                } else {
-                    let cordovaError = CordovaBLEError.InternalError("Unkown error")
-                    self.sendError(command: command, result: cordovaError)
-                }
-            }
-        })
-        
-    }
-
-    func isReady() -> Bool {
-        return bleController.isReady()
-    }
-    
-    @objc(discoverServices:)
-    func discoverServices(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            printBLE("discoverServices called")
-            if (command.arguments.count == 0){
-                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
-                return
-            }
-            
-            let deviceUUID = command.arguments[0] as? String ?? ""
-
-            bleController.discoverServices(forUUID: deviceUUID) { (anyPeripheral, error) in
-                if (error != nil) {
-                    self.lastError = error
-                    self.sendError(command: command, result: error?.message ?? "discoverServicesError")
-                } else {
-                    if let peripheral = anyPeripheral as? CBPeripheral {
-                        let result = CBPeripheralConverter.toServiceDescriptionsJSON(device: peripheral)
-                        self.sendSuccessWithSingleResponse(command: command, result: result)
-                    }
-                }
-            }
-        })
-    }
-
-    @objc(characteristicWriteWithoutResponse:)
-    func characteristicWriteWithoutResponse(command: CDVInvokedUrlCommand) {
-        
-        addToQueue(command: command, bleAction: {[self] in
-            printBLE("characteristicWriteWithoutResponse called")
-            if (command.arguments.count < 4){
-                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
-                return
-            }
-            let deviceID = command.arguments[0] as? String ?? ""
-            
-            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            
-            let dataToWrite = Data(Request.stringToHexArray(command.arguments[3] as? String ?? ""))
-
-            bleController.characteristicWriteWithoutResponse(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, data: dataToWrite, completion: { (error) in
-                if (error != nil) {
-                    self.sendError(command: command, result: error!.message)
-                    return
-                }
-                self.sendSuccessWithSingleResponse(command: command, result: "OK")
-            })
-        })
-    }
-    
-    @objc(characteristicWrite:)
-    func characteristicWrite(command: CDVInvokedUrlCommand) {
-        addToQueue(command: command, bleAction: {[self] in
-            printBLE("characteristicWrite called")
-            if (command.arguments.count < 4){
-                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
-                return
-            }
-            let deviceID = command.arguments[0] as? String ?? ""
-            
-            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            
-            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
-                
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-
-            let dataToWrite = Data(Request.stringToHexArray(command.arguments[3] as? String ?? ""))
-            
-            bleController.characteristicWrite(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, data: dataToWrite, completion: { (error) in
-                if (error != nil) {
-                    self.sendError(command: command, result: error!.message)
-                    return
-                }
-                self.sendSuccessWithSingleResponse(command: command, result: "OK")
-            })
-        })
-    }
-    
-    @objc(characteristicRead:)
-    func characteristicRead(command: CDVInvokedUrlCommand) {
-        
-        addToQueue(command: command, bleAction: {[self] in
-            printBLE("characteristicRead called")
-            if (command.arguments.count < 3){
-                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
-                return
-            }
-            let deviceID = command.arguments[0] as? String ?? ""
-            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            
-            bleController.characteristicRead(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { (readData, error)  in
-                if (error != nil) {
-                    self.sendError(command: command, result: error!.message)
-                    return
-                }
-                let data = readData as! String
-                self.sendSuccessWithSingleResponse(command: command, result: data)
-            })
-        })
-        
- 
-    }
-    
-    @objc(characteristicStartNotification:)
-    func characteristicStartNotification(command: CDVInvokedUrlCommand) {
-        
-        addToQueue(command: command, bleAction: {[self] () in
-            printBLE("characteristicStartNotification called")
-            if (command.arguments.count < 3){
-                self.sendError(command: command, result: "characteristicStartNotification parameter error")
-                return
-            }
-            let deviceID = command.arguments[0] as? String ?? ""
-        
-            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-
-            bleController.characteristicStartNotification(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { error  in
-                if (error != nil) {
-                    printBLE("characteristicStartNotification response error")
-                    self.sendError(command: command, result: error!.message)
-                    return
-                }
-                printBLE("characteristicStartNotification response OK")
-                self.sendSuccessWithSingleResponse(command: command, result: "OK")
-            })
-        })
-        
-    }
-    
-    @objc(characteristicStopNotification:)
-    func characteristicStopNotification(command: CDVInvokedUrlCommand) {
-        
-        addToQueue(command: command, bleAction: { [self] () in
-            printBLE("characteristicStopNotification called")
-            if (command.arguments.count < 3){
-                self.sendError(command: command, result: "characteristicStopNotification parameter error")
-                return
-            }
-            let deviceID = command.arguments[0] as? String ?? ""
-        
-            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-
-            bleController.characteristicStopNotification(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { error  in
-                if (error != nil) {
-                    printBLE("characteristicStopNotification response error")
-                    self.sendError(command: command, result: error!.message)
-                    return
-                }
-                printBLE("characteristicStopNotification response OK")
-                self.sendSuccessWithSingleResponse(command: command, result: "OK")
-            })
-        })
-        
-    }
-    
-    @objc(characteristicChanged:)
-    func characteristicChanged(command: CDVInvokedUrlCommand) {
-        
-        addToQueue(command: command, bleAction: { [self] () in
-            
-            printBLE("characteristicChanged called")
-            if (command.arguments.count < 3){
-                self.sendError(command: command, result: "SendRequest parameter error")
-                return
-            }
-            let deviceID = command.arguments[0] as? String ?? ""
-        
-            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
-                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
-                self.sendError(command: command, result: cordovaError)
-                return
-            }
-
-            bleController.characteristicChanged(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { (result, error)   in
-                if (error != nil) {
-                    self.sendError(command: command, result: error!.message)
-                    return
-                }
-                self.sendSuccessWithMultipleResponse(command: command, result: result as! String)
-        })
-            if (bleActionQueue.first?.id == command.callbackId) {
-                removeFromQueue()
-            }
-    })
-        }
-    
-    func addToQueue(command: CDVInvokedUrlCommand, bleAction: @escaping () -> Void) {
-        bleActionQueue.enqueue(BLEAction(command.callbackId, bleAction))
-        if (!isHandlingQueue) {
-            isHandlingQueue = true
-            DispatchQueue.main.async {
-                bleAction()
-            }
-        }
-    }
-    
-    func removeFromQueue() {
-        bleActionQueue.dequeue()
-        if (isHandlingQueue) {
-            if (bleActionQueue.first != nil) {
-                DispatchQueue.main.async {
-                    self.bleActionQueue.first!.action()
-                }
-            } else {
-                isHandlingQueue = false
-            }
-        }
-    }
-
-
-    @objc(close:)
-    func close(command: CDVInvokedUrlCommand) {
-        disConnect(command: command)
-    }
-}
+//
+//  Copyright 2018 IoTize SAS Inc.  Licensed under the MIT license. 
+//
+//  BLECom.swift
+//  device-com-ble.cordova BLE Cordova Plugin
+//
+
+import Foundation
+import CoreBluetooth
+
+// Custom debug print functions
+
+public func printBLE(_ object: Any...) {
+    #if DEBUG
+    for item in object {
+        Swift.print("BLE:", item)
+    }
+    #endif
+}
+
+public func printBLE(_ object: Any) {
+    #if DEBUG
+    Swift.print("BLE:", object)
+    #endif
+}
+
+
+struct IoTizeBleError: Error {
+    
+    let code: Int
+    let message: String
+    
+    init(code: Int, message: String) {
+        self.code = code
+        self.message = message
+    }
+    
+    static func BleUnsupported() -> IoTizeBleError { return IoTizeBleError(code:100, message:"Bluetooth is not supported")}
+    static func BleUnauthorized() -> IoTizeBleError { return IoTizeBleError(code:101, message:"Bluetooth is not authorized")}
+    static func BlePoweredOff() -> IoTizeBleError { return IoTizeBleError(code:102, message:"Bluetooth is powered off")}
+    static func BleResetting() -> IoTizeBleError { return IoTizeBleError(code:103, message:"Bluetooth is resetting")}
+    static func BleUnknown() -> IoTizeBleError { return IoTizeBleError(code:104, message:"Bluetooth is in an unknown state")}
+    
+    static func PeripheralConnectionFailed(peripheral: CBPeripheral, error: Error?) -> IoTizeBleError { return IoTizeBleError(code:200, message:"Connection to \(peripheral.name ?? "unknown peripheral") failed: \(error?.localizedDescription ?? "unknown")" )}
+    static func NoDeviceConnected() -> IoTizeBleError { return IoTizeBleError(code:201, message:"No Device Connected")}
+    
+    static func ServiceDiscoveryFailed(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:300, message:"Failed to discover services for \(peripheral.name ?? "unknown peripheral")" )}
+    static func CharacteristicsDiscoveryFailed(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:301, message:"Failed to discover characteristics for \(peripheral.name ?? "unknown peripheral")" )}
+    static func CharacteristicSPPNotFound(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:302, message:"Characteristic SPP not found for \(peripheral.name ?? "unknown peripheral")" )}
+    static func CharacteristicNotifyChangeFailed() -> IoTizeBleError { return IoTizeBleError(code:304, message:"Failed to set notification for characteristic" )}
+    static func BleVersionIsOld(version: String) -> IoTizeBleError { return IoTizeBleError(code:303, message:"BLE firmware version is too old: \(version)" )}
+    
+    static func InvalidWriteData(peripheral: CBPeripheral) -> IoTizeBleError { return IoTizeBleError(code:403, message:"Invalid write data for \(peripheral.name ?? "unknown peripheral")" )}
+    static func TimedOutRequest(msg: String) -> IoTizeBleError { return IoTizeBleError(code:404, message:"Waiting for response timed out, txData: " + msg )}
+        
+}
+
+enum CordovaBLEErrorCode: CustomStringConvertible {
+    case InternalError
+    case IllegalArgument
+    case DeviceNotFound
+    
+    var description: String {
+        switch self {
+        case .InternalError: return "CordovaBLEErrorInternalError"
+        case .IllegalArgument: return "CordovaBLEErrorIllegalArgument"
+        case .DeviceNotFound: return "CordovaBLEErrorDeviceNotFound"
+        }
+    }
+}
+
+struct CordovaBLEError: Error {
+    var code: CordovaBLEErrorCode
+    var message: String
+    
+    init(_ code: CordovaBLEErrorCode, _ message: String) {
+        self.code = code
+        self.message = message
+    }
+    
+    func toJSON() -> [AnyHashable: Any] {
+        return ["code": code.description, "message": message]
+    }
+    
+    static func InternalError(_ message: String) -> CordovaBLEError {return CordovaBLEError(.InternalError, message)}
+    
+    static func IllegalArgument(_ message: String) -> CordovaBLEError {return CordovaBLEError(.IllegalArgument, message)}
+}
+
+struct BLEAction {
+    var id: String
+    var action: () -> Void
+    
+    init(_ id: String, _ action: @escaping () -> Void) {
+        self.id = id
+        self.action = action
+    }
+}
+
+//Main class handling the plugin functionalities.
+@objc(BLECom) class BLECom : CDVPlugin {
+    
+    var bleActionQueue: Queue<BLEAction>!
+    
+    var isHandlingQueue = false
+    
+    var bleController: BLEManager!
+    var lastError: IoTizeBleError?
+    
+    //
+    override func pluginInitialize(){
+        bleController = BLEManager()
+        bleActionQueue = Queue<BLEAction>()
+    }
+    
+    //helper to return an empty response
+    func sendSuccessWithoutResponse(command: CDVInvokedUrlCommand) {
+        let pluginResult = CDVPluginResult(status: CDVCommandStatus_OK)
+        
+        self.commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+        removeFromQueue(id: command.callbackId)
+        
+    }
+    
+    //helper to return a string 
+    func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: String){
+        let pluginResult =  CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result
+        )
+        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
+        removeFromQueue(id: command.callbackId)
+    }
+    
+    //helper to return a boolean 
+    private func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: Bool) {
+        let pluginResult = CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result
+        )
+        self.commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+        removeFromQueue(id: command.callbackId)
+    }
+    
+    //helper to return a JSon object 
+    func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: DiscoveredDeviceType){
+        let pluginResult =  CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result.ToJSON()
+        )
+        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
+        removeFromQueue(id: command.callbackId)
+    }
+    
+    //helper to return a String with keeping the callback
+    func sendSuccessWithMultipleResponse(command: CDVInvokedUrlCommand, result: String){
+        let pluginResult =  CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result
+        )
+        pluginResult!.setKeepCallbackAs(true);
+        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId )
+        removeFromQueue(id: command.callbackId)
+    }
+    
+    //helper to return a JSon DiscoveredDeviceType object with keeping the callback
+    func sendSuccessWithMultipleResponse(command: CDVInvokedUrlCommand, result: DiscoveredDeviceType){
+        let pluginResult =  CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result.ToJSON()
+        )
+        pluginResult!.setKeepCallbackAs(true);
+        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId )
+        removeFromQueue(id: command.callbackId)
+    }
+    //helper to return a JSon Array object object
+    func sendSuccessWithSingleResponse(command: CDVInvokedUrlCommand, result: [[AnyHashable: Any]]) {
+        let pluginResult =  CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result
+        )
+        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId )
+        removeFromQueue(id: command.callbackId)    }
+    
+    //helper to send back an error
+    func sendError(command: CDVInvokedUrlCommand, result: String){
+        let pluginResult =  CDVPluginResult(
+            status: CDVCommandStatus_ERROR,
+            messageAs: result
+        )
+        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
+        removeFromQueue(id: command.callbackId)    }
+    
+    func sendError(command: CDVInvokedUrlCommand, result: CordovaBLEError){
+        let pluginResult =  CDVPluginResult(
+            status: CDVCommandStatus_ERROR,
+            messageAs: result.toJSON()
+        )
+        self.commandDelegate!.send( pluginResult, callbackId: command.callbackId)
+        removeFromQueue(id: command.callbackId)
+    }
+    
+    
+    //Is BLE available
+    @objc(checkAvailable:)
+    func checkAvailable(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            DispatchQueue.main.async {
+                
+                //from ios5
+                if ( floor(NSFoundationVersionNumber) <= floor(NSFoundationVersionNumber_iOS_5_1) ){
+                    self.sendError(command: command, result: IoTizeBleError.BleUnsupported().message)
+                }
+                
+                //check State
+                self.bleController.checkState(completion: {
+                    (error: IoTizeBleError?) -> () in
+                    
+                    DispatchQueue.main.async {
+                        
+                        if (error != nil){
+                            self.lastError = error
+                            self.sendError(command: command, result: error!.message)
+                        }
+                        else {
+                            self.sendSuccessWithSingleResponse(command: command, result: true)
+                        }
+                        
+                    }
+                })
+            }
+        })
+    }
+    
+
+    //Start scanning  IoTize devices    
+    @objc(startScan:)
+    func startScan(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            if (!self.isReady()){
+                
+                DispatchQueue.main.async {
+                    Thread.sleep(forTimeInterval: 0.01)
+                    self.startScan(command: command)
+                }
+                return
+            }
+            
+            let scanOptionsJSON = command.arguments[0] as? String ?? nil
+            
+            var serviceUUIDs: [CBUUID]? = nil
+            
+            if let actualScanOptionsJSON = scanOptionsJSON {
+                if let scanOptionsJSONData = actualScanOptionsJSON.data(using: .utf8) {
+                    if let scannerOptions = try? JSONDecoder().decode(ScannerOptions.self, from: scanOptionsJSONData) {
+                        if let filters = scannerOptions.filters {
+                            if (!filters.isEmpty) {
+                                serviceUUIDs = []
+                                for filter in filters {
+                                    serviceUUIDs?.append(CBUUID(string: filter))
+                                }
+
+                            }
+
+                        }
+                    }
+                }
+            }
+            
+            self.bleController.beginScan(completion: {
+                (result: Any, error: IoTizeBleError?) -> () in
+                
+                DispatchQueue.main.async {
+                    
+                    if (error != nil){
+                        self.lastError = error
+                        self.sendError(command: command, result: error!.message)
+                    }
+                    else if let resultString = result as? String{
+                        self.sendSuccessWithMultipleResponse(command: command, result: resultString)
+                    } else if let resultDiscoveredDevice = result as? DiscoveredDeviceType {
+                        self.sendSuccessWithMultipleResponse(command: command, result: resultDiscoveredDevice)
+                    } else if let resultDevice = result as? CBPeripheral {
+                        self.sendSuccessWithMultipleResponse(command: command, result: CBPeripheralConverter.toDiscoveredDeviceType(device: resultDevice))
+                    } else {
+                    }
+                }
+            }, serviceUUIDs: serviceUUIDs)
+        })
+    }
+    
+    //Stop scanning 
+    @objc(stopScan:)
+    func stopScan(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            bleController.stopScan();
+            self.sendSuccessWithSingleResponse(command: command, result: "OK")
+        })
+    }
+    
+    
+    //Connect to a device using its UUID
+    @objc(connectAndDiscoverTapServices:)
+    func connectAndDiscoverTapServices(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            //we need the UUID of the device
+            if (command.arguments.count == 0){
+                let error = CordovaBLEError.IllegalArgument("Missing arguments")
+                self.sendError(command: command, result: error)
+                return
+            }
+            
+            let deviceUUID = command.arguments[0] as? String ?? ""
+            
+            bleController.useBLETapPeripheral = true
+            
+            bleController.connectWithUUID(device: deviceUUID, completion: {
+                (state: Any?, error: IoTizeBleError?) -> () in
+                
+                DispatchQueue.main.async {
+                    
+                    if (error != nil){
+                        self.lastError = error
+                        self.sendError(command: command, result: error!.message)
+                    }
+                    else {
+                        //printBLE("##> Sending Connected Ok")
+                        let _state = state as? String
+
+                        self.sendSuccessWithMultipleResponse(command: command, result: _state ?? "") // keep callback
+                    }
+                }
+                })
+        })
+    }
+    
+    
+    @objc(connect:)
+    func connect(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            
+            printBLE("connect called")
+            //we need the UUID of the device
+            if (command.arguments.count == 0){
+                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
+                return
+            }
+            
+            let deviceUUID = command.arguments[0] as? String ?? ""
+            
+            bleController.useBLETapPeripheral = false
+            
+            bleController.connectWithUUID(device: deviceUUID, completion: {
+                (state: Any?, error: IoTizeBleError?) -> () in
+                
+                DispatchQueue.main.async {
+                    
+                    if (error != nil){
+                        self.lastError = error
+                        self.sendError(command: command, result: error!.message)
+                    }
+                    else {
+                        //printBLE("##> Sending Connected Ok")
+                        let _state = state as? String
+
+                        self.sendSuccessWithMultipleResponse(command: command, result: _state ?? "") // keep callback
+                    }
+                }
+                })
+        })
+    }
+    
+    //Disconnect from a device using its name
+    @objc(disConnect:)
+    func disConnect(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: { [self] in
+            printBLE("disconnect called")
+            //we need the name of the device
+            if (command.arguments.count == 0){
+                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
+                return
+            }
+                    
+            bleController.disconnect( completion: {
+                (error: IoTizeBleError?) -> () in
+                
+                DispatchQueue.main.async {
+                    
+                    if (error != nil){
+                        self.lastError = error
+                        self.sendError(command: command, result: error!.message)
+                    }
+                    else {
+                        self.sendSuccessWithSingleResponse(command: command, result: "OK")
+                    }
+                }
+            })
+        })
+    }
+    
+    //Retrieve additional information
+    @objc(getLastError:)
+    func getLastError(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            let msg: String = (lastError != nil) ? (lastError!.message) : ""
+            self.sendSuccessWithSingleResponse(command: command, result: msg)
+        })
+    }
+    
+    //Send Data to device
+    @objc(sendRequest:)
+    func sendRequest(command: CDVInvokedUrlCommand) {
+        
+        addToQueue(command: command, bleAction: {[self] in
+            printBLE("##> SendRequest")
+            //we need data to send
+            if (command.arguments.count == 1){
+                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
+                return
+            }
+            
+            let data = command.arguments[1] as? String ?? ""
+            
+            bleController.sendRequest(data: data, completion: {
+                (response: Any, error: IoTizeBleError?) -> () in
+                
+                DispatchQueue.main.async {
+                    
+                    if (error != nil){
+                        self.lastError = error
+                        self.sendError(command: command, result: error!.message)
+                    }
+                    else {
+                        if let responseString = response as? String {
+                            self.sendSuccessWithSingleResponse(command: command, result: responseString)
+                        }
+                        else if let responseDiscoveredDevice = response as? DiscoveredDeviceType {
+                            self.sendSuccessWithSingleResponse(command: command, result: responseDiscoveredDevice)
+                        } else if let responseDevice = response as? CBPeripheral {
+                            self.sendSuccessWithSingleResponse(command: command, result: CBPeripheralConverter.toDiscoveredDeviceType(device: responseDevice))
+                        }
+                    }
+                }
+            })
+        })
+    }
+    
+    @objc(isConnected:)
+    func isConnected(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: { [self] in
+            var status: Bool ;
+            
+            if (command.arguments.count < 1) {
+                let error = CordovaBLEError.IllegalArgument("Missing arguments")
+                self.sendError(command: command, result: error)
+            }
+            
+            let deviceUUID = command.arguments[0] as? String ?? ""
+            do {
+                status = try bleController.isConnected(deviceUUID)
+                self.sendSuccessWithSingleResponse(command: command, result: status)
+            }
+            catch {
+                if (error is CordovaBLEError) {
+                    self.sendError(command: command, result: (error as! CordovaBLEError))
+                } else {
+                    let cordovaError = CordovaBLEError.InternalError("Unkown error")
+                    self.sendError(command: command, result: cordovaError)
+                }
+            }
+        })
+        
+    }
+
+    func isReady() -> Bool {
+        return bleController.isReady()
+    }
+    
+    @objc(discoverServices:)
+    func discoverServices(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            printBLE("discoverServices called")
+            if (command.arguments.count == 0){
+                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
+                return
+            }
+            
+            let deviceUUID = command.arguments[0] as? String ?? ""
+
+            bleController.discoverServices(forUUID: deviceUUID) { (anyPeripheral, error) in
+                if (error != nil) {
+                    self.lastError = error
+                    self.sendError(command: command, result: error?.message ?? "discoverServicesError")
+                } else {
+                    if let peripheral = anyPeripheral as? CBPeripheral {
+                        let result = CBPeripheralConverter.toServiceDescriptionsJSON(device: peripheral)
+                        self.sendSuccessWithSingleResponse(command: command, result: result)
+                    }
+                }
+            }
+        })
+    }
+
+    @objc(characteristicWriteWithoutResponse:)
+    func characteristicWriteWithoutResponse(command: CDVInvokedUrlCommand) {
+        
+        addToQueue(command: command, bleAction: {[self] in
+            printBLE("characteristicWriteWithoutResponse called")
+            if (command.arguments.count < 4){
+                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
+                return
+            }
+            let deviceID = command.arguments[0] as? String ?? ""
+            
+            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            
+            let dataToWrite = Data(Request.stringToHexArray(command.arguments[3] as? String ?? ""))
+
+            bleController.characteristicWriteWithoutResponse(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, data: dataToWrite, completion: { (error) in
+                if (error != nil) {
+                    self.sendError(command: command, result: error!.message)
+                    return
+                }
+                self.sendSuccessWithSingleResponse(command: command, result: "OK")
+            })
+        })
+    }
+    
+    @objc(characteristicWrite:)
+    func characteristicWrite(command: CDVInvokedUrlCommand) {
+        addToQueue(command: command, bleAction: {[self] in
+            printBLE("characteristicWrite called")
+            if (command.arguments.count < 4){
+                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
+                return
+            }
+            let deviceID = command.arguments[0] as? String ?? ""
+            
+            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            
+            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
+                
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+
+            let dataToWrite = Data(Request.stringToHexArray(command.arguments[3] as? String ?? ""))
+            
+            bleController.characteristicWrite(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, data: dataToWrite, completion: { (error) in
+                if (error != nil) {
+                    self.sendError(command: command, result: error!.message)
+                    return
+                }
+                self.sendSuccessWithSingleResponse(command: command, result: "OK")
+            })
+        })
+    }
+    
+    @objc(characteristicRead:)
+    func characteristicRead(command: CDVInvokedUrlCommand) {
+        
+        addToQueue(command: command, bleAction: {[self] in
+            printBLE("characteristicRead called")
+            if (command.arguments.count < 3){
+                self.sendError(command: command, result: CordovaBLEError.IllegalArgument("Missing arguments"))
+                return
+            }
+            let deviceID = command.arguments[0] as? String ?? ""
+            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            
+            bleController.characteristicRead(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { (readData, error)  in
+                if (error != nil) {
+                    self.sendError(command: command, result: error!.message)
+                    return
+                }
+                let data = readData as! String
+                self.sendSuccessWithSingleResponse(command: command, result: data)
+            })
+        })
+        
+ 
+    }
+    
+    @objc(characteristicStartNotification:)
+    func characteristicStartNotification(command: CDVInvokedUrlCommand) {
+        
+        addToQueue(command: command, bleAction: {[self] () in
+            printBLE("characteristicStartNotification called")
+            if (command.arguments.count < 3){
+                self.sendError(command: command, result: "characteristicStartNotification parameter error")
+                return
+            }
+            let deviceID = command.arguments[0] as? String ?? ""
+        
+            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+
+            bleController.characteristicStartNotification(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { error  in
+                if (error != nil) {
+                    printBLE("characteristicStartNotification response error")
+                    self.sendError(command: command, result: error!.message)
+                    return
+                }
+                printBLE("characteristicStartNotification response OK")
+                self.sendSuccessWithSingleResponse(command: command, result: "OK")
+            })
+        })
+        
+    }
+    
+    @objc(characteristicStopNotification:)
+    func characteristicStopNotification(command: CDVInvokedUrlCommand) {
+        
+        addToQueue(command: command, bleAction: { [self] () in
+            printBLE("characteristicStopNotification called")
+            if (command.arguments.count < 3){
+                self.sendError(command: command, result: "characteristicStopNotification parameter error")
+                return
+            }
+            let deviceID = command.arguments[0] as? String ?? ""
+        
+            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+
+            bleController.characteristicStopNotification(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { error  in
+                if (error != nil) {
+                    printBLE("characteristicStopNotification response error")
+                    self.sendError(command: command, result: error!.message)
+                    return
+                }
+                printBLE("characteristicStopNotification response OK")
+                self.sendSuccessWithSingleResponse(command: command, result: "OK")
+            })
+        })
+        
+    }
+    
+    @objc(characteristicChanged:)
+    func characteristicChanged(command: CDVInvokedUrlCommand) {
+        
+        addToQueue(command: command, bleAction: { [self] () in
+            
+            printBLE("characteristicChanged called")
+            if (command.arguments.count < 3){
+                self.sendError(command: command, result: "SendRequest parameter error")
+                return
+            }
+            let deviceID = command.arguments[0] as? String ?? ""
+        
+            guard let serviceUUID = CBUUIDHelper.fromString(command.arguments[1] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[1] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+            guard let characteristicUUID = CBUUIDHelper.fromString(command.arguments[2] as? String ?? "") else {
+                let cordovaError = CordovaBLEError.IllegalArgument("\"\(command.arguments[2] as? String ?? "")\" is not a valid BLE UUID")
+                self.sendError(command: command, result: cordovaError)
+                return
+            }
+
+            bleController.characteristicChanged(deviceID: deviceID, serviceUUID: serviceUUID, characteristicUUID: characteristicUUID, completion: { (result, error)   in
+                if (error != nil) {
+                    self.sendError(command: command, result: error!.message)
+                    return
+                }
+                self.sendSuccessWithMultipleResponse(command: command, result: result as! String)
+            })
+            removeFromQueue(id: command.callbackId)
+        })
+    }
+    
+    func addToQueue(command: CDVInvokedUrlCommand, bleAction: @escaping () -> Void) {
+        bleActionQueue.enqueue(BLEAction(command.callbackId, bleAction))
+        if (!isHandlingQueue) {
+            isHandlingQueue = true
+            DispatchQueue.main.async {
+                bleAction()
+            }
+        }
+    }
+    
+    func removeFromQueue(id: String) {
+        bleActionQueue.dequeue(searchClosure: {$0.id == id})
+        if (isHandlingQueue) {
+            DispatchQueue.main.async {
+                self.bleActionQueue.first?.action()
+                if (self.bleActionQueue.isEmpty) {
+                    self.isHandlingQueue = false
+                }
+            }
+        }
+    }
+
+
+    @objc(close:)
+    func close(command: CDVInvokedUrlCommand) {
+        disConnect(command: command)
+    }
+}
+
+struct ScannerOptions: Decodable {
+    let filters: [String]?
+}
+
+