public void NdefMultipleMessage() { // Arrange // Extract the data from the Mifare card dump var extract = ExtractAllBlocksFromCardDump(CardDumpExamples.Memory1KDumpMultipleEntries); // Get the NDEF section from the card dump var ndef = ExtractAllMessage(extract); // Act // Get the NDEF Message NdefMessage message = new NdefMessage(ndef); var firstRecord = message.Records.First(); var recordTestUri = message.Records[2]; var uriRecord = new UriRecord(recordTestUri); var mediaTest = message.Records[5]; var media = new MediaRecord(mediaTest); var ret = media.TryGetPayloadAsText(out string payloadAsText); var lastRecord = message.Records.Last(); // Assert // Check if all is ok Assert.Equal(10, message.Records.Count); Assert.True(firstRecord.Header.IsFirstMessage); Assert.True(UriRecord.IsUriRecord(recordTestUri)); Assert.False(MediaRecord.IsMediaRecord(recordTestUri)); Assert.Equal("bing.com/search?q=.net%20core%20iot", uriRecord.Uri); Assert.Equal(UriType.HttpsWww, uriRecord.UriType); Assert.Equal(new Uri("https://www.bing.com/search?q=.net%20core%20iot"), uriRecord.FullUri); Assert.True(MediaRecord.IsMediaRecord(mediaTest)); Assert.Equal("text/vcard", media.PayloadType); Assert.True(media.IsTextType); Assert.True(ret); Assert.Contains("VCARD", payloadAsText); Assert.True(lastRecord.Header.IsLastMessage); }
/// <summary> /// This method will be called when an NFC tag is discovered by the application, /// as long as we've enabled 'foreground dispatch' - send it to us, don't go looking /// for another program to respond to the tag. Not actually necessary for launching /// the interaction modes themselves; that'll happen even if they're in the background. /// Used here to enable the "write to tag" functionality. /// </summary> /// <param name="intent">The Intent representing the occurrence of "hey, we spotted an NFC!"</param> protected override void OnNewIntent(Intent intent) { if (_inWriteMode) { _inWriteMode = false; nfcTag = intent.GetParcelableExtra(NfcAdapter.ExtraTag) as Tag; if (nfcTag == null) { return; } var nfcID = nfcTag.tagID(); Log.Info("Main", "NFC tag ID is " + nfcID ?? "(none)"); // These next few lines will create a payload (consisting of a string) // and a mimetype. NFC records are arrays of bytes. var payload = System.Text.Encoding.ASCII.GetBytes(selectedMode.Name); var mimeBytes = System.Text.Encoding.ASCII.GetBytes(Res.AtroposMimeType); var newRecord = new NdefRecord(NdefRecord.TnfMimeMedia, mimeBytes, new byte[0], payload); var ndefMessage = new NdefMessage(new[] { newRecord }); if (!TryAndWriteToTag(nfcTag, ndefMessage)) { // Maybe the write couldn't happen because the tag wasn't formatted? TryAndFormatTagWithMessage(nfcTag, ndefMessage); } //_nfcAdapter.DisableForegroundDispatch(this); } }
public static ObservableCollection <string> readNDEFMEssage(NdefMessage message) { ObservableCollection <string> collection = new ObservableCollection <string>(); if (message == null) { return(collection); } foreach (NdefRecord record in message) { // Go through each record, check if it's a Smart Poster if (record.CheckSpecializedType(false) == typeof(NdefSpRecord)) { // Convert and extract Smart Poster info var spRecord = new NdefSpRecord(record); collection.Add("URI: " + spRecord.Uri); collection.Add("Titles: " + spRecord.TitleCount()); collection.Add("1. Title: " + spRecord.Titles[0].Text); collection.Add("Action set: " + spRecord.ActionInUse()); } if (record.CheckSpecializedType(false) == typeof(NdefUriRecord)) { // Convert and extract Smart Poster info var spRecord = new NdefUriRecord(record); collection.Add("Text: " + spRecord.Uri); } } return(collection); }
private void ButtonWriteNFC_Clicked(object sender, EventArgs e) { var spRecord = new NdefSpRecord { Uri = "www.google.at", NfcAction = NdefSpActRecord.NfcActionType.DoAction, }; spRecord.AddTitle(new NdefTextRecord { Text = "NFCForms - XamarinForms - Write-Demo", LanguageCode = "en" }); // Add record to NDEF message var msg = new NdefMessage { spRecord }; try { nfcService.WriteTag(msg); } catch (Exception excp) { DisplayAlert("Error", excp.Message, "OK"); } }
private IEnumerable <string> readNDEFMEssage(NdefMessage message) { List <string> allTagInfos = new List <string>(); if (message == null) { return(allTagInfos); } foreach (NdefRecord record in message) { // Go through each record, check if it's a Smart Poster if (record.CheckSpecializedType(false) == typeof(NdefSpRecord)) { // Convert and extract Smart Poster info var spRecord = new NdefSpRecord(record); allTagInfos.Add("URI: " + spRecord.Uri); allTagInfos.Add("Titles: " + spRecord.TitleCount()); allTagInfos.Add("1. Title: " + spRecord.Titles[0].Text); allTagInfos.Add("Action set: " + spRecord.ActionInUse()); } if (record.CheckSpecializedType(false) == typeof(NdefUriRecord)) { // Convert and extract Smart Poster info var spRecord = new NdefUriRecord(record); allTagInfos.Add("Text: " + spRecord.Uri); } } return(allTagInfos); }
/// <summary> /// Attempts to format a new tag with the message. /// </summary> /// <param name="tag"></param> /// <param name="ndefMessage"></param> /// <returns></returns> private bool TryAndFormatTagWithMessage(Tag tag, NdefMessage ndefMessage) { var format = NdefFormatable.Get(tag); if (format == null) { if (tag.GetTechList().Any((s) => s.ToLower().Contains("ndef"))) { DisplayMessage("Tag supports NDEF but is not formattable - not all of them are.\nYou might also retry the write."); } else { DisplayMessage("Tag does not appear to support NDEF format."); } } else { try { format.Connect(); format.Format(ndefMessage); DisplayMessage("Tag successfully written."); return(true); } catch (IOException ioex) { var msg = "There was an error trying to format the tag."; DisplayMessage(msg); Log.Error(Res.AtroposMimeType, ioex, msg); } } return(false); }
private void LaunchCallback(ResponseFrame frame, Exception e) { if (CheckForErrorsOrTimeout(frame, e)) { return; } byte[] data = frame.Data; byte[] temp = new byte[data.Length - data[1] - 2]; Array.Copy(data, 2 + data[1], temp, 0, temp.Length); NdefMessage message = NdefMessage.FromByteArray(temp); if (message.Count > 0) { if (Encoding.UTF8.GetString(message[0].Type).Equals("U")) { NdefUriRecord uriRecord = new NdefUriRecord(message[0]); NdefUri uri = new NdefUri(uriRecord.Uri); if (uri.Scheme == 0) { return; } Process.Start(uriRecord.Uri); } } Task.Run(() => { Thread.Sleep(500); DetectandLaunch(); }); }
private void PublishRecord(NdefRecord record, bool writeToTag) { if (_device == null) { return; } // Make sure we're not already publishing another message StopPublishingMessage(false); // Wrap the NDEF record into an NDEF message var message = new NdefMessage { record }; // Convert the NDEF message to a byte array var msgArray = message.ToByteArray(); try { // Publish the NDEF message to a tag or to another device, depending on the writeToTag parameter // Save the publication ID so that we can cancel publication later _publishingMessageId = _device.PublishBinaryMessage((writeToTag ? "NDEF:WriteTag" : "NDEF"), msgArray.AsBuffer(), MessageWrittenHandler); // Update status text for UI SetStatusOutput(string.Format(_loader.GetString(writeToTag ? "StatusWriteToTag" : "StatusWriteToDevice"), msgArray.Length, _publishingMessageId)); // Update enabled / disabled state of buttons in the User Interface UpdateUiForNfcStatusAsync(); } catch (Exception e) { SetStatusOutput(string.Format(_loader.GetString("StatusPublicationError"), e.Message)); } }
private bool?FormatNdef(Tag tag, NdefMessage ndefMsg) { NdefFormatable ndef = NdefFormatable.Get(tag); if (ndef == null) { ShowToast("Tag is not NDEF formatable."); return(false); } try { ndef.Connect(); ndef.Format(ndefMsg); } catch (Exception e) { ShowToast("Failed formating tag: " + e.Message); return(null); } finally { try { ndef.Close(); } catch (Exception) { ShowToast("Tag connection failed to close."); } } return(true); }
/// <summary> /// This method will try and write the specified message to the provided tag. /// </summary> /// <param name="tag">The NFC tag that was detected.</param> /// <param name="ndefMessage">An NDEF message to write.</param> /// <returns>true if the tag was written to.</returns> private bool TryAndSendNfc(Tag tag, NdefMessage ndefMessage) { // This object is used to get information about the NFC tag as // well as perform operations on it. var ndef = Ndef.Get(tag); if (ndef != null) { ndef.Connect(); // Once written to, a tag can be marked as read-only - check for this. if (!ndef.IsWritable) { DisplayMessage("Tag is read-only."); } // NFC tags can only store a small amount of data, this depends on the type of tag its. var size = ndefMessage.ToByteArray().Length; if (ndef.MaxSize < size) { DisplayMessage("Tag doesn't have enough space."); } ndef.WriteNdefMessage(ndefMessage); DisplayMessage("Succesfully wrote tag."); return(true); } return(false); }
void HandleClicked(object sender, EventArgs e) { var spRecord = new NdefSpRecord { Uri = "www.poz1.com", NfcAction = NdefSpActRecord.NfcActionType.DoAction, }; spRecord.AddTitle(new NdefTextRecord { Text = "NFCForms - XamarinForms - Poz1.com", LanguageCode = "en" }); // Add record to NDEF message var msg = new NdefMessage { spRecord }; try { device.WriteTag(msg); } catch (Exception excp) { DisplayAlert("Error", excp.Message, "OK"); } }
private void WriteDataToTag(Tag tag) { try { ndefHandler.SetKeys(AppSettings.Global.PubKey, AppSettings.Global.PrivKey); ndefHandler.SetExtraSignDataFromTag(tag); byte[] rawNdefMsg = ndefHandler.GenerateRawNdefMessage(writeData); NdefMessage ndefMsg = new NdefMessage(rawNdefMsg); bool?written = WriteNdef(tag, ndefMsg); if (written == false) { written = FormatNdef(tag, ndefMsg); } if (written == true) { ShowToast("Written " + ndefMsg.ByteArrayLength + " bytes of NDEF data."); Finish(); } } finally { ndefHandler.ClearKeys(); ndefHandler.ClearExtraSignData(); } }
private void NfcHandler_ReceiveNdefMessage(NdefMessage msg) { NdefHandler.SetKeys(AppSettings.PubKey); Dictionary <string, string> vals = NdefHandler.ParseNdefMessage(msg); bool?sigValid = GetSigValid(vals); if (TryHandleSettings(vals, sigValid)) { return; } if (sigValid == false) { SignalFailure(); } else { SignalSuccess(); } if (NdefHandler.HasPubKey() && sigValid != true && !AppSettings.ReportAllScans) { return; } HandleScannedTag(vals, sigValid); }
/// <summary> /// /// </summary> /// <param name="tag"></param> /// <param name="ndefMessage"></param> /// <returns></returns> private bool TryAndFormatTagWithMessage(Tag tag, NdefMessage ndefMessage) { var format = NdefFormatable.Get(tag); if (format == null) { DisplayMessage("Tag does not appear to support NDEF format."); } else { try { format.Connect(); format.Format(ndefMessage); DisplayMessage("Tag successfully written."); return(true); } catch (Java.IO.IOException ioex) { var msg = "There was an error trying to format the tag."; DisplayMessage(msg); Log.Error(this.Application.PackageName, ioex.Message, msg); } } // clear the input text _writeTextView.Text = String.Empty; return(false); }
private bool IsShopCard(byte[] buffer) { // NDEF - byte 0 should be 0x03, byte 1 should be length of remaining bytes. if (buffer.Length < 2 || buffer[0] != 0x03 || buffer[1] != buffer.Length - 2) { return(false); } try { var msg = NdefMessage.FromByteArray(buffer.Skip(2).ToArray()); if (msg.Count > 0 && msg.First().CheckSpecializedType(false) == typeof(NdefUriRecord)) { var record = new NdefUriRecord(msg.First()); return(record.Uri.StartsWith(CardUri)); } } catch (Exception ex) { Log.Error(ex); } return(false); }
private string ReadNFC(Ndef ndef) { string message; try { if (ndef == null) { throw new System.Exception("Não foi possÃvel ler o cartão."); } if (!ndef.IsConnected) { ndef.Connect(); } NdefMessage ndefMessage = ndef.NdefMessage; if (ndefMessage == null) { throw new System.Exception("Não foi possÃvel ler o cartão."); } else { message = Encoding.UTF8.GetString(ndefMessage.GetRecords()[0].GetPayload()); return(message); } } catch (Exception e) { Console.WriteLine(e.Message); throw new System.Exception("Não foi possÃvel ler o cartão."); } }
private void WriteToTagExecute() { var spRecord = new NdefSpRecord { Uri = shortenedNote, NfcAction = NdefSpActRecord.NfcActionType.DoAction }; if (SecureNoteTitle != String.Empty && SecureNoteTitle != null) { spRecord.AddTitle(new NdefTextRecord { Text = SecureNoteTitle, LanguageCode = CultureInfo.CurrentCulture.TwoLetterISOLanguageName }); } var msg = new NdefMessage { spRecord }; if (tagSize >= msg.ToByteArray().Length) { nfcService.WriteNdefMessageToTag(msg); uxService.ShowToastNotification("NFC", AppResources.NfcMessageWritten); } else { uxService.ShowToastNotification("NFC", AppResources.NfcMessageTooLong); LogMessage(AppResources.NfcMessageTooLong, NfcLogItem.WARNING_ICON); } }
internal NdefMessage[] GetNdefMessages(Intent intent) { try { IParcelable[] rawMessages = intent.GetParcelableArrayExtra(NfcAdapter.ExtraNdefMessages); if (rawMessages != null) { NdefMessage[] messages = new NdefMessage[rawMessages.Length]; for (int i = 0; i < messages.Length; i++) { messages[i] = (NdefMessage)rawMessages[i]; } return(messages); } else { return(null); } } catch (Exception e) { Log.Error(TAG, e.Message + "\n" + e.StackTrace); return(null); } }
private void PublishMessageExecute() { var spRecord = new NdefSpRecord { Uri = "http://msdn.microsoft.com/windows", NfcAction = NdefSpActRecord.NfcActionType.DoAction }; spRecord.AddTitle(new NdefTextRecord { Text = "Windows Dev Center", LanguageCode = "es" }); // Add record to NDEF message var msg = new NdefMessage { spRecord }; nfcService.PublishNdefMessage(msg); //var uri = new Uri(" http://www.nokia.com/"); ////encode uri to UTF16LE. //var buffer = Encoding.Unicode.GetBytes(uri.ToString()); //nfcService.PublishBinaryMessage("WindowsUri", buffer); //NdefUriRecord rec = new NdefUriRecord { Uri = "http://www.nokia.com/" }; //NdefMessage msg = new NdefMessage { rec }; //nfcService.PublishNdefMessage(msg); }
void HandleNewTag(object sender, NfcTag e) { var contentRead = Encoding.ASCII.GetString(e.NdefMessage[0].Payload); string serialNumber = BitConverter.ToString(e.Id); var r = new CrudApi(App.btoken); Uri restUri = new Uri(Constants.RestURLAddAttendance); string NFCContentUploaded = Guid.NewGuid().ToString(); AddAttendanceBody body = new AddAttendanceBody(serialNumber, contentRead, NFCContentUploaded); AddAttendanceResponseBody responseBody = null; try { var spRecord = new NdefTextRecord { Payload = Encoding.ASCII.GetBytes(NFCContentUploaded) }; var msg = new NdefMessage { spRecord }; device.WriteTag(msg); responseBody = Task.Run(async() => { return(await r.PostAsync <AddAttendanceBody, AddAttendanceResponseBody>(restUri, body)); }).Result; string text = responseBody.EmployeeInfo + " succesfully added attendance no." + responseBody.ID + " on point " + System.Environment.NewLine + responseBody.TagInfo; ShowSuccess(text); } catch (Exception excp) { ShowFail("An error occurred."); DependencyService.Get <IAudio>().PlayMp3File("door.mp3"); return; } Device.StartTimer(System.TimeSpan.FromSeconds(5), () => { ShowBasic(); return(true); }); return; }
public bool WriteExternalType(string pathPrefix, string payload, object tag) { if (!(tag is Tag)) { return(false); } if (string.IsNullOrEmpty(pathPrefix) || string.IsNullOrEmpty(payload)) { return(false); } WriteResult writeResult = WriteResult.FAILED; try { NdefRecord extRecord = new NdefRecord( (short)TypeNameFormat.TNF_EXTERNAL_TYPE, Encoding.UTF8.GetBytes(pathPrefix), new byte[0], Encoding.UTF8.GetBytes(payload)); NdefMessage ndefMessage = new NdefMessage(new NdefRecord[] { extRecord }); writeResult = WriteTag(ndefMessage, (Tag)tag); } catch { } return(writeResult == WriteResult.OK); }
/// <summary> /// Returns informations contains in NFC Tag /// </summary> /// <param name="tag">Android <see cref="Tag"/></param> /// <param name="ndefMessage">Android <see cref="NdefMessage"/></param> /// <returns><see cref="ITagInfo"/></returns> ITagInfo GetTagInfo(Tag tag, NdefMessage ndefMessage = null) { if (tag == null) { return(null); } var ndef = Ndef.Get(tag); if (ndef == null) { return(null); } if (ndefMessage == null) { ndefMessage = ndef.CachedNdefMessage; } var nTag = new TagInfo() { IsWritable = ndef.IsWritable }; if (ndefMessage != null) { var records = ndefMessage.GetRecords(); nTag.Records = GetRecords(records); } return(nTag); }
public bool WriteAbsoluteUri(string uri, object tag) { if (!(tag is Tag)) { return(false); } if (string.IsNullOrEmpty(uri)) { return(false); } WriteResult writeResult = WriteResult.FAILED; try { NdefRecord uriRecord = new NdefRecord( (short)TypeNameFormat.TNF_ABSOLUTE_URI, Encoding.ASCII.GetBytes(uri), new byte[0], new byte[0]); NdefMessage ndefMessage = new NdefMessage(new NdefRecord[] { uriRecord }); writeResult = WriteTag(ndefMessage, (Tag)tag); } catch { } return(writeResult == WriteResult.OK); }
private async void MessageReceivedHandler(ProximityDevice sender, ProximityMessage message) { // Get the raw NDEF message data as byte array var rawMsg = message.Data.ToArray(); // Let the NDEF library parse the NDEF message out of the raw byte array var ndefMessage = NdefMessage.FromByteArray(rawMsg); // Analysis result var tagContents = new StringBuilder(); // Parse tag contents try { // Clear bitmap if the last tag contained an image SetStatusImage(null); // Parse the contents of the tag await ParseTagContents(ndefMessage, tagContents); // Update status text for UI SetStatusOutput(string.Format(_loader.GetString("StatusTagParsed"), tagContents)); } catch (Exception ex) { SetStatusOutput(string.Format(_loader.GetString("StatusNfcParsingError"), ex.Message)); } }
/// <summary> /// /// </summary> /// <param name="tag"></param> /// <param name="ndefMessage"></param> /// <returns></returns> private bool TryAndFormatTagWithMessage(Tag tag, NdefMessage ndefMessage) { var format = NdefFormatable.Get(tag); if (format == null) { DisplayMessage("Tag does not appear to support NDEF format."); } else { try { format.Connect(); format.Format(ndefMessage); DisplayMessage("Tag successfully written."); return(true); } catch (IOException ioex) { var msg = "There was an error trying to format the tag."; DisplayMessage(msg); Log.Error(Tag, ioex, msg); } } return(false); }
private string ReadTagAsync(Tag tag) { Ndef ndef = Ndef.Get(tag); if (ndef == null) { // NDEF is not supported by this Tag. return(null); } NdefMessage ndefMessage = ndef.CachedNdefMessage; NdefRecord[] records = ndefMessage.GetRecords(); foreach (NdefRecord ndefRecord in records) { if (ndefRecord.Tnf == NdefRecord.TnfWellKnown) { try { return(ReadText(ndefRecord)); } catch (UnsupportedEncodingException ex) { Log.Error("VirtualWall", "Unsupported Encoding", ex); } } } return(null); }
/// <summary> /// This method is called when an NFC tag is discovered by the application. /// </summary> /// <param name="intent"></param> protected override void OnNewIntent(Intent intent) { if (_inWriteMode) { _inWriteMode = false; var tag = intent.GetParcelableExtra(NfcAdapter.ExtraTag) as Tag; if (tag == null) { return; } // These next few lines will create a payload (consisting of a string) // and a mimetype. NFC record are arrays of bytes. var payload = Encoding.ASCII.GetBytes(GetRandomHominid()); var mimeBytes = Encoding.ASCII.GetBytes(ViewApeMimeType); var apeRecord = new NdefRecord(NdefRecord.TnfMimeMedia, mimeBytes, new byte[0], payload); var ndefMessage = new NdefMessage(new[] { apeRecord }); if (!TryAndWriteToTag(tag, ndefMessage)) { // Maybe the write couldn't happen because the tag wasn't formatted? TryAndFormatTagWithMessage(tag, ndefMessage); } } }
protected override void OnNewIntent(Intent intent) { if (_inWriteMode) { _inWriteMode = false; var tag = intent.GetParcelableExtra(NfcAdapter.ExtraTag) as Tag; if (tag == null) { return; } // These next few lines will create a payload (consisting of a string) // and a mimetype. NFC record are arrays of bytes. var message = _inputText.Text += " " + DateTime.Now.ToString("HH:mm:ss dd/M/yyyy"); _outputText.Text = message; var payload = Encoding.ASCII.GetBytes(message); var mimeBytes = Encoding.ASCII.GetBytes(ViewIsolationType); var isolationRecord = new NdefRecord(NdefRecord.TnfMimeMedia, mimeBytes, new byte[0], payload); var ndefMessage = new NdefMessage(new[] { isolationRecord }); TryAndFormatTagWithMessage(tag, ndefMessage); if (!TryAndWriteToTag(tag, ndefMessage)) { // Maybe the write couldn't happen because the tag wasn't formatted? TryAndFormatTagWithMessage(tag, ndefMessage); } } }
/// <summary> /// Returns informations contains in NFC Tag /// </summary> /// <param name="tag">Android <see cref="Tag"/></param> /// <param name="ndefMessage">Android <see cref="NdefMessage"/></param> /// <returns><see cref="ITagInfo"/></returns> ITagInfo GetTagInfo(Tag tag, NdefMessage ndefMessage = null) { if (tag == null) { return(null); } var ndef = Ndef.Get(tag); var nTag = new TagInfo(tag.GetId(), ndef != null); if (ndef != null) { nTag.Capacity = ndef.MaxSize; nTag.IsWritable = ndef.IsWritable; if (ndefMessage == null) { ndefMessage = ndef.CachedNdefMessage; } if (ndefMessage != null) { var records = ndefMessage.GetRecords(); nTag.Records = GetRecords(records); } } return(nTag); }
private static void WriteTagFile(string pathName, string tagName, NdefMessage ndefMessage) { // NDEF message var ndefMessageBytes = ndefMessage.ToByteArray(); // Write NDEF message to binary file var binFileName = string.Format(FileNameBin, tagName); using (var fs = File.Create(Path.Combine(pathName, binFileName))) { foreach (var curByte in ndefMessageBytes) { fs.WriteByte(curByte); } } // Write NDEF message to hex file var hexFileName = string.Format(FileNameHex, tagName); using (var fs = File.Create(Path.Combine(pathName, hexFileName))) { using (var logFileWriter = new StreamWriter(fs)) { logFileWriter.Write(ConvertToHexByteString(ndefMessageBytes)); } } }
protected override void NewMessage(string tagid, NdefMessage message) { if (_result != null) { MessageReceived result = new MessageReceived(tagid,message,this); _result.TrySetResult(result); } }
public async Task<WriteResult> WriteTag(NdefMessage message, CancellationToken cancellationToken, TimeSpan timeout) { if (!IsSupported) { if (_dontThrowExpceptionWhenNotSupported) { return null; } throw new NotSupportedException("This device does not support NFC (or perhaps it's disabled)"); } Task timeoutTask = null; if (timeout != default(TimeSpan)) { timeoutTask = Task.Delay(timeout); } long subscription; TaskCompletionSource<WriteResult> resultSource = new TaskCompletionSource<WriteResult>(); //needs a message type using (cancellationToken.Register((s => ((TaskCompletionSource<WriteResult>)s).TrySetCanceled()), resultSource)) { byte[] theMessage=message.ToByteArray(); subscription = _proximityDevice.PublishBinaryMessage("NDEF:WriteTag", theMessage.AsBuffer(), (sender, id) => { WriteResult result = new WriteResult(); result.NFCTag = new NFCTag(); result.ReasonForFailure = FailureReasons.DidNotFail; resultSource.TrySetResult(result); }); try { if (timeoutTask != null) { await Task.WhenAny(timeoutTask, resultSource.Task); if (timeoutTask.IsCompleted) { throw new TimeoutException("NFC message not recieved in time"); } } if (resultSource.Task.IsCanceled) { return null; } return await resultSource.Task; } finally { _proximityDevice.StopPublishingMessage(subscription); } } }
protected override void OnNavigatedTo(NavigationEventArgs e) { var device = ProximityDevice.GetDefault(); if (device == null) return; var record = new NdefSpRecord { Uri = "cloudsdale://clouds/" + cloud.id, NfcAction = NdefSpActRecord.NfcActionType.DoAction }; record.AddTitle(new NdefTextRecord { Text = cloud.name, LanguageCode = "en" }); var message = new NdefMessage { record }; messageIds.Add(device.PublishBinaryMessage("NDEF", message.ToByteArray().AsBuffer())); }
private async void DoWriteTag() { WritingTag = true; Result = ""; NdefLibrary.Ndef.NdefMessage message = new NdefMessage(); NdefTextRecord record = new NdefTextRecord(); record.LanguageCode = "en"; record.TextEncoding = NdefTextRecord.TextEncodingType.Utf8; record.Text = Message; message.Add(record); var result = await _writeTask.WriteTag(message); if (result.DidSucceed) { Result = "Wrote Message to tag with ID " + result.NFCTag.Id; } else { switch(result.ReasonForFailure) { case FailureReasons.TagReadOnly: Result = "The tag was read only"; break; case FailureReasons.TagTooSmall: Result = "The tag was too small for this message"; break; case FailureReasons.ErrorDuringWrite: Result = "An error occured whislt trying to write the tag"; break; case FailureReasons.UnableToFormatTag: Result = "The tag was not formatted. Please format it first"; break; case FailureReasons.Unkown: Result = "An unkown error occured"; break; case FailureReasons.TagLostDuringWrite: Result = "The tag was removed whilst it was been written to"; break; default: throw new ArgumentOutOfRangeException(); } } WritingTag = false; }
static void r_NewNdefMessageDetected(NdefMessage message, int readerId) { Answer a = answers.Find(an => an.ReaderID == readerId); if (a == null) { a = new Answer(readerId); answers.Add(a); Console.WriteLine("Buzzer '{0}' initialisiert", a.Label); } var textRecord = new NdefTextRecord(message.First()); Console.WriteLine("Tag '{0}' an Buzzer '{1}'", textRecord.Text, a.Label); }
private void Device_DeviceArrived(ProximityDevice sender) { var data = new { Employee = new { Id = 2572923226000L, Name = "TestUser" } }; var payload = JsonConvert.SerializeObject(data); var spRecord = new NdefSpRecord { NfcAction = NdefSpActRecord.NfcActionType.OpenForEditing, Payload = Encoding.UTF8.GetBytes(payload), NfcSize = (uint)payload.Length, Type = Encoding.UTF8.GetBytes("application/json; charset=\"utf-8\"") }; var msg = new NdefMessage { spRecord }; long publishingId = device.PublishBinaryMessage("NDEF:WriteTag", msg.ToByteArray().AsBuffer(), (d0, id) => { device.DeviceArrived -= Device_DeviceArrived; Debug.WriteLine(" published. id = " + id); var notify = new MessageDialog("The message has been published."); }); }
static void Main(string[] args) { // Dynamically construct some more NDEF records var spRecord = new NdefSpRecord { Uri = "http://andijakl.github.io/ndef-nfc/", NfcAction = NdefSpActRecord.NfcActionType.DoAction }; spRecord.AddTitle(new NdefTextRecord { LanguageCode = "en", Text = "NFC Library" }); spRecord.AddTitle(new NdefTextRecord { LanguageCode = "de", Text = "NFC Bibliothek" }); NfcRecords.Add("SmartPoster", spRecord); // Ensure the path exists var tagsDirectory = Path.Combine(Environment.CurrentDirectory, FileDirectory); Directory.CreateDirectory(tagsDirectory); // Write tag contents to files foreach (var curNdefRecord in NfcRecords) { WriteTagFile(tagsDirectory, curNdefRecord.Key, curNdefRecord.Value); } // Multi-record file var record1 = new NdefUriRecord {Uri = "http://www.twitter.com"}; var record2 = new NdefAndroidAppRecord {PackageName = "com.twitter.android"}; var twoRecordsMsg = new NdefMessage {record1, record2}; WriteTagFile(tagsDirectory, "TwoRecords", twoRecordsMsg); var record3 = new NdefRecord { TypeNameFormat = NdefRecord.TypeNameFormatType.ExternalRtd, Type = Encoding.UTF8.GetBytes("custom.com:myapp") }; var threeRecordsMsg = new NdefMessage { record1, record3, record2 }; WriteTagFile(tagsDirectory, "ThreeRecords", threeRecordsMsg); // Success message on output Console.WriteLine("Generated {0} tag files in {1}.", NfcRecords.Count, tagsDirectory); Debug.WriteLine("Generated {0} tag files in {1}.", NfcRecords.Count, tagsDirectory); }
private ObservableCollection<string> readNDEFMEssage(NdefMessage message) { ObservableCollection<string> collection = new ObservableCollection<string>(); foreach (NdefRecord record in message) { // Go through each record, check if it's a Smart Poster if (record.CheckSpecializedType(false) == typeof(NdefSpRecord)) { // Convert and extract Smart Poster info var spRecord = new NdefSpRecord(record); collection.Add("URI: " + spRecord.Uri); collection.Add("Titles: " + spRecord.TitleCount()); collection.Add("1. Title: " + spRecord.Titles[0].Text); collection.Add("Action set: " + spRecord.ActionInUse()); } if (record.CheckSpecializedType(false) == typeof(NdefUriRecord)) { // Convert and extract Smart Poster info var spRecord = new NdefUriRecord(record); collection.Add("Text: " + spRecord.Uri); } } return collection; }
public Task<WriteResult> WriteTag(NdefMessage message) { return WriteTag(message, CancellationToken.None); }
public void SetPublishCrew(string personnel) { if (_proximity != null) { if (_subscribedMessageId != -1) { _proximity.StopSubscribingForMessage(_subscribedMessageId); _subscribedMessageId = -1; } try { //In case for Crew var record = GetPublishingMessage(typeof(NdefTextRecord), personnel.ToString()); //In case for foreman to auto login //var record = GetPublishingMessage(typeof(NdefLaunchAppRecord), "user="******"NDEF:WriteTag", msg.ToByteArray().AsBuffer(), messageTransmitted); //NotifyUser("Publishing Message: \n" + record.ToString(), NotifyType.StatusMessage); /* * This section is based on MSDN and same function with using NDEF Library. * But it was not verified */ //string launchArgs = "user="******"!" + praid; //string launchAppMessage = launchArgs + "\tWindows\t" + appName; //var dataWriter = new Windows.Storage.Streams.DataWriter(); //dataWriter.UnicodeEncoding = Windows.Storage.Streams.UnicodeEncoding.Utf16LE; //dataWriter.WriteString(launchAppMessage); //_proximity.PublishBinaryMessage("LaunchApp:WriteTag", dataWriter.DetachBuffer(), messageTransmitted); //NotifyUser("Publishing Message: \n" + launchArgs, NotifyType.StatusMessage); } catch (Exception e) { _subscribedMessageId = _proximity.SubscribeForMessage("NDEF", messageReceived); this.NotifyUser(e.Message, NotifyType.ErrorMessage); } } else this.NotifyUser("NFC Device could not be found...", NotifyType.ErrorMessage); }
private void PublishRecord(NdefRecord record, bool writeToTag) { if (_device == null) return; // Make sure we're not already publishing another message StopPublishingMessage(false); // Wrap the NDEF record into an NDEF message var message = new NdefMessage { record }; // Convert the NDEF message to a byte array var msgArray = message.ToByteArray(); // Publish the NDEF message to a tag or to another device, depending on the writeToTag parameter // Save the publication ID so that we can cancel publication later _publishingMessageId = _device.PublishBinaryMessage((writeToTag ? "NDEF:WriteTag" : "NDEF"), msgArray.AsBuffer(), MessageWrittenHandler); }
/// <summary> /// Reverse function to parseRecords() - this one takes /// the information stored in the individual record instances and assembles /// it into the payload of the base class. /// </summary> /// <remarks> /// As the URI is mandatory, the payload will not be assembled /// if no URI is defined. /// </remarks> /// <returns>Whether assembling the payload was successful.</returns> private bool AssemblePayload() { // Uri is mandatory - don't assemble the payload if it's not set if (RecordUri == null) return false; // URI (mandatory) var message = new NdefMessage { RecordUri }; // Title(s) (optional) if (Titles != null && Titles.Count > 0) message.AddRange(Titles); // Action (optional) if (ActionInUse()) message.Add(_recordAction); // Size (optional) if (SizeInUse()) message.Add(_recordSize); // Mime Type (optional) if (MimeTypeInUse()) message.Add(_recordMimeType); // Image (optional) if (ImageInUse()) message.Add(_recordImage); SetPayloadAndParse(message.ToByteArray(), false); return true; }
private void PublishRecord(NdefRecord record, bool writeToTag) { if (_device == null) return; // Make sure we're not already publishing another message StopPublishingMessage(false); // Wrap the NDEF record into an NDEF message var message = new NdefMessage { record }; // Convert the NDEF message to a byte array var msgArray = message.ToByteArray(); // Publish the NDEF message to a tag or to another device, depending on the writeToTag parameter // Save the publication ID so that we can cancel publication later _publishingMessageId = _device.PublishBinaryMessage((writeToTag ? "NDEF:WriteTag" : "NDEF"), msgArray.AsBuffer(), MessageWrittenHandler); // Update status text for UI SetStatusOutput(string.Format((writeToTag ? AppResources.StatusWriteToTag : AppResources.StatusWriteToDevice), msgArray.Length, _publishingMessageId)); // Update enabled / disabled state of buttons in the User Interface SetStatusOutput(string.Format("You said \"{0}\"\nPlease touch a tag to write the message.", recordresult)); recordresult = ""; UpdateUiForNfcStatus(); }
private async Task ParseTagContents(NdefMessage ndefMessage, StringBuilder tagContents) { // Loop over all records contained in the NDEF message foreach (NdefRecord record in ndefMessage) { // -------------------------------------------------------------------------- // Print generic information about the record if (record.Id != null && record.Id.Length > 0) { // Record ID (if present) tagContents.AppendFormat("Id: {0}\n", Encoding.UTF8.GetString(record.Id, 0, record.Id.Length)); } // Record type name, as human readable string tagContents.AppendFormat("Type name: {0}\n", ConvertTypeNameFormatToString(record.TypeNameFormat)); // Record type if (record.Type != null && record.Type.Length > 0) { tagContents.AppendFormat("Record type: {0}\n", Encoding.UTF8.GetString(record.Type, 0, record.Type.Length)); } // -------------------------------------------------------------------------- // Check the type of each record // Using 'true' as parameter for CheckSpecializedType() also checks for sub-types of records, // e.g., it will return the SMS record type if a URI record starts with "sms:" // If using 'false', a URI record will always be returned as Uri record and its contents won't be further analyzed // Currently recognized sub-types are: SMS, Mailto, Tel, Nokia Accessories, NearSpeak, WpSettings var specializedType = record.CheckSpecializedType(true); if (specializedType == typeof(NdefMailtoRecord)) { // -------------------------------------------------------------------------- // Convert and extract Mailto record info var mailtoRecord = new NdefMailtoRecord(record); tagContents.Append("-> Mailto record\n"); tagContents.AppendFormat("Address: {0}\n", mailtoRecord.Address); tagContents.AppendFormat("Subject: {0}\n", mailtoRecord.Subject); tagContents.AppendFormat("Body: {0}\n", mailtoRecord.Body); } else if (specializedType == typeof(NdefUriRecord)) { // -------------------------------------------------------------------------- // Convert and extract URI record info var uriRecord = new NdefUriRecord(record); tagContents.Append("-> URI record\n"); tagContents.AppendFormat("URI: {0}\n", uriRecord.Uri); } else if (specializedType == typeof(NdefSpRecord)) { // -------------------------------------------------------------------------- // Convert and extract Smart Poster info var spRecord = new NdefSpRecord(record); tagContents.Append("-> Smart Poster record\n"); tagContents.AppendFormat("URI: {0}", spRecord.Uri); tagContents.AppendFormat("Titles: {0}", spRecord.TitleCount()); if (spRecord.TitleCount() > 1) tagContents.AppendFormat("1. Title: {0}", spRecord.Titles[0].Text); tagContents.AppendFormat("Action set: {0}", spRecord.ActionInUse()); // You can also check the action (if in use by the record), // mime type and size of the linked content. } //else if (specializedType == typeof(NdefVcardRecordBase)) //{ // // -------------------------------------------------------------------------- // // Convert and extract business card info // var vcardRecord = new NdefVcardRecord(record); // tagContents.Append("-> Business Card record" + Environment.NewLine); // var contact = vcardRecord.ContactData; // // Contact has phone or email info set? Use contact manager to show the contact card // await _dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => // { // if (contact.Emails.Any() || contact.Phones.Any()) // { // var rect = GetElementRect(StatusOutput); // ContactManager.ShowContactCard(contact, rect, Placement.Below); // } // else // { // // No phone or email set - contact manager would not show the contact card. // // -> parse manually // tagContents.AppendFormat("Name: {0}\n", contact.DisplayName); // tagContents.Append("[not parsing other values in the demo app]"); // } // }); //} //else if (specializedType == typeof(NdefIcalendarRecordBase)) //{ // // -------------------------------------------------------------------------- // // Convert and extract iCalendar info // var icalendarRecord = new NdefIcalendarRecord(record); // tagContents.Append("-> iCalendar record" + Environment.NewLine); // var ap = icalendarRecord.AppointmentData; // if (!String.IsNullOrEmpty(ap.Subject)) // tagContents.AppendFormat("Subject: {0}\n", ap.Subject); // if (!String.IsNullOrEmpty(ap.Details)) // tagContents.AppendFormat("Details: {0}\n", ap.Details); // if (!String.IsNullOrEmpty(ap.Organizer.Address)) // tagContents.AppendFormat("Organizer Address: {0}\n", ap.Organizer.Address); // if (!String.IsNullOrEmpty(ap.Location)) // tagContents.AppendFormat("Location: {0}\n", ap.Location); // tagContents.AppendFormat("Start time: {0}\n", ap.StartTime); // tagContents.AppendFormat("Duration: {0}\n", ap.Duration); // tagContents.AppendFormat("AllDay? {0}\n", ap.AllDay ? "yes" : "no"); // if (ap.Reminder != null) // tagContents.AppendFormat("Reminder: {0}\n", ap.Reminder); //} else if (specializedType == typeof(NdefLaunchAppRecord)) { // -------------------------------------------------------------------------- // Convert and extract LaunchApp record info var launchAppRecord = new NdefLaunchAppRecord(record); tagContents.Append("-> LaunchApp record" + Environment.NewLine); if (!string.IsNullOrEmpty(launchAppRecord.Arguments)) tagContents.AppendFormat("Arguments: {0}\n", launchAppRecord.Arguments); if (launchAppRecord.PlatformIds != null) { foreach (var platformIdTuple in launchAppRecord.PlatformIds) { if (platformIdTuple.Key != null) tagContents.AppendFormat("Platform: {0}\n", platformIdTuple.Key); if (platformIdTuple.Value != null) tagContents.AppendFormat("App ID: {0}\n", platformIdTuple.Value); } } } //else if (specializedType == typeof(NdefMimeImageRecordBase)) //{ // // -------------------------------------------------------------------------- // // Convert and extract Image record info // var imgRecord = new NdefMimeImageRecord(record); // tagContents.Append("-> MIME / Image record" + Environment.NewLine); // _dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () => SetStatusImage(await imgRecord.GetImageAsBitmap())); //} else { // Other type, not handled by this demo tagContents.Append("NDEF record not parsed by this demo app" + Environment.NewLine); } } }
void HandleClicked(object sender, EventArgs e) { var spRecord = new NdefSpRecord { NfcAction = NdefSpActRecord.NfcActionType.DoAction, }; spRecord.AddTitle(new NdefTextRecord { Text = "00001:5.49" }); // Add record to NDEF message var msg = new NdefMessage { spRecord }; try { device.WriteTag(msg); } catch (Exception excp) { DisplayAlert("Error", excp.Message, "OK"); } }
private static void WriteTagFile(string pathName, string tagName, NdefMessage ndefMessage) { // NDEF message var ndefMessageBytes = ndefMessage.ToByteArray(); // Write NDEF message to binary file var binFileName = String.Format(FileNameBin, tagName); using (var fs = File.Create(Path.Combine(pathName, binFileName))) { foreach (var curByte in ndefMessageBytes) { fs.WriteByte(curByte); } } // Write NDEF message to hex file var hexFileName = String.Format(FileNameHex, tagName); using (var fs = File.Create(Path.Combine(pathName, hexFileName))) { using (var logFileWriter = new StreamWriter(fs)) { logFileWriter.Write(ConvertToHexByteString(ndefMessageBytes)); } } }
// private Windows.UI.Core.CoreDispatcher _dispatcher = //Windows.UI.Core.CoreWindow.GetForCurrentThread().Dispatcher; // private async void ProximityDeviceArrived(object sender) // { // await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, // () => // { // StatusOutput.Text += "Proximate device arrived.\n"; // }); // } // private async void ProximityDeviceDeparted(object sender) // { // await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, // () => // { // StatusOutput.Text += "Proximate device departed.\n"; // }); // } private void PublishRecord(NdefRecord record, bool writeToTag) { if (_device == null) return; // Make sure we're not already publishing another message StopPublishingMessage(false); // Wrap the NDEF record into an NDEF message var message = new NdefMessage { record }; // Convert the NDEF message to a byte array var msgArray = message.ToByteArray(); // Publish the NDEF message to a tag or to another device, depending on the writeToTag parameter // Save the publication ID so that we can cancel publication later _publishingMessageId = _device.PublishBinaryMessage((writeToTag ? "NDEF:WriteTag" : "NDEF"), msgArray.AsBuffer(), MessageWrittenHandler); // Update status text for UI //_publishingMessageId = -1; SetStatusOutput(string.Format((writeToTag ? AppResources.StatusWriteToTag : AppResources.StatusWriteToDevice), msgArray.Length, _publishingMessageId)); }
public string Write() { Log.Debug("Card write"); try { using (var reader = new IsoReader(CardContext, GetReader(), SCardShareMode.Shared, SCardProtocol.Any, false)) { var status = GetReaderStatus(reader); Log.Debug(String.Format("Card State: {0}", status.CardState)); if (!status.CardState.HasFlag(SCardState.Present)) return null; var id = GetCardId(reader); var cardName = GetCardName(status.Atr); var cardType = GetInt16(cardName); var isMifare = cardType == CardReader.Mifare1KCard || cardType == CardReader.Mifare4KCard; var isMifareUltralight = cardType == CardReader.MifareUltralightCard; Log.Debug(String.Format("Card Id: {0}", BitConverter.ToString(id))); var cardString = BitConverter.ToString(cardName.Concat(id).ToArray()).Replace("-", ""); if (isMifareUltralight) { var msg = new NdefMessage { new NdefUriRecord { Uri = CardReader.CardUri + "/#/" + cardString } }; var data = msg.ToByteArray(); var buffer = new List<byte>(new byte[] { 0x03, (byte)data.Length }.Concat(data)); WriteAllCardBytes(reader, buffer.ToArray(), isMifareUltralight ? 4 : 16); } return BitConverter.ToString(cardName.Concat(id).ToArray()).Replace("-", ""); } } catch (Exception ex) { Log.Error(ex); } return null; }
/// <summary> /// Create the payload based on the data stored in the properties. Usually called /// automatically when changing properties, but you might need to call this manually /// if you modify the list of alternative carrier records directly without using /// accessor method provided by this class. /// </summary> /// <exception cref="NdefException">Thrown if unable to assemble the payload. /// The exception message contains further details about the issue.</exception> public void AssemblePayload() { if (_handoverVersion == null) { throw new NdefException(NdefExceptionMessages.ExHandoverInvalidVersion); } // Convert child records to message var childMsg = new NdefMessage(); if (_handoverAlternativeCarrierRecords != null) childMsg.AddRange(_handoverAlternativeCarrierRecords); if (_handoverErrorRecord != null) childMsg.Add(_handoverErrorRecord); var childBytes = childMsg.ToByteArray(); var newPayload = new byte[childBytes.Length + 1]; // Frist byte: handover version newPayload[0] = _handoverVersion.Version; // Rest of the payload: child message containing Alternative Carrier records + Error record Array.Copy(childBytes, 0, newPayload, 1, childBytes.Length); _payload = newPayload; }
private void PublishRecord(NdefRecord record, bool writeToTag) { if (_device == null) return; // Make sure we're not already publishing another message StopPublishingMessage(false); // Wrap the NDEF record into an NDEF message var message = new NdefMessage { record }; // Convert the NDEF message to a byte array var msgArray = message.ToByteArray(); try { // Publish the NDEF message to a tag or to another device, depending on the writeToTag parameter // Save the publication ID so that we can cancel publication later _publishingMessageId = _device.PublishBinaryMessage((writeToTag ? "NDEF:WriteTag" : "NDEF"), msgArray.AsBuffer(), MessageWrittenHandler); // Update status text for UI SetStatusOutput(string.Format(_loader.GetString(writeToTag ? "StatusWriteToTag" : "StatusWriteToDevice"), msgArray.Length, _publishingMessageId)); // Update enabled / disabled state of buttons in the User Interface UpdateUiForNfcStatusAsync(); } catch (Exception e) { SetStatusOutput(string.Format(_loader.GetString("StatusPublicationError"), e.Message)); } }
protected DokanError WritePayload(byte[] payload, string extension) { // Make sure the chip is still here if (!rfidListener.ReconnectOnCard()) { log.Error("Card reconnection failed"); return DokanError.ErrorNotReady; } IChip chip = rfidListener.GetChip(); ICardService svc = chip.GetService(CardServiceType.CST_NFC_TAG); IDESFireEV1NFCTag4CardService nfcsvc = svc as IDESFireEV1NFCTag4CardService; if (nfcsvc == null) { log.Error("No NFC service."); // If no NFC service for this chip, we must fail return DokanError.ErrorNotReady; } try { IStorageCardService storage = chip.GetService(CardServiceType.CST_STORAGE) as IStorageCardService; if (storage != null) { storage.Erase(); } nfcsvc.CreateNFCApplication(1, null); NdefMessage ndef = new NdefMessage(); switch (extension) { case "txt": log.Info("Adding Text Record"); ndef.AddRawTextRecord(payload); break; case "url": string lnk = Encoding.UTF8.GetString(payload); int urlpos = lnk.IndexOf("URL="); if (urlpos > -1) { urlpos += 4; int end = lnk.IndexOf(Environment.NewLine, urlpos); if (end < 0) { end = lnk.Length - urlpos; } else { end -= urlpos; } string url = lnk.Substring(urlpos, end).Trim(); log.Info(String.Format("Adding Uri Record `{0}`", url)); ndef.AddUriRecord(url, UriType.NO_PREFIX); } else { log.Warn("Cannot found URL on link file content."); } break; default: string mime = System.Web.MimeMapping.GetMimeMapping("dummy." + extension); log.Info(String.Format("Adding Mime Record `{0}`", mime)); ndef.AddMimeMediaRecord(mime, Encoding.ASCII.GetString(payload)); // This shouldn't be a string here break; } nfcsvc.WriteNDEFFile(ndef); ResetCache(); } catch (COMException ex) { log.Info("NDEF write error", ex); } return DokanError.ErrorSuccess; }