@iotize/device-com-nfc.cordova 3.1.0

package/src/ios/NFCNDEFDelegate.swift

@@ -0,0 +1,78 @@
+//
+//  NFCNDEFDelegate.swift
+//  NFC
+//
+//  Created by dev@iotize.com on 05/08/2019.
+//  Copyright © 2019 dev@iotize.com. All rights reserved.
+//
+
+import Foundation
+import CoreNFC
+
+class NFCNDEFDelegate: NSObject, NFCNDEFReaderSessionDelegate {
+    var session: NFCNDEFReaderSession?
+    var completed: ([AnyHashable : Any]?, Error?) -> ()
+    
+    init(completed: @escaping ([AnyHashable: Any]?, Error?) -> (), message: String?) {
+        self.completed = completed
+        super.init()
+        self.session = NFCNDEFReaderSession.init(delegate: self, queue: nil, invalidateAfterFirstRead: false)
+        if (self.session == nil) {
+            self.completed(nil, "NFC is not available" as? Error);
+            return
+        }
+        self.session!.alertMessage = message ?? ""
+        self.session!.begin()
+    }
+    
+    func readerSession(_: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
+        for message in messages {
+            self.fireNdefEvent(message: message)
+        }
+        self.session?.invalidate()
+    }
+    
+    func readerSession(_: NFCNDEFReaderSession, didInvalidateWithError _: Error) {
+        completed(nil, "NFCNDEFReaderSession error" as? Error)
+    }
+    
+    func readerSessionDidBecomeActive(_: NFCNDEFReaderSession) {
+        print("NDEF Reader session active")
+    }
+    
+    func fireNdefEvent(message: NFCNDEFMessage) {
+        let response = message.ndefMessageToJSON()
+        completed(response, nil)
+    }
+    
+    
+    
+}
+
+extension NFCNDEFMessage {
+    func ndefMessageToJSON() -> [AnyHashable: Any] {
+        let array = NSMutableArray()
+        for record in self.records {
+            let recordDictionary = self.ndefToNSDictionary(record: record)
+            array.add(recordDictionary)
+        }
+        let wrapper = NSMutableDictionary()
+        wrapper.setObject(array, forKey: "ndefMessage" as NSString)
+        
+        let returnedJSON = NSMutableDictionary()
+        returnedJSON.setValue("ndef", forKey: "type")
+        returnedJSON.setObject(wrapper, forKey: "tag" as NSString)
+
+        return returnedJSON as! [AnyHashable : Any]
+    }
+    
+    func ndefToNSDictionary(record: NFCNDEFPayload) -> NSDictionary {
+        let dict = NSMutableDictionary()
+        dict.setObject([record.typeNameFormat.rawValue], forKey: "tnf" as NSString)
+        dict.setObject([UInt8](record.type), forKey: "type" as NSString)
+        dict.setObject([UInt8](record.identifier), forKey: "id" as NSString)
+        dict.setObject([UInt8](record.payload), forKey: "payload" as NSString)
+        
+        return dict
+    }
+}

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

@@ -0,0 +1,7 @@
+//
+//  NFCPlugin-Bridging-Header.h
+//  PhoneGap NFC - Cordova Plugin
+//
+//  (c) 2018 IoTize Solutions
+
+#import "../../Classes/AppDelegate.h"

package/src/ios/NFCTapPlugin.swift

@@ -0,0 +1,251 @@
+//
+//  NFCTapPlugin.swift
+//  NFC
+//
+//  Created by dev@iotize.com on 23/07/2019.
+//  Copyright © 2019 dev@iotize.com. All rights reserved.
+//
+
+import Foundation
+import UIKit
+import CoreNFC
+
+// Main class handling the plugin functionalities.
+@objc(NfcPlugin) class NfcPlugin: CDVPlugin {
+    var nfcController: NSObject? // ST25DVReader downCast as NSObject for iOS version compatibility
+    var ndefController: NFCNDEFDelegate?
+    var lastError: Error?
+    var channelCommand: CDVInvokedUrlCommand?
+    var isListeningNDEF = false
+
+    // helper to return a string
+    func sendSuccess(command: CDVInvokedUrlCommand, result: String) {
+        let pluginResult = CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result
+        )
+        commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+    }
+
+    // helper to return a boolean
+    private func sendSuccess(command: CDVInvokedUrlCommand, result: Bool) {
+        let pluginResult = CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result
+        )
+        commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+    }
+
+    // helper to return a String with keeping the callback
+    func sendSuccessWithResponse(command: CDVInvokedUrlCommand, result: String) {
+        let pluginResult = CDVPluginResult(
+            status: CDVCommandStatus_OK,
+            messageAs: result
+        )
+        pluginResult!.setKeepCallbackAs(true)
+        commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+    }
+
+    // helper to send back an error
+    func sendError(command: CDVInvokedUrlCommand, result: String) {
+        let pluginResult = CDVPluginResult(
+            status: CDVCommandStatus_ERROR,
+            messageAs: result
+        )
+        commandDelegate!.send(pluginResult, callbackId: command.callbackId)
+    }
+
+    @objc(connect:)
+    func connect(command: CDVInvokedUrlCommand) {
+        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)")
+            if self.nfcController == nil {
+                self.nfcController = ST25DVReader()
+            }
+
+            (self.nfcController as! ST25DVReader).initSession(alertMessage: "Bring your phone close to the Tap.", completed: {
+                (error: Error?) -> Void in
+
+                DispatchQueue.main.async {
+                    if error != nil {
+                        self.sendError(command: command, result: error!.localizedDescription)
+                    } else {
+                        self.sendSuccess(command: command, result: "")
+                    }
+                }
+            })
+        }
+    }
+
+    @objc(close:)
+    func close(command: CDVInvokedUrlCommand) {
+        guard #available(iOS 13.0, *) else {
+            sendError(command: command, result: "close is only available on iOS 13+")
+            return
+        }
+        DispatchQueue.main.async {
+            if self.nfcController == nil {
+                self.sendError(command: command, result: "no session to terminate")
+                return
+            }
+
+            (self.nfcController as! ST25DVReader).invalidateSession(message: "Sesssion Ended!")
+            self.nfcController = nil
+        }
+    }
+
+    @objc(transceive:)
+    func transceive(command: CDVInvokedUrlCommand) {
+        guard #available(iOS 13.0, *) else {
+            sendError(command: command, result: "transceive is only available on iOS 13+")
+            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: "SendRequest parameter error")
+                return
+            }
+
+            guard let data: NSData = command.arguments[0] as? NSData else {
+                self.sendError(command: command, result: "Tried to transceive empty string")
+                return
+            }
+            let request = data.map { String(format: "%02x", $0) }
+                .joined()
+            print("send request  - \(request)")
+
+            (self.nfcController as! ST25DVReader).send(request: request, 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(registerNdef:)
+    func registerNdef(command: CDVInvokedUrlCommand) {
+        print("Registered NDEF Listener")
+        isListeningNDEF = true // Flag for the AppDelegate
+        sendSuccess(command: command, result: "NDEF Listener is on")
+    }
+
+    @objc(registerMimeType:)
+    func registerMimeType(command: CDVInvokedUrlCommand) {
+        print("Registered Mi Listener")
+        sendSuccess(command: command, result: "NDEF Listener is on")
+    }
+
+    @objc(beginNDEFSession:)
+    func beginNDEFSession(command: CDVInvokedUrlCommand) {
+        DispatchQueue.main.async {
+            print("Begin NDEF reading session")
+
+            if self.ndefController == nil {
+                var message: String?
+                if command.arguments.count != 0 {
+                    message = command.arguments[0] as? String ?? ""
+                }
+                self.ndefController = NFCNDEFDelegate(completed: {
+                    (response: [AnyHashable: Any]?, error: Error?) -> Void in
+                    DispatchQueue.main.async {
+                        print("handle NDEF")
+                        if error != nil {
+                            self.lastError = error
+                            self.sendError(command: command, result: error!.localizedDescription)
+                        } else {
+                            // self.sendSuccess(command: command, result: response ?? "")
+                            self.sendThroughChannel(jsonDictionary: response ?? [:])
+                        }
+                        self.ndefController = nil
+                    }
+                }, message: message)
+            }
+        }
+    }
+
+    @objc(invalidateNDEFSession:)
+    func invalidateNDEFSession(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!")
+        }
+    }
+
+    @objc(channel:)
+    func channel(command: CDVInvokedUrlCommand) {
+        DispatchQueue.main.async {
+            print("Creating NDEF Channel")
+            self.channelCommand = command
+            self.sendThroughChannel(message: "Did create NDEF Channel")
+        }
+    }
+
+    func sendThroughChannel(message: String) {
+        guard let command: CDVInvokedUrlCommand = self.channelCommand else {
+            print("Channel is not set")
+            return
+        }
+        guard let response = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: message) else {
+            print("sendThroughChannel Did not create CDVPluginResult")
+            return
+        }
+
+        response.setKeepCallbackAs(true)
+        commandDelegate!.send(response, callbackId: command.callbackId)
+    }
+
+    func sendThroughChannel(jsonDictionary: [AnyHashable: Any]) {
+        guard let command: CDVInvokedUrlCommand = self.channelCommand else {
+            print("Channel is not set")
+            return
+        }
+        guard let response = CDVPluginResult(status: CDVCommandStatus_OK, messageAs: jsonDictionary) else {
+            print("sendThroughChannel Did not create CDVPluginResult")
+            return
+        }
+
+        response.setKeepCallbackAs(true)
+        commandDelegate!.send(response, callbackId: command.callbackId)
+
+//        self.sendSuccessWithResponse(command: command, result: message)
+    }
+
+    @objc(enabled:)
+    func enabled(command: CDVInvokedUrlCommand) {
+        guard #available(iOS 11.0, *) else {
+            sendError(command: command, result: "enabled is only available on iOS 11+")
+            return
+        }
+        let enabled = NFCReaderSession.readingAvailable
+        sendSuccess(command: command, result: enabled)
+    }
+}

package/www/cordova-interface.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Partial typings for phonegap nfc cordova interface class
+ */
+export interface CordovaInterface {
+    /**
+     * Close current nfc tag
+     */
+    close(): Promise<void>;
+    /**
+     * Connect to current nfc tag
+     */
+    connect(tech: string, timeout: number): Promise<void>;
+    /**
+     * Transeive data using
+     * @param data ArrayBuffer or string of hex data for transcieve
+     */
+    transceive(data: ArrayBuffer | string): Promise<string>;
+}

package/www/errors.d.ts

@@ -0,0 +1,16 @@
+export declare class NfcError extends Error {
+    code: NfcError.ErrorCode;
+    constructor(code: NfcError.ErrorCode, message: string);
+    static tagLostError(): NfcError;
+    static notConnectedError(): NfcError;
+    static unknownError(errString: string): NfcError;
+    static internalError(message: string): void;
+}
+export declare namespace NfcError {
+    enum ErrorCode {
+        Unknown = "NfcUnknownError",
+        InternalError = "NfcInternalError",
+        TagLostError = "NfcTagLostError",
+        NotConnectedError = "NfcNotConnectedError"
+    }
+}

package/www/index.d.ts

@@ -0,0 +1,4 @@
+export * from './nfc-com-protocol';
+export * from './cordova-interface';
+export * from './errors';
+export * from './tap-ndef';

package/www/logger.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="@iotize/common/debug/@types/debug" />
+export declare const debug: import("debug").DebugFct;

package/www/nfc-com-protocol.d.ts

@@ -0,0 +1,14 @@
+import { ComProtocolConnectOptions, ComProtocolDisconnectOptions, ComProtocolOptions, ComProtocolSendOptions } from '@iotize/tap/protocol/api';
+import { QueueComProtocol } from '@iotize/tap/protocol/core';
+import { Observable } from 'rxjs';
+import { NfcError } from './errors';
+export declare class NFCComProtocol extends QueueComProtocol {
+    constructor(options?: ComProtocolOptions);
+    static iOSProtocol(): NFCComProtocol;
+    _connect(options?: ComProtocolConnectOptions): Observable<any>;
+    _disconnect(options?: ComProtocolDisconnectOptions): Observable<any>;
+    write(data: Uint8Array): Promise<any>;
+    read(): Promise<Uint8Array>;
+    send(data: Uint8Array, options?: ComProtocolSendOptions): Observable<Uint8Array>;
+    _onConnectionLost(error: NfcError): void;
+}