@iotize/device-com-ble.cordova 3.0.0 → 3.3.0

package/src/ios/BLECom.swift

@@ -8,6 +8,23 @@
 import Foundation
 import CoreBluetooth
 
+// Custom debug print functions
+
+public func printBLE(_ object: Any...) {
+    #if true
+    for item in object {
+        Swift.print("BLE:", object)
+    }
+    #endif
+}
+
+public func printBLE(_ object: Any) {
+    #if true
+    Swift.print("BLE:", object)
+    #endif
+}
+
+
 struct IoTizeBleError: Error {
     
     let code: Int
@@ -38,63 +55,143 @@ struct IoTizeBleError: Error {
         
 }
 
+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 sendSuccess(command: CDVInvokedUrlCommand, result: 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 sendSuccess(command: CDVInvokedUrlCommand, result: Bool) {
+    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 sendSuccess(command: CDVInvokedUrlCommand, result: DiscoveredDeviceType){
+    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 sendSuccessWithResponse(command: CDVInvokedUrlCommand, result: String){
+    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 object with keeping the callback
-    func sendSuccessWithResponse(command: CDVInvokedUrlCommand, result: DiscoveredDeviceType){
+    //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){
@@ -103,192 +200,533 @@ struct IoTizeBleError: 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) {
-        
-        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
+        addToQueue(command: command, bleAction: {[self] in
+            DispatchQueue.main.async {
                 
-                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
                     
-                    if (error != nil){
-                        self.lastError = error
-                        self.sendError(command: command, result: error!.message)
+                    DispatchQueue.main.async {
+                        
+                        if (error != nil){
+                            self.lastError = error
+                            self.sendError(command: command, result: error!.message)
+                        }
+                        else {
+                            self.sendSuccessWithSingleResponse(command: command, result: true)
+                        }
+                        
                     }
-                    else {
-                        self.sendSuccess(command: command, result: true)
-                    }
-                    
-                }
-            })
-        }
+                })
+            }
+        })
     }
     
 
     //Start scanning  IoTize devices    
     @objc(startScan:)
     func startScan(command: CDVInvokedUrlCommand) {
-        
-        if (!self.isReady()){
-            
-            DispatchQueue.main.async {
-                Thread.sleep(forTimeInterval: 0.01)
-                self.startScan(command: command)
+        addToQueue(command: command, bleAction: {[self] in
+            if (!self.isReady()){
+                
+                DispatchQueue.main.async {
+                    Thread.sleep(forTimeInterval: 0.01)
+                    self.startScan(command: command)
+                }
+                return
             }
-            return
-        }
-        
-        self.bleController.beginScan(completion: {
-            (result: Any, error: IoTizeBleError?) -> () in
             
-            DispatchQueue.main.async {
+            self.bleController.beginScan(completion: {
+                (result: Any, error: IoTizeBleError?) -> () in
                 
-                if (error != nil){
-                    self.lastError = error
-                    self.sendError(command: command, result: error!.message)
-                }
-                else if let resultString = result as? String{
-                    self.sendSuccessWithResponse(command: command, result: resultString)
-                } else if let resultDiscoveredDevice = result as? DiscoveredDeviceType {
-                    self.sendSuccessWithResponse(command: command, result: resultDiscoveredDevice)
-                } else if let resultDevice = result as? CBPeripheral {
-                    self.sendSuccessWithResponse(command: command, result: CBPeripheralConverter.toDiscoveredDeviceType(device: resultDevice))
-                } else {
+                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) {
-        bleController.stopScan();
-        self.sendSuccess(command: command, result: "Ok")
+        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) {
-        
-        //we need the UUID of the device
-        if (command.arguments.count == 0){
-            self.sendError(command: command, result: "Connection parameter error")
-            return
-        }
-        
-        let deviceUUID = command.arguments[0] as? String ?? ""
-        
-        bleController.connectWithUUID(device: deviceUUID, completion: {
-            (state: Any?, error: IoTizeBleError?) -> () in
+        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
+            }
             
-            DispatchQueue.main.async {
+            let deviceUUID = command.arguments[0] as? String ?? ""
+            
+            bleController.useBLETapPeripheral = false
+            
+            bleController.connectWithUUID(device: deviceUUID, completion: {
+                (state: Any?, error: IoTizeBleError?) -> () in
                 
-                if (error != nil){
-                    self.lastError = error
-                    self.sendError(command: command, result: error!.message)
-                }
-                else {
-                    //print("##> Sending Connected Ok")
-                    let _state = state as? String
+                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.sendSuccessWithResponse(command: command, result: _state ?? "") // keep callback
+                        self.sendSuccessWithMultipleResponse(command: command, result: _state ?? "") // keep callback
+                    }
                 }
-            }
-            })
+                })
+        })
     }
     
     //Disconnect from a device using its name
     @objc(disConnect:)
     func disConnect(command: CDVInvokedUrlCommand) {
-        
-        //we need the name of the device
-        if (command.arguments.count == 0){
-            self.sendError(command: command, result: "disConnection parameter error")
-            return
-        }
-                
-        bleController.disconnect( completion: {
-            (error: IoTizeBleError?) -> () in
-            
-            DispatchQueue.main.async {
+        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
                 
-                if (error != nil){
-                    self.lastError = error
-                    self.sendError(command: command, result: error!.message)
-                }
-                else {
-                    self.sendSuccess(command: command, result: "Ok")
+                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) {
-        let msg: String = (lastError != nil) ? (lastError!.message) : ""
-        self.sendSuccess(command: command, result: msg)
+        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) {
-        print("##> SendRequest")
-        //we need data to send
-        if (command.arguments.count == 1){
-            self.sendError(command: command, result: "SendRequest parameter error")
-            return
-        }
-        
-        let data = command.arguments[1] as? String ?? ""
         
-        bleController.sendRequest(data: data, completion: {
-            (response: Any, error: IoTizeBleError?) -> () in
+        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
+            }
             
-            DispatchQueue.main.async {
+            let data = command.arguments[1] as? String ?? ""
+            
+            bleController.sendRequest(data: data, completion: {
+                (response: Any, error: IoTizeBleError?) -> () in
                 
-                if (error != nil){
-                    self.lastError = error
-                    self.sendError(command: command, result: error!.message)
-                }
-                else {
-                    if let responseString = response as? String {
-                        self.sendSuccess(command: command, result: responseString)
+                DispatchQueue.main.async {
+                    
+                    if (error != nil){
+                        self.lastError = error
+                        self.sendError(command: command, result: error!.message)
                     }
-                    else if let responseDiscoveredDevice = response as? DiscoveredDeviceType {
-                        self.sendSuccess(command: command, result: responseDiscoveredDevice)
-                    } else if let responseDevice = response as? CBPeripheral {
-                        self.sendSuccess(command: command, result: CBPeripheralConverter.toDiscoveredDeviceType(device: responseDevice))
+                    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) {
-        
-        let error: Bool ;
-        
-        error = bleController.isConnected()
-        self.sendSuccess(command: command, result: error)
+        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)
+    }
 }