@iotize/device-com-nfc.cordova 3.3.0 → 3.4.1

package/src/ios/ISO15Reader.swift

@@ -9,77 +9,79 @@
 import UIKit
 import CoreNFC
 
-
-public extension String {
-    
-     func dataFromHexString() -> Data {
-        var bytes = [UInt8]()
-        for i in 0..<(count/2) {
-            let range = index(self.startIndex, offsetBy: 2*i)..<index(self.startIndex, offsetBy: 2*i+2)
-            let stringBytes = self[range]
-            let byte = strtol((stringBytes as NSString).utf8String, nil, 16)
-            bytes.append(UInt8(byte))
-        }
-        return Data(bytes: UnsafePointer<UInt8>(bytes), count:bytes.count)
-    }
-    
-}
-
-extension Data {
-    
-    func hexEncodedString() -> String {
-        let format = "%02hhX"
-        return map { String(format: format, $0) }.joined()
-    }
-}
-
 @available(iOS 13.0, *)
-class ST25DVReader : NSObject {
-   
-    typealias Completion = (Error?) -> ()
-    
-    private var comSession: NFCTagReaderSession?
-    private var tag: NFCISO15693Tag?
-
-    static var   MB_CTRL_DYN : UInt8 = 0x0D
-    
-    private var connectionCompleted :  Completion?
+class ST25DVReader : NFCTagReader {
     
-    /*ST25 commands*/
-    static var   ISO15693_CUSTOM_ST25DV_CMD_WRITE_MB_MSG : UInt8 =  0xAA;
-    static var   ISO15693_CUSTOM_ST25DV_CMD_READ_MB_MSG_LENGTH : Int =  0xAB;
-    static var   ISO15693_CUSTOM_ST25DV_CMD_READ_MB_MSG = 0xAC;
+    var iso15Tag: NFCISO15693Tag?
+    var detectionRetryCount = 0
     
-    static var   ISO15693_CUSTOM_ST_CMD_READ_DYN_CONFIG : Int =  0xAD;
-    static var   ISO15693_CUSTOM_ST_CMD_WRITE_DYN_CONFIG : Int = 0xAE;
-
-    static var   DELAY : UInt32 = 1000;   // timeout resolution in millionths of second
-    static var   NB_MAX_RETRY : Int = 50;
-    
-    override init() {
-        super.init()
+    override func invalidateSession( message :String) {
+        super.invalidateSession(message: message)
+        iso15Tag = nil
     }
+    
+    override func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) {
 
-    func initSession( alertMessage: String, completed: @escaping (Error?)->() ) {
-        
-        guard NFCNDEFReaderSession.readingAvailable else {
-            completed( NFCReaderError( NFCReaderError.readerErrorUnsupportedFeature ))
+        print( "tagReaderSession:didDectectTag" )
+        guard let session = self.comSession else {
+            return;
+        }
+        if tags.count > 1 {
+            // Restart polling in 500 milliseconds.
+            let retryInterval = DispatchTimeInterval.milliseconds(500)
+            session.alertMessage = "More than 1 Tap is detected. Please remove all tags and try again."
+            DispatchQueue.global().asyncAfter(deadline: .now() + retryInterval, execute: {
+                session.restartPolling()
+            })
             return
         }
         
-        connectionCompleted = completed
+        guard let tag = tags.first else {
+            return;
+        }
         
-        if NFCNDEFReaderSession.readingAvailable {
-            comSession = NFCTagReaderSession(pollingOption: [.iso15693], delegate: self, queue: nil)
-            comSession?.alertMessage = alertMessage
-            comSession?.begin()
+        switch tag {
+        case .iso15693(let iso15tag):
+            self.iso15Tag = iso15tag
+            detectionRetryCount = 0
+            
+            // Connect to tag
+            
+            session.connect(to: tag) { [weak self] (error: Error?) in
+                guard let strongSelf = self  else {
+                    return;
+                }
+                
+                if error != nil {
+                    let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
+                    strongSelf.invalidateSession( message: error.localizedDescription  )
+                    strongSelf.connectionCompleted?(error)
+                    return
+                }
+                print( "connected to tag" )
+                strongSelf.tag = tag
+                strongSelf.connectionCompleted?(nil)
+                iso15tag.readNDEF(completionHandler: {(ndef: NFCNDEFMessage?, error: Error?) in
+                    if (error != nil) {
+                        strongSelf.onDiscoverCompletion?(iso15tag.toJSON(), nil)
+                    }
+                })
+                strongSelf.onDiscoverCompletion?(iso15tag.toJSON(), nil)
+            }
+            return
+        default:
+            detectionRetryCount += 1
+            if (detectionRetryCount < 5) {
+                usleep(ST25DVReader.DELAY)
+                session.restartPolling()
+                return
+            }
+            let error = NFCReaderError( NFCReaderError.ndefReaderSessionErrorTagNotWritable )
+           invalidateSession( message: error.localizedDescription  )
+           connectionCompleted?(error)
+           return
         }
     }
-
-    func invalidateSession( message :String) {
-        comSession?.alertMessage = message
-        comSession?.invalidate()
-    }
     
     func send( request: String, completed: @escaping (Data?,Error?)->() ) {
         
@@ -99,7 +101,7 @@ class ST25DVReader : NSObject {
         
         let requestData : Data = request.dataFromHexString()
         print( "Transceive - \(requestData.hexEncodedString())" )
-        transceive(request: requestData,
+        transceiveTap(request: requestData,
                    completed: { ( response: Data?, error: Error?) in
                             if nil != error {
                                 self.invalidateSession( message: error?.localizedDescription ?? "Error" )
@@ -116,76 +118,12 @@ class ST25DVReader : NSObject {
    
 }
 
-@available(iOS 13.0, *)
-extension ST25DVReader : NFCTagReaderSessionDelegate {
-    // MARK: - NFCTagReaderSessionDelegate
-    func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {
-        // If necessary, you may perform additional operations on session start.
-        // At this point RF polling is enabled.
-        print( "tagReaderSessionDidBecomeActive" )
-    }
- 
-    func tagReaderSession(_ session: NFCTagReaderSession, didInvalidateWithError error: Error) {
-       // If necessary, you may handle the error. Note session is no longer valid.
-        // You must create a new session to restart RF polling.
-        print( "tagReaderSession:didInvalidateWithError - \(error)" )
-        connectionCompleted?(error)
-        self.comSession = nil
-    }
-
-    func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) {
-        print( "tagReaderSession:didDectectTag" )
-        guard let session = self.comSession else {
-            return;
-        }
-        if tags.count > 1 {
-            // Restart polling in 500 milliseconds.
-            let retryInterval = DispatchTimeInterval.milliseconds(500)
-            session.alertMessage = "More than 1 Tap is detected. Please remove all tags and try again."
-            DispatchQueue.global().asyncAfter(deadline: .now() + retryInterval, execute: {
-                session.restartPolling()
-            })
-            return
-        }
-        
-        guard let tag = tags.first else {
-            return;
-        }
-            
-        switch tag {
-        case .iso15693(let iso15tag):
-            self.tag = iso15tag
-        default:
-            let error = NFCReaderError( NFCReaderError.ndefReaderSessionErrorTagNotWritable )
-           invalidateSession( message: error.localizedDescription  )
-           connectionCompleted?(error)
-           return;
-        }
-     
-        // Connect to tag
-        session.connect(to: tag) { [weak self] (error: Error?) in
-            guard let strongSelf = self  else {
-                return;
-            }
-            
-            if error != nil {
-                let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
-                strongSelf.invalidateSession( message: error.localizedDescription  )
-                strongSelf.connectionCompleted?(error)
-                return
-            }
-            print( "connected to tag" )
-            strongSelf.connectionCompleted?(nil)
-        }
-    }
-}
-
 @available(iOS 13.0, *)
 extension ST25DVReader {
     
     
 
-    func transceive(request: Data, completed: @escaping (Data?, Error?)->()){
+    func transceiveTap(request: Data, completed: @escaping (Data?, Error?)->()){
        
 
         checkMBEnabled( completed: { ( error: Error?) in
@@ -210,7 +148,7 @@ extension ST25DVReader {
     }
 
     func sendRequest(request: Data, nbTry: Int, completed: @escaping (Data?, Error?)->() ) {
-        guard let tag = self.tag else {
+        guard let tag = self.iso15Tag else {
             let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
             invalidateSession( message: error.localizedDescription  )
             completed(nil, error )
@@ -227,6 +165,7 @@ extension ST25DVReader {
         var parameters  = Data( bytes:[request.count - 1], count: 1 )
         parameters.append(request)
         print( "Send - \(parameters.hexEncodedString())" )
+
         tag.customCommand(requestFlags: [.highDataRate],
                           customCommandCode: 0xAA,
             customRequestParameters:  parameters,
@@ -244,7 +183,7 @@ extension ST25DVReader {
     
     func readResponse( nbTry: Int, completed: @escaping (Data?, Error?)->() ) {
         
-        guard let tag = self.tag else {
+        guard let tag = self.iso15Tag else {
             let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
             invalidateSession( message: error.localizedDescription  )
             completed( nil, error )
@@ -304,7 +243,7 @@ extension ST25DVReader {
     }
     
     func checkMBEnabled(completed: @escaping (Error?)->()) {
-        guard let tag = self.tag else {
+        guard let tag = self.iso15Tag else {
             let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
              invalidateSession( message: error.localizedDescription  )
              completed( error )
@@ -372,5 +311,67 @@ extension ST25DVReader {
                 
             })
     }
+    
+    //full transparent mode
+    
+    @available(iOS 14.0, *)
+    func transceiveRaw(request: Data, completed: @escaping (Data?, Error?) -> (), nbTry: Int = NB_MAX_RETRY) {
+        guard (request.count >= 2) else {
+            completed(nil, NFCReaderError(NFCReaderError.readerErrorInvalidParameterLength))
+            return
+        }
+        let flags = Int(request[0])
+        let commandCode = Int(request[1])
+        let dataToSend = request.dropFirst(2)
+        
+        print("TRANSCEIVE RAW SEND \(request.hexEncodedString())")
+        
+        guard let tag = self.iso15Tag else {
+            completed(nil, NFCReaderError(NFCReaderError.readerTransceiveErrorTagConnectionLost))
+            return
+        }
+        
+        print("TRANSCEIVE RAW SEND ON ISO15TAG TRY \(nbTry), SESSION READY \(String(describing: comSession?.isReady))")
+        
+        tag.sendRequest(requestFlags: flags, commandCode: commandCode, data: dataToSend, resultHandler: {(result: Result<(NFCISO15693ResponseFlag, Data?), any Error>) in
+
+            print("SEND_REQUEST_CALLBACK")
+            switch result {
+            case .success((let flag, let data)):
+                let firstByteBuffer = withUnsafeBytes(of: flag.rawValue) { Data($0)}
+                var resultData = Data(firstByteBuffer)
+                if let nonNilData = data {
+                    resultData.append(nonNilData)
+                }
+                print("TRANSCEIVE RAW RETURN \(resultData.hexEncodedString())")
+                completed(resultData, nil)
+                return
+            case .failure(let error):
+                print("TRANSCEIVE RAW ERROR \(error.localizedDescription), TRY \(nbTry)")
+                if (nbTry >= 0) {
+                    usleep(ST25DVReader.DELAY)
+                    return self.transceiveRaw(request: request, completed: completed, nbTry: nbTry - 1)
+                }
+                completed(nil, error)
+                return
+            }
+        })
+    }
 }
     
+extension NFCISO15693Tag {
+    
+    func toJSON(ndefMessage: NFCNDEFMessage? = nil) -> [AnyHashable: Any] {
+        
+        let wrapper = NSMutableDictionary()
+        wrapper.setValue([UInt8](self.identifier) , forKey: "id")
+        
+        let returnedJSON = NSMutableDictionary()
+        returnedJSON.setValue("tag", forKey: "type")
+        returnedJSON.setObject(wrapper, forKey: "tag" as NSString)
+        
+        
+
+        return returnedJSON as! [AnyHashable : Any]
+    }
+}

package/src/ios/NFCHelpers.swift

@@ -0,0 +1,23 @@
+
+public extension String {
+    
+     func dataFromHexString() -> Data {
+        var bytes = [UInt8]()
+        for i in 0..<(count/2) {
+            let range = index(self.startIndex, offsetBy: 2*i)..<index(self.startIndex, offsetBy: 2*i+2)
+            let stringBytes = self[range]
+            let byte = strtol((stringBytes as NSString).utf8String, nil, 16)
+            bytes.append(UInt8(byte))
+        }
+        return Data(bytes: UnsafePointer<UInt8>(bytes), count:bytes.count)
+    }
+    
+}
+
+public extension Data {
+    
+    func hexEncodedString() -> String {
+        let format = "%02hhX"
+        return map { String(format: format, $0) }.joined()
+    }
+}

package/src/ios/NFCPlugin-Bridging-Header.h

@@ -4,4 +4,4 @@
 //
 //  (c) 2018 IoTize Solutions
 
-#import "../../Classes/AppDelegate.h"
+#import "../../../Classes/AppDelegate.h"

package/src/ios/NFCTagReader.swift

@@ -0,0 +1,102 @@
+import CoreNFC
+
+@available(iOS 13.0, *)
+class NFCTagReader : NSObject, NFCTagReaderSessionDelegate  {
+
+    typealias Completion = (Error?) -> ()
+    typealias CompletionWithJSONResponse = ([AnyHashable: Any]?, Error?) -> ()
+        
+    internal var comSession: NFCTagReaderSession?
+    internal var tag: NFCTag?
+
+    static var   MB_CTRL_DYN : UInt8 = 0x0D
+    
+    internal var connectionCompleted :  Completion?
+    internal var onDiscoverCompletion :  CompletionWithJSONResponse?
+
+    
+    static var   DELAY : UInt32 = 1000;   // timeout resolution in millionths of second
+    static var   NB_MAX_RETRY : Int = 50;
+    
+    override init() {
+        super.init()
+    }
+    
+    func initSession( pollingOption: NFCTagReaderSession.PollingOption, alertMessage: String, completed: @escaping (Error?)->() ) {
+        return self.initSession(pollingOption: pollingOption, alertMessage: alertMessage, completed: completed, onDiscover: nil)
+    }
+    
+    func initSession( pollingOption: NFCTagReaderSession.PollingOption, alertMessage: String, completed: @escaping (Error?)->(), onDiscover: CompletionWithJSONResponse? ) {
+        connectionCompleted = completed
+        onDiscoverCompletion = onDiscover
+        
+        if NFCNDEFReaderSession.readingAvailable {
+            comSession = NFCTagReaderSession(pollingOption: pollingOption, delegate: self, queue: nil)
+            comSession?.alertMessage = alertMessage
+            comSession?.begin()
+        } else {
+            completed(NFCReaderError.readerTransceiveErrorSessionInvalidated as? Error)
+        }
+    }
+
+    func invalidateSession( message :String) {
+        comSession?.alertMessage = message
+        comSession?.invalidate()
+        tag = nil
+    }
+    
+    func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {
+        // If necessary, you may perform additional operations on session start.
+        // At this point RF polling is enabled.
+        print( "tagReaderSessionDidBecomeActive" )
+    }
+ 
+    func tagReaderSession(_ session: NFCTagReaderSession, didInvalidateWithError error: Error) {
+       // If necessary, you may handle the error. Note session is no longer valid.
+        // You must create a new session to restart RF polling.
+        print( "tagReaderSession:didInvalidateWithError - \(error)" )
+        connectionCompleted?(error)
+        self.comSession = nil
+    }
+
+    func tagReaderSession(_ session: NFCTagReaderSession, didDetect tags: [NFCTag]) {
+        print( "tagReaderSession:didDectectTag" )
+        guard let session = self.comSession else {
+            return;
+        }
+        if tags.count > 1 {
+            // Restart polling in 500 milliseconds.
+            let retryInterval = DispatchTimeInterval.milliseconds(500)
+            session.alertMessage = "More than 1 Tap is detected. Please remove all tags and try again."
+            DispatchQueue.global().asyncAfter(deadline: .now() + retryInterval, execute: {
+                session.restartPolling()
+            })
+            return
+        }
+        
+        guard let tag = tags.first else {
+            return;
+        }
+     
+        // Connect to tag
+        
+        session.connect(to: tag) { [weak self] (error: Error?) in
+            guard let strongSelf = self  else {
+                return;
+            }
+            
+            if error != nil {
+                let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
+                strongSelf.invalidateSession( message: error.localizedDescription  )
+                strongSelf.connectionCompleted?(error)
+                return
+            }
+            print( "connected to tag" )
+            strongSelf.tag = tag
+            strongSelf.connectionCompleted?(nil)
+        }
+    }
+    
+    
+
+}

package/src/ios/NFCTapPlugin.swift

@@ -57,17 +57,18 @@ import CoreNFC
 
     @objc(connect:)
     func connect(command: CDVInvokedUrlCommand) {
+        print("CONNECT NFC")
         guard #available(iOS 13.0, *) else {
             sendError(command: command, result: "connect is only available on iOS 13+")
             return
         }
         DispatchQueue.main.async {
-            print("Begin session \(self.nfcController)")
+            print("Begin session \(String(describing: self.nfcController))")
             if self.nfcController == nil {
                 self.nfcController = ST25DVReader()
             }
 
-            (self.nfcController as! ST25DVReader).initSession(alertMessage: "Bring your phone close to the Tap.", completed: {
+            (self.nfcController as! ST25DVReader).initSession(pollingOption: [.iso15693], alertMessage: "Bring your phone close to the Tap.", completed: {
                 (error: Error?) -> Void in
 
                 DispatchQueue.main.async {
@@ -93,13 +94,13 @@ import CoreNFC
                 return
             }
 
-            (self.nfcController as! ST25DVReader).invalidateSession(message: "Sesssion Ended!")
+            (self.nfcController as! NFCTagReader).invalidateSession(message: "Sesssion Ended!")
             self.nfcController = nil
         }
     }
 
-    @objc(transceive:)
-    func transceive(command: CDVInvokedUrlCommand) {
+    @objc(transceiveTap:)
+    func transceiveTap(command: CDVInvokedUrlCommand) {
         guard #available(iOS 13.0, *) else {
             sendError(command: command, result: "transceive is only available on iOS 13+")
             return
@@ -140,6 +141,13 @@ import CoreNFC
             })
         }
     }
+    
+    @objc(registerTag:)
+    func registerTag(command: CDVInvokedUrlCommand) {
+        print("Registered NDEF Listener")
+        //isListeningNDEF = true // Flag for the AppDelegate
+        sendSuccess(command: command, result: "Tag Listener is on")
+    }
 
     @objc(registerNdef:)
     func registerNdef(command: CDVInvokedUrlCommand) {
@@ -248,4 +256,121 @@ import CoreNFC
         let enabled = NFCReaderSession.readingAvailable
         sendSuccess(command: command, result: enabled)
     }
+    
+    //full transparent mode
+    @objc(transceive:)
+    func transceive(command: CDVInvokedUrlCommand) {
+        guard #available(iOS 14.0, *) else {
+            sendError(command: command, result: "Tranparent transceive is only available in iOS 14+")
+            return
+        }
+        
+        DispatchQueue.main.async {
+            print("sending ...")
+            if self.nfcController == nil {
+                self.sendError(command: command, result: "no session available")
+                return
+            }
+
+            // we need data to send
+            if command.arguments.count <= 0 {
+                self.sendError(command: command, result: "transceive parameter error")
+                return
+            }
+
+            guard let data: Data = command.arguments[0] as? Data else {
+                self.sendError(command: command, result: "Tried to transceive empty buffer")
+                return
+            }
+
+            (self.nfcController as! ST25DVReader).transceiveRaw(request: data, completed: {
+                (response: Data?, error: Error?) -> Void in
+
+                DispatchQueue.main.async {
+                    if error != nil {
+                        self.lastError = error
+                        self.sendError(command: command, result: error!.localizedDescription)
+                    } else {
+                        print("responded \(response!.hexEncodedString())")
+                        self.sendSuccess(command: command, result: response!.hexEncodedString())
+                    }
+                }
+            })
+        }
+    }
+    
+    @objc(beginSessionFromTech:)
+    func beginSessionFromTech(command: CDVInvokedUrlCommand) {
+        
+//        self.nfcController = nil // Clear previous session, if any
+        
+        guard #available(iOS 13.0, *) else {
+            sendError(command: command, result: "NFC Tag Session is only available in iOS 13+")
+            return
+        }
+        // we need data to send
+        if command.arguments.count <= 0 {
+            self.sendError(command: command, result: "beginSessionFromTech parameter error: missing tech")
+            return
+        }
+
+        guard let tech = command.argument(at: 0) as? String else {
+            self.sendError(command: command, result: "beginSessionFromTech parameter error: improper tech")
+            return
+        }
+        switch tech {
+        case "nfcV":
+            DispatchQueue.main.async {
+                print("Begin session \(String(describing: self.nfcController))")
+                if self.nfcController == nil {
+                    self.nfcController = ST25DVReader()
+                }
+
+                (self.nfcController as! ST25DVReader).initSession(pollingOption: [.iso15693], alertMessage: "Begin nfcV Session.", completed: {
+                    (error: Error?) -> Void in
+
+                    DispatchQueue.main.async {
+                        if error != nil {
+                            print("onBeginSessionFromTech error \(error!.localizedDescription)")
+                            self.sendError(command: command, result: error!.localizedDescription)
+                        } else {
+                            print("onBeginSessionFromTech sucess")
+                            self.sendSuccess(command: command, result: "nfcV session started")
+                        }
+                    }
+                }, onDiscover: {(discovered: [AnyHashable: Any]?, error: Error?) -> Void in
+                    DispatchQueue.main.async {
+                        if error != nil {
+                            print("onDiscover error \(error!.localizedDescription)")
+                            self.sendError(command: command, result: error!.localizedDescription)
+                        } else if (discovered != nil){
+                            print("onDiscover success")
+                            self.sendThroughChannel(jsonDictionary: discovered!)
+                        }
+                    }
+                })
+            }
+            return
+        default:
+            self.sendError(command: command, result: "Unsupported tech \(tech)")
+        }
+    }
+    
+    @objc(endSession:)
+    func endSession(command: CDVInvokedUrlCommand) {
+        guard #available(iOS 11.0, *) else {
+            sendError(command: command, result: "close is only available on iOS 13+")
+            return
+        }
+        DispatchQueue.main.async {
+            guard let session = self.ndefController?.session else {
+                self.sendError(command: command, result: "no session to terminate")
+                return
+            }
+
+            session.invalidate()
+            self.nfcController = nil
+            self.sendSuccess(command: command, result: "Session Ended!")
+        }
+    }
 }

package/www/cordova-interface.d.ts

@@ -9,10 +9,22 @@ export interface CordovaInterface {
     /**
      * Connect to current nfc tag
      */
-    connect(tech: string, timeout: number): Promise<void>;
+    connect(tech: string, timeout?: number): Promise<void>;
     /**
-     * Transeive data using
+     * Transeive data using Tap NFC communication protocol
+     * @param data ArrayBuffer or string of hex data for transcieve
+     */
+    transceiveTap(data: ArrayBuffer | string): Promise<string>;
+    /**
+     * Transeive raw data
      * @param data ArrayBuffer or string of hex data for transcieve
      */
     transceive(data: ArrayBuffer | string): Promise<string>;
+    setTapDeviceDiscoveryEnabled(value: boolean): Promise<void>;
+    /**
+     * Begins a reading session for the given technology.
+     * @param tech String representing the technology of the tap to discover.
+     */
+    beginSessionFromTech(tech: string): Promise<void>;
+    endSession(): Promise<void>;
 }