@iotize/device-com-nfc.cordova 3.1.0

package/src/android/src/com/chariotsolutions/nfc/plugin/NfcPluginError.java

@@ -0,0 +1,15 @@
+package com.chariotsolutions.nfc.plugin;
+
+class NfcPluginError extends Exception {
+
+    String code;
+
+    public String getCode() {
+        return code;
+    }
+
+    public NfcPluginError(String code, String message, Throwable cause) {
+        super(message, cause);
+        this.code = code;
+    }
+}

package/src/android/src/com/chariotsolutions/nfc/plugin/PluginResponse.java

@@ -0,0 +1,85 @@
+//
+//  Copyright 2018 IoTize SAS Inc.  Licensed under the MIT license. 
+//
+//  PluginResponse.java
+//  device-com-ble.cordova BLE Cordova Plugin
+//
+package com.chariotsolutions.nfc.plugin;
+
+import com.iotize.android.core.util.Helper;
+
+import org.apache.cordova.CallbackContext;
+import org.apache.cordova.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+public class PluginResponse {
+
+    private static final String TAG = "PluginResponse";
+    private final CallbackContext callbackContext;
+    private final String action;
+
+    public PluginResponse(String action, JSONArray args, CallbackContext callbackContext) {
+        this.callbackContext = callbackContext;
+        this.action = action;
+
+    }
+
+    public void newResult(String data) {
+        PluginResult result = new PluginResult(
+                PluginResult.Status.OK,
+                data
+        );
+        result.setKeepCallback(true);
+        this.callbackContext.sendPluginResult(result);
+    }
+
+    public void newResult(JSONObject data) {
+        PluginResult result = new PluginResult(
+                PluginResult.Status.OK,
+                data
+        );
+        result.setKeepCallback(true);
+        this.callbackContext.sendPluginResult(result);
+    }
+
+    public void newResult(NfcPluginError error) {
+        this.callbackContext.sendPluginResult(new PluginResult(
+                PluginResult.Status.ERROR,
+                JSONBuilder.toJSONObject(error)
+        ));
+    }
+
+    public void success(JSONObject object) {
+        this.callbackContext.success(object);
+    }
+
+    public void success(byte[] response) {
+        this.callbackContext.success(Helper.ByteArrayToHexString(response));
+    }
+
+    public void error(NfcPluginError err) {
+        JSONObject object = JSONBuilder.toJSONObject(err);
+        this.callbackContext.error(object);
+    }
+
+    public void success(boolean isConnected) {
+        this.callbackContext.sendPluginResult(new PluginResult(PluginResult.Status.OK, isConnected));    }
+
+    public void success() {
+        this.callbackContext.success();
+    }
+
+    public void error(String message) {
+        this.callbackContext.success(message);
+    }
+
+    public void success(String msg) {
+        this.callbackContext.success(msg);
+    }
+
+    public CallbackContext getCallbackContext() {
+        return callbackContext;
+    }
+
+}

package/src/android/src/com/chariotsolutions/nfc/plugin/Util.java

@@ -0,0 +1,140 @@
+package com.chariotsolutions.nfc.plugin;
+
+import android.nfc.NdefMessage;
+import android.nfc.NdefRecord;
+import android.nfc.Tag;
+import android.nfc.tech.Ndef;
+import android.util.Log;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Util {
+
+    static final String TAG = "NfcPlugin";
+
+    static JSONObject ndefToJSON(Ndef ndef) {
+        JSONObject json = new JSONObject();
+
+        if (ndef != null) {
+            try {
+
+                Tag tag = ndef.getTag();
+                // tag is going to be null for NDEF_FORMATABLE until NfcUtil.parseMessage is refactored
+                if (tag != null) {
+                    json.put("id", byteArrayToJSON(tag.getId()));
+                    json.put("techTypes", new JSONArray(Arrays.asList(tag.getTechList())));
+                }
+
+                json.put("type", translateType(ndef.getType()));
+                json.put("maxSize", ndef.getMaxSize());
+                json.put("isWritable", ndef.isWritable());
+                json.put("ndefMessage", messageToJSON(ndef.getCachedNdefMessage()));
+                // Workaround for bug in ICS (Android 4.0 and 4.0.1) where
+                // mTag.getTagService(); of the Ndef object sometimes returns null
+                // see http://issues.mroland.at/index.php?do=details&task_id=47
+                try {
+                  json.put("canMakeReadOnly", ndef.canMakeReadOnly());
+                } catch (NullPointerException e) {
+                  json.put("canMakeReadOnly", JSONObject.NULL);
+                }
+            } catch (JSONException e) {
+                Log.e(TAG, "Failed to convert ndef into json: " + ndef.toString(), e);
+            }
+        }
+        return json;
+    }
+
+    static JSONObject tagToJSON(Tag tag) {
+        JSONObject json = new JSONObject();
+
+        if (tag != null) {
+            try {
+                json.put("id", byteArrayToJSON(tag.getId()));
+                json.put("techTypes", new JSONArray(Arrays.asList(tag.getTechList())));
+            } catch (JSONException e) {
+                Log.e(TAG, "Failed to convert tag into json: " + tag.toString(), e);
+            }
+        }
+        return json;
+    }
+
+    static String translateType(String type) {
+        String translation;
+        if (type.equals(Ndef.NFC_FORUM_TYPE_1)) {
+            translation = "NFC Forum Type 1";
+        } else if (type.equals(Ndef.NFC_FORUM_TYPE_2)) {
+            translation = "NFC Forum Type 2";
+        } else if (type.equals(Ndef.NFC_FORUM_TYPE_3)) {
+            translation = "NFC Forum Type 3";
+        } else if (type.equals(Ndef.NFC_FORUM_TYPE_4)) {
+            translation = "NFC Forum Type 4";
+        } else {
+            translation = type;
+        }
+        return translation;
+    }
+
+    static NdefRecord[] jsonToNdefRecords(String ndefMessageAsJSON) throws JSONException {
+        JSONArray jsonRecords = new JSONArray(ndefMessageAsJSON);
+        NdefRecord[] records = new NdefRecord[jsonRecords.length()];
+        for (int i = 0; i < jsonRecords.length(); i++) {
+            JSONObject record = jsonRecords.getJSONObject(i);
+            byte tnf = (byte) record.getInt("tnf");
+            byte[] type = jsonToByteArray(record.getJSONArray("type"));
+            byte[] id = jsonToByteArray(record.getJSONArray("id"));
+            byte[] payload = jsonToByteArray(record.getJSONArray("payload"));
+            records[i] = new NdefRecord(tnf, type, id, payload);
+        }
+        return records;
+    }
+
+    static JSONArray byteArrayToJSON(byte[] bytes) {
+        JSONArray json = new JSONArray();
+        for (byte aByte : bytes) {
+            json.put(aByte);
+        }
+        return json;
+    }
+
+    static byte[] jsonToByteArray(JSONArray json) throws JSONException {
+        byte[] b = new byte[json.length()];
+        for (int i = 0; i < json.length(); i++) {
+            b[i] = (byte) json.getInt(i);
+        }
+        return b;
+    }
+
+    static JSONArray messageToJSON(NdefMessage message) {
+        if (message == null) {
+            return null;
+        }
+
+        List<JSONObject> list = new ArrayList<JSONObject>();
+
+        for (NdefRecord ndefRecord : message.getRecords()) {
+            list.add(recordToJSON(ndefRecord));
+        }
+
+        return new JSONArray(list);
+    }
+
+    static JSONObject recordToJSON(NdefRecord record) {
+        JSONObject json = new JSONObject();
+        try {
+            json.put("tnf", record.getTnf());
+            json.put("type", byteArrayToJSON(record.getType()));
+            json.put("id", byteArrayToJSON(record.getId()));
+            json.put("payload", byteArrayToJSON(record.getPayload()));
+        } catch (JSONException e) {
+            //Not sure why this would happen, documentation is unclear.
+            Log.e(TAG, "Failed to convert ndef record into json: " + record.toString(), e);
+        }
+        return json;
+    }
+
+}

package/src/ios/AppDelegate+NFC.swift

@@ -0,0 +1,51 @@
+//
+//  AppDelegate+NFC.swift
+//  PhoneGap NFC - Cordova Plugin
+//
+//  Copyright © 2019 dev@iotize.com. All rights reserved.
+
+import CoreNFC
+
+extension AppDelegate {
+    
+    override open func application(_ application: UIApplication,
+                     continue userActivity: NSUserActivity,
+                     restorationHandler: @escaping ([Any]?) -> Void) -> Bool {
+        
+        NSLog("Extending UIApplicationDelegate")
+        
+        guard userActivity.activityType == NSUserActivityTypeBrowsingWeb else {
+            return false
+        }
+        
+        // Confirm that the NSUserActivity object contains a valid NDEF message.
+        if #available(iOS 12.0, *) {
+            let ndefMessage = userActivity.ndefMessagePayload
+            guard ndefMessage.records.count > 0,
+            ndefMessage.records[0].typeNameFormat != .empty else {
+                return false
+            }
+            let nfcPluginInstance: NfcPlugin = self.viewController.getCommandInstance("NfcPlugin") as! NfcPlugin
+            var resolved: Bool = false;
+            NSLog(nfcPluginInstance.debugDescription);
+            
+            DispatchQueue.global().async {
+                let waitingTimeInterval: Double = 0.1;
+                print("<NFC> Did start timeout")
+                for _ in 1...2000 { // 5?s timeout
+                    if ( !nfcPluginInstance.isListeningNDEF ) {
+                    Thread.sleep(forTimeInterval: waitingTimeInterval)
+                    } else {
+                        let jsonDictionary = ndefMessage.ndefMessageToJSON()
+                        nfcPluginInstance.sendThroughChannel(jsonDictionary: jsonDictionary)
+                        resolved = true
+                        return
+                    }
+                }
+        }
+            return resolved
+        } else {
+            return false
+        }
+    }
+}

package/src/ios/ISO15Reader.swift

@@ -0,0 +1,376 @@
+//
+//  IOS15Reader.swift
+//  NFC
+//
+//  Created by dev@iotize.com on 23/07/2019.
+//  Copyright © 2019 dev@iotize.com. All rights reserved.
+//
+
+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?
+    
+    /*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;
+    
+    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()
+    }
+
+    func initSession( alertMessage: String, completed: @escaping (Error?)->() ) {
+        
+        guard NFCNDEFReaderSession.readingAvailable else {
+            completed( NFCReaderError( NFCReaderError.readerErrorUnsupportedFeature ))
+            return
+        }
+        
+        connectionCompleted = completed
+        
+        if NFCNDEFReaderSession.readingAvailable {
+            comSession = NFCTagReaderSession(pollingOption: [.iso15693], delegate: self, queue: nil)
+            comSession?.alertMessage = alertMessage
+            comSession?.begin()
+        }
+    }
+
+    func invalidateSession( message :String) {
+        comSession?.alertMessage = message
+        comSession?.invalidate()
+    }
+    
+    func send( request: String, completed: @escaping (Data?,Error?)->() ) {
+        
+        guard NFCNDEFReaderSession.readingAvailable else {
+            let error = NFCReaderError( NFCReaderError.readerErrorUnsupportedFeature )
+            invalidateSession( message: error.localizedDescription )
+            completed( nil, error )
+            return
+        }
+        
+        guard comSession != nil && comSession!.isReady else {
+            let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
+            invalidateSession( message: error.localizedDescription )
+            completed( nil, error )
+            return
+        }
+        
+        let requestData : Data = request.dataFromHexString()
+        print( "Transceive - \(requestData.hexEncodedString())" )
+        transceive(request: requestData,
+                   completed: { ( response: Data?, error: Error?) in
+                            if nil != error {
+                                self.invalidateSession( message: error?.localizedDescription ?? "Error" )
+                                completed( nil, error )
+                                return
+                            }
+                            else {
+                                completed( response, nil)
+                                return
+                            }
+                    })
+    }
+    
+   
+}
+
+@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?)->()){
+       
+
+        checkMBEnabled( completed: { ( error: Error?) in
+                if nil != error {
+                    self.invalidateSession( message: error?.localizedDescription ?? "Error" )
+                    completed( nil, error )
+                    return
+                }
+                print( "Com enabled" )
+                self.sendRequest( request: request,
+                    nbTry: ST25DVReader.NB_MAX_RETRY,
+                    completed: { ( response: Data?, error: Error?) in
+                        if nil != error {
+                            self.invalidateSession( message: error?.localizedDescription ?? "Error" )
+                            completed( nil, error )
+                            return
+                        }
+                        completed(response, nil)
+                    })
+            })
+    
+    }
+
+    func sendRequest(request: Data, nbTry: Int, completed: @escaping (Data?, Error?)->() ) {
+        guard let tag = self.tag else {
+            let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
+            invalidateSession( message: error.localizedDescription  )
+            completed(nil, error )
+            return;
+        }
+
+        if (nbTry <= 0){
+            let error = NFCReaderError( NFCReaderError.readerTransceiveErrorRetryExceeded )
+            invalidateSession( message: error.localizedDescription  )
+            completed(nil, error )
+            return
+        }
+        
+        var parameters  = Data( bytes:[request.count - 1], count: 1 )
+        parameters.append(request)
+        print( "Send - \(parameters.hexEncodedString())" )
+        tag.customCommand(requestFlags: [.highDataRate],
+                          customCommandCode: 0xAA,
+            customRequestParameters:  parameters,
+            completionHandler: { (response: Data?, error: Error?) in
+                if nil != error {
+                    usleep(ST25DVReader.DELAY)
+                    self.sendRequest( request: request, nbTry: nbTry - 1, completed: completed )
+                    return
+                }
+                    usleep(ST25DVReader.DELAY * 10) // free ST25DV for SPI
+                    self.readResponse( nbTry: nbTry , completed: completed)
+            })
+        
+    }
+    
+    func readResponse( nbTry: Int, completed: @escaping (Data?, Error?)->() ) {
+        
+        guard let tag = self.tag else {
+            let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
+            invalidateSession( message: error.localizedDescription  )
+            completed( nil, error )
+            return;
+        }
+        
+        //We have tried enough timeout and return
+        if (nbTry <= 0){
+            print( "Read Abandonned" )
+            let error = NFCReaderError( NFCReaderError.readerTransceiveErrorRetryExceeded )
+            invalidateSession( message: error.localizedDescription  )
+            completed( nil, error )
+            return;
+        }
+        
+        print( "Read \(nbTry)" )
+  
+        //check Mailbox
+        tag.customCommand(requestFlags: [.highDataRate],
+                          customCommandCode: 0xAD,
+                          customRequestParameters:  Data(bytes: [UInt8(0x0D)], count: 1),
+                          completionHandler: { (response: Data, error: Error?) in
+                            if nil != error {
+                                usleep(ST25DVReader.DELAY)
+                                self.readResponse( nbTry: nbTry - 1, completed: completed )
+                                return
+                            }
+                            
+                            print( "Read resonse" )
+                            
+                            if ( (response.count >= 1) && ( (response[0]&0x1) != 0 ) && ( (response[0]&0x2) != 0  )){
+
+                                print( "Read Value - \(Data(response).hexEncodedString())" )
+                                tag.customCommand(requestFlags: [.highDataRate],
+                                                  customCommandCode: 0xAC,
+                                                  customRequestParameters:  Data(bytes: [UInt8(0), UInt8(0)], count: 2),
+                                                  completionHandler: { (response: Data, error: Error?) in
+                                                    if nil != error {
+                                                        self.invalidateSession( message: error?.localizedDescription ?? "Error" )
+                                                        completed( nil, error )
+                                                        return
+                                                    }
+                                                    print( "got Value - \(Data(response).hexEncodedString())" )
+                                                    completed(response,nil)
+                                                    return
+                                })
+                               
+                            }
+                            else {
+                                usleep(ST25DVReader.DELAY)
+                                self.readResponse( nbTry: nbTry - 1, completed: completed )
+                            }
+                        
+            })
+        
+        
+    }
+    
+    func checkMBEnabled(completed: @escaping (Error?)->()) {
+        guard let tag = self.tag else {
+            let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagNotConnected )
+             invalidateSession( message: error.localizedDescription  )
+             completed( error )
+            return;
+        }
+        
+        //Read Config
+        tag.customCommand(requestFlags: [.highDataRate],
+            customCommandCode: 0xAD,
+            customRequestParameters:  Data(bytes: [UInt8(0x0D)], count: 1),
+            completionHandler: { (response: Data, error: Error?) in
+                if nil != error {
+                    self.invalidateSession( message: error?.localizedDescription ?? "Error"  )
+                    completed(error)
+                    return
+                }
+            
+                if ( response.count == 0) {
+                    let error = NFCReaderError( NFCReaderError.readerTransceiveErrorTagResponseError )
+                    self.invalidateSession( message: error.localizedDescription  )
+                    completed( error )
+                    return
+                }
+
+                
+                let current = response[0];
+                
+                //We should reset mailbox
+                if ( (current != 0x41) && (current != 0x81) ) {
+            
+                    //disable
+                    tag.customCommand(requestFlags: [.highDataRate],
+                        customCommandCode: 0xAE,
+                        customRequestParameters:  Data(bytes: [UInt8(0x0D), UInt8(0x00)], count: 2),
+                        completionHandler: { (response: Data, error: Error?) in
+                            if nil != error {
+                                self.invalidateSession( message: error?.localizedDescription ?? "Error" )
+                                completed( error )
+                                return
+                            }
+                            
+                            //enable
+                            tag.customCommand(requestFlags: [.highDataRate],
+                                customCommandCode: 0xAE,
+                                customRequestParameters:  Data(bytes: [UInt8(0x0D), UInt8(0x01)], count: 2),
+                                completionHandler: { (response: Data, error: Error?) in
+                                    if nil != error {
+                                        self.invalidateSession( message: error?.localizedDescription ?? "Error" )
+                                        completed( error )
+                                        return
+                                    }
+                                  
+                                    completed(nil)
+                                    return
+
+                                })
+                        })
+                }
+                    //We are ok to go
+                else
+                {
+                    completed(nil)
+                    return
+                }
+                
+            })
+    }
+}
+