community-cordova-plugin-nfc 1.3.0

package/src/windows/nfc-plugin.js

@@ -0,0 +1,285 @@
+/* globals:  export, module, console, document, ndef, Windows, Uint8Array */
+
+"use strict";
+
+var STATUS_NFC_OK = "NFC_OK";
+var STATUS_NO_NFC = "NO_NFC";
+var STATUS_NFC_DISABLED = "NFC_DISABLED";
+// I don't think there is a Windows API to determine if NFC exists
+var STATUS_NO_NFC_OR_NFC_DISABLED = "NO_NFC_OR_NFC_DISABLED";
+var STATUS_NDEF_PUSH_DISABLED = "NDEF_PUSH_DISABLED";
+
+var ndefUtils = {
+    // convert Uint8Array to []
+    toArray: function (bytes) {
+        var output = [], i = 0;
+        for (; i < bytes.length; i += 1) {
+            output.push(bytes[i]);
+        }
+
+        return output;
+    }
+};
+
+var self = {
+    subscribedMessageId: -1,
+    publishedMessageId: -1,
+    proximityDeviceStatus: STATUS_NO_NFC_OR_NFC_DISABLED,
+    listeningForNonNdefTags: false,
+    tagEventTimeoutId: -1,
+    initializeProximityDevice: function() {
+        if (self.proximityDevice) {
+            // TODO Is there an API to tell if the user disabled NFC?
+            try {
+                // KLUDGE this call fails when the user has disabled the device
+                var kludge = self.proximityDevice.maxMessageBytes;
+                self.proximityDeviceStatus = STATUS_NFC_OK;
+            } catch (e) {
+                console.log(e);
+                self.proximityDeviceStatus = STATUS_NFC_DISABLED;
+            }
+            return self.proximityDeviceStatus === STATUS_NFC_OK;
+        }
+
+        // try to get device again because user might have re-enabled the device
+        self.proximityDevice = Windows.Networking.Proximity.ProximityDevice.getDefault();
+
+        // TODO use these events to implement nfc.addTagDiscoveredListener
+        if (self.proximityDevice) {
+            self.proximityDevice.ondevicearrived = function (eventArgs) {
+                console.log("NFC tag detected");
+                if (self.listeningForNonNdefTags) {
+                    // set a timeout so NDEF tags can cancel this event
+                    // we want one event to mimic the Android behavior
+                    self.tagEventTimeoutId = setTimeout(self.fireTagEvent, 100);
+                }
+            };
+
+            self.proximityDevice.ondevicedeparted = function (eventArgs) {
+                console.log("NFC tag is gone");
+            };
+        } else {
+            self.proximityDeviceStatus = STATUS_NO_NFC_OR_NFC_DISABLED;
+        }
+
+        return self.proximityDeviceStatus === STATUS_NFC_OK;
+    },
+    init: function (success, failure, args) {
+
+        self.initializeProximityDevice();
+
+        if (!self.proximityDevice) {
+            console.log("WARNING: proximity device is null");
+        }
+
+        success();
+    },
+    registerNdef: function (success, failure, args) {
+        console.log("Listening for NFC tags with NDEF messages.");
+
+        if (!self.initializeProximityDevice()) {
+            failure(self.proximityDeviceStatus);
+            return;
+        }
+
+        try {
+            self.subscribedMessageId = self.proximityDevice.subscribeForMessage("NDEF", self.messageReceivedHandler);
+            success();
+        } catch (e) {
+            console.log(e);
+            failure(e);
+        }
+    },
+    removeNdef: function (success, failure, args) {
+
+        console.log("Removing NDEF Listener");
+
+        if (!self.initializeProximityDevice()) {
+            failure(self.proximityDeviceStatus);
+            return;
+        }
+
+        try {
+            if (self.subscribedMessageId !== -1) {
+                self.proximityDevice.stopSubscribingForMessage(self.subscribedMessageId);
+                self.subscribedMessageId = -1;
+            }
+
+            success();
+        } catch (e) {
+            console.log(e);
+            failure(e.message);
+        }
+    },
+    addTagDiscoveredListener: function(success, failure, args) {
+        self.listeningForNonNdefTags = true;
+        success();
+    },
+    remoteTagDiscoveredListener: function(success, failure, args) {
+        self.listeningForNonNdefTags = false;
+        success();
+    },
+    writeTag: function (success, failure, args) {
+
+        console.log("Write Tag");
+
+        if (!self.initializeProximityDevice()) {
+            failure(self.proximityDeviceStatus);
+            return;
+        }
+
+        try {
+            var records = args[0];
+            var bytes = ndef.encodeMessage(records);
+
+            self.stopPublishing();
+
+            var dataWriter = new Windows.Storage.Streams.DataWriter();
+            dataWriter.unicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.utf16LE;
+            dataWriter.writeBytes(bytes);
+
+            self.publishedMessageId = self.proximityDevice.publishBinaryMessage("NDEF:WriteTag",
+                dataWriter.detachBuffer(),
+                function (sender, messageId) {
+                      console.log("Successfully wrote message to the NFC tag.");
+                      self.stopPublishing();
+
+                      success();
+                }
+            );
+
+        } catch (e) {
+            console.log(e);
+            failure(e.message);
+        }
+    },
+    shareTag: function(success, failure, args) {
+
+        console.log("Share Tag");
+
+        if (!self.initializeProximityDevice()) {
+            failure(self.proximityDeviceStatus);
+            return;
+        }
+
+        try {
+            var records = args[0];
+            var bytes = ndef.encodeMessage(records);
+
+            self.stopPublishing();
+
+            var dataWriter = new Windows.Storage.Streams.DataWriter();
+            dataWriter.unicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.utf16LE;
+            dataWriter.writeBytes(bytes);
+
+            self.publishedMessageId = self.proximityDevice.publishBinaryMessage("NDEF",
+                dataWriter.detachBuffer(),
+                function (sender, messageId) {
+                    console.log("Successfully shared message over peer-to-peer.");
+                    self.stopPublishing();
+
+                    success();
+                });
+
+        } catch (e) {
+            console.log(e);
+            failure(e.message);
+        }
+    },
+    unshareTag: function(success, failure, args) {
+        console.log("Unshare Tag");
+
+        if (!self.initializeProximityDevice()) {
+            failure(self.proximityDeviceStatus);
+            return;
+        }
+
+        try {
+            self.stopPublishing();
+            success();
+        } catch (e) {
+            console.log(e);
+            failure(e.message);
+        }
+    },
+    enabled: function(success, failure, args) {
+        self.initializeProximityDevice();
+
+        if (self.initializeProximityDevice()) {
+            success();
+        } else {
+            failure(self.proximityDeviceStatus);
+        }
+
+    },
+    showSettings: function(success, failure, args) {
+
+        // WARNING: this isn't documented, so it might break
+        var nfcSettingsUri = "ms-settings-proximity:";
+        var uri = new Windows.Foundation.Uri(nfcSettingsUri);
+
+        Windows.System.Launcher.launchUriAsync(uri).then(
+            function (settingsAppeared) {
+                if (settingsAppeared) {
+                    success();
+                } else {
+                    failure();
+                }
+            }
+        );
+    },
+    stopPublishing: function() {
+        if (self.publishedMessageId !== -1) {
+            self.proximityDevice.stopPublishingMessage(self.publishedMessageId);
+            self.publishedMessageId = -1;
+        }
+    },
+    messageReceivedHandler: function (sender, message) {
+
+        // this is an NDEF message so cancel the tag event before it fires
+        clearTimeout(self.tagEventTimeoutId);
+
+        var bytes = new Uint8Array(message.data.length);
+        var dataReader = Windows.Storage.Streams.DataReader.fromBuffer(message.data);
+        dataReader.readBytes(bytes);
+        dataReader.close();
+
+        var byteArray = ndefUtils.toArray(bytes);
+        var ndefMessage = ndef.decodeMessage(byteArray);
+        console.log(JSON.stringify(ndefMessage));
+
+        // on windows, tag only contains the ndef message
+        // other platforms have tag data
+        var tag = {
+            ndefMessage: ndefMessage
+        };
+
+        // fire JavaScript event with NDEF data
+        var e = document.createEvent('Events');
+        e.initEvent("ndef", true, false);
+        e.tag = tag;
+        document.dispatchEvent(e);
+    },
+    fireTagEvent: function() {
+        var e = document.createEvent('Events');
+        e.initEvent("tag", true, false);
+        // unfortunately we don't have any tag metadata
+        e.tag = {};
+        document.dispatchEvent(e);
+    }
+};
+
+module.exports = {
+    init: self.init,
+    registerNdef: self.registerNdef,
+    removeNdef: self.removeNdef,
+    registerTag: self.addTagDiscoveredListener,
+    remoteTag: self.removeTagDiscoveredListener,
+    writeTag: self.writeTag,
+    shareTag: self.shareTag,
+    unshareTag: self.unshareTag,
+    enabled: self.enabled,
+    showSettings: self.showSettings
+}
+
+require("cordova/exec/proxy").add("NfcPlugin", module.exports);

package/src/windows-phone-8/Ndef.cs

@@ -0,0 +1,191 @@
+using System.Runtime.Serialization;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.IO;
+
+using System.Runtime.InteropServices.WindowsRuntime;
+using Windows.Storage.Streams;
+
+namespace ChariotSolutions.NFC.NDEF
+{
+    public class Ndef
+    {
+        public static List<NdefRecord> parse(byte[] bytes)
+        {
+            List<NdefRecord> records = new List<NdefRecord>();
+            int index = 0;
+
+            while (index <= bytes.Length)
+            {
+                byte tnf_byte = bytes[index];
+                bool mb = (tnf_byte & 0x80) != 0;
+                bool me = (tnf_byte & 0x40) != 0;
+                bool cf = (tnf_byte & 0x20) != 0;
+                bool sr = (tnf_byte & 0x10) != 0;
+                bool il = (tnf_byte & 0x8) != 0;
+                int tnf = tnf_byte & 0x7;
+
+                if (cf)
+                {
+                    // TODO implement me
+                    throw new IOException("Chunked records are not supported.");
+                }
+
+                index++;
+                int typeLength = bytes[index];
+                int idLength = 0;
+                int payloadLength = 0;
+
+                if (sr)
+                {
+                    index++;
+                    payloadLength = bytes[index];
+                }
+                else
+                {
+                    payloadLength = ((0xFF & bytes[++index]) << 24) |
+                                    ((0xFF & bytes[++index]) << 26) |
+                                    ((0xFF & bytes[++index]) << 8) |
+                                    (0xFF & bytes[++index]);
+                }
+
+                if (il)
+                {
+                    index++;
+                    idLength = bytes[index];
+                }
+
+                index++;
+                IBuffer type = bytes.AsBuffer(index, typeLength);
+                index += typeLength;
+
+                IBuffer id = bytes.AsBuffer(index, idLength);
+                index += idLength;
+
+                IBuffer payload = bytes.AsBuffer(index, payloadLength);
+                index += payloadLength;
+
+                NdefRecord record = new NdefRecord();
+                record.tnf = (byte)tnf;
+                record.type = typeLength > 0 ? type.ToArray() : new byte[0];
+                record.id = idLength > 0 ? id.ToArray() : new byte[0];
+                record.payload = payloadLength > 0 ? payload.ToArray() : new byte[0];
+
+                records.Add(record);
+
+                if (me) break;  // last message
+            }
+
+            return records;
+        }
+
+        public static byte[] toBytes(NdefRecord[] records)
+        {
+            MemoryStream encoded = new MemoryStream();
+
+            for (int i = 0; i < records.Length; i++)
+            {
+
+                bool mb = (i == 0);
+                bool me = (i == (records.Length - 1));
+                bool cf = false; // TODO
+                bool sr = (records[i].payload.Length < 0xFF);
+                bool il = (records[i].id.Length > 0);
+
+                byte tnf_byte = encodeTnf(mb, me, cf, sr, il, records[i].tnf);
+                encoded.WriteByte(tnf_byte);
+
+                int type_length = records[i].type.Length;
+                encoded.WriteByte((byte)type_length);
+
+                int payload_length = records[i].payload.Length;
+                if (sr)
+                {
+                    encoded.WriteByte((byte)payload_length);
+                }
+                else
+                {
+                    // 4 bytes
+                    encoded.WriteByte((byte)(payload_length >> 24));
+                    encoded.WriteByte((byte)(payload_length >> 16));
+                    encoded.WriteByte((byte)(payload_length >> 8));
+                    encoded.WriteByte((byte)(payload_length & 0xFF));
+                }
+
+                int id_length = 0;
+                if (il)
+                {
+                    id_length = records[i].id.Length;
+                    encoded.WriteByte((byte)id_length);
+                }
+
+                encoded.Write(records[i].type, 0, type_length);
+                if (il)
+                {
+                    encoded.Write(records[i].id, 0, id_length);
+                }
+
+                encoded.Write(records[i].payload, 0, payload_length);
+            }
+            return encoded.ToArray();
+        }
+
+        static byte encodeTnf(bool mb, bool me, bool cf, bool sr, bool il, byte tnf)
+        {
+            byte value = tnf;
+
+            if (mb)
+            {
+                value = (byte)(value | 0x80);
+            }
+
+            if (me)
+            {
+                value = (byte)(value | 0x40);
+            }
+
+            if (cf)
+            {
+                value = (byte)(value | 0x20);
+            }
+
+            if (sr)
+            {
+                value = (byte)(value | 0x10);
+            }
+
+            if (il)
+            {
+                value = (byte)(value | 0x8);
+            }
+
+            if (cf)  // check
+            {
+                if (!(tnf == 0x06 && !mb && !me && !il))
+                {
+                    throw new IOException("When cf is true, mb, me and il must be false and tnf must be 0x6");
+                }
+            }
+
+            return value;
+        }
+    }
+
+    [DataContract]
+    public class NdefRecord
+    {
+        [DataMember]
+        public byte tnf { get; set; }
+        [DataMember]
+        public byte[] type { get; set; }
+        [DataMember]
+        public byte[] id { get; set; }
+        [DataMember]
+        public byte[] payload { get; set; }
+    }
+
+}

package/src/windows-phone-8/NfcPlugin.cs

@@ -0,0 +1,200 @@
+using System.Runtime.Serialization;
+using Windows.Networking.Proximity;
+using WPCordovaClassLib.Cordova;
+using WPCordovaClassLib.Cordova.Commands;
+using WPCordovaClassLib.Cordova.JSON;
+
+using System.Runtime.InteropServices.WindowsRuntime;
+using Windows.Storage.Streams;
+using System.Diagnostics;
+using System.IO;
+
+using System.Collections.Generic;
+using System.Text;
+using System.Collections;
+
+using ChariotSolutions.NFC.NDEF;
+
+// 
+// http://www.nfc-forum.org/specs/spec_list/
+// http://msdn.microsoft.com/en-us/library/windows/apps/br241250.aspx
+// 
+
+namespace Cordova.Extension.Commands
+{
+    class NfcPlugin : BaseCommand
+    {
+        private ProximityDevice proximityDevice;
+        private long subscribedMessageId = -1;
+        private long publishedMessageId = -1;
+
+        public NfcPlugin()
+        {
+            Debug.WriteLine("Nfc Plugin");
+            proximityDevice = ProximityDevice.GetDefault();
+            if (proximityDevice == null) // shouldn't happen
+            {
+                Debug.WriteLine("WARNING: proximity device is null");
+            }
+        }
+
+        public void init(string args)
+        {
+            // not used for WP8
+        }
+
+        // no args
+        public void registerNdef(string args)
+        {
+            Debug.WriteLine("Registering for NDEF");
+
+            try
+            {
+                subscribedMessageId = proximityDevice.SubscribeForMessage("NDEF", MessageReceivedHandler);
+                DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+            }
+            catch (System.Exception e)
+            {
+                Debug.WriteLine(e);
+                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+            }
+        }
+
+        // no args
+        public void removeNdef(string args)
+        {
+            Debug.WriteLine("Removing NDEF");
+
+            try
+            {
+                if (subscribedMessageId != -1)
+                {
+                    proximityDevice.StopSubscribingForMessage(subscribedMessageId);
+                    subscribedMessageId = -1;
+                }
+                DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+            }
+            catch (System.Exception e)
+            {
+                Debug.WriteLine(e);
+                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+            }
+
+        }
+
+        // args[0] is a NdefMessage, which is a JSON array of NdefRecords
+        public void writeTag(string args)
+        {
+            Debug.WriteLine("Write Tag");
+
+            try
+            {
+                string ndefMessage = JsonHelper.Deserialize<string[]>(args)[0];
+                NdefRecord[] records = JsonHelper.Deserialize<NdefRecord[]>(ndefMessage);
+                byte[] data = Ndef.toBytes(records);
+
+                stopPublishing();
+                publishedMessageId = proximityDevice.PublishBinaryMessage("NDEF:WriteTag", data.AsBuffer(), nfcWriteTagCallback);
+
+                // send no result now, C# callback will send success after write
+                PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
+                result.KeepCallback = true;
+                DispatchCommandResult(result);
+            }
+            catch (System.Exception e)
+            {
+                Debug.WriteLine(e);
+                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+            }
+        }
+
+        // args[0] is a NdefMessage, which is a JSON array of NdefRecords
+        public void shareTag(string args)
+        {
+            Debug.WriteLine("Share Tag");
+
+            try
+            {
+                string ndefMessage = JsonHelper.Deserialize<string[]>(args)[0];
+                NdefRecord[] records = JsonHelper.Deserialize<NdefRecord[]>(ndefMessage);
+                byte[] data = Ndef.toBytes(records);
+            
+                stopPublishing();
+                publishedMessageId = proximityDevice.PublishBinaryMessage("NDEF", data.AsBuffer());
+                DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+            }
+            catch (System.Exception e)
+            {
+                Debug.WriteLine(e);
+                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+            }
+        }
+
+        // no args
+        public void unshareTag(string args)
+        {
+            Debug.WriteLine("Unshare Tag");
+
+            try
+            {
+                stopPublishing();
+                DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+            }
+            catch (System.Exception e)
+            {
+                Debug.WriteLine(e);
+                DispatchCommandResult(new PluginResult(PluginResult.Status.ERROR, e.Message));
+            }
+        }
+
+        private void stopPublishing()
+        {
+            if (publishedMessageId != -1)
+            {
+                proximityDevice.StopPublishingMessage(publishedMessageId);
+                publishedMessageId = -1;
+            }
+        }
+
+        // MessageTransmittedHandler called after the message is written to a tag
+        private void nfcWriteTagCallback(ProximityDevice sender, long messageId)
+        {
+            Debug.WriteLine("Successfully wrote message to the NFC tag.");
+
+            // only write the tag one time
+            stopPublishing();
+
+            DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
+        }
+
+        private void MessageReceivedHandler(ProximityDevice sender, ProximityMessage message)
+        {
+
+            var bytes = message.Data.ToArray();
+            List<NdefRecord> records = Ndef.parse(bytes);
+
+            NfcTag tag = new NfcTag(records);
+
+           // calling a global js method to fire an nfc event
+           ScriptCallback script = new ScriptCallback("fireNfcTagEvent", new string[] { "ndef", JsonHelper.Serialize(tag) });
+           this.InvokeCustomScript(script, false);
+        }
+
+        [DataContract]
+        public class NfcTag
+        {
+            public NfcTag()
+            {
+            }
+
+            public NfcTag(List<NdefRecord> records)
+            {
+                ndefMessage = records;
+            }
+
+            [DataMember]
+            public List<NdefRecord> ndefMessage { get; set; }
+        }
+
+    }
+}

package/tests/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "com.chariotsolutions.nfc.plugin.tests",
+  "version": "0.0.1-dev",
+  "description": "Tests for phonegap-nfc",
+  "cordova": {
+    "id": "phonegap-nfc-tests",
+    "platforms": []
+  },
+  "keywords": [
+    "ecosystem:cordova"
+  ],
+  "author": "Don Coleman <don.coleman@gmail.com>",
+  "license": "MIT"
+}

package/tests/plugin.xml

@@ -0,0 +1,11 @@
+<plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+    xmlns:rim="http://www.blackberry.com/ns/widgets"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    id="phonegap-nfc-tests"
+    version="0.0.1-dev">
+    <name>PhoneGap NFC Plugin Tests</name>
+    <license>Apache 2.0</license>
+
+    <js-module src="tests.js" name="tests">
+    </js-module>
+</plugin>