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));
}
}
public async Task <NdefMessage> ReadNdefAsync()
{
Android.Nfc.Tech.Ndef ndef = null;
try
{
await _lockSemaphore.WaitAsync();
if (!_isNfcEnabled)
{
throw new Exception("NFC is not enabled");
}
ndef = Android.Nfc.Tech.Ndef.Get(_tag);
ndef.Connect();
var ndefMessage = NdefMessage.FromByteArray(ndef.NdefMessage.ToByteArray());
ndef.Close();
return(ndefMessage);
}
catch (Exception ex)
{
if (ndef.IsConnected)
{
ndef.Close();
}
throw ex;
}
finally
{
_lockSemaphore.Release();
}
}
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 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 void messagedReceived(ProximityDevice device, ProximityMessage m)
{
uint x = m.Data.Length;
byte[] b = new byte[x];
b = m.Data.ToArray();
PlaySound();
// string s = Encoding.UTF8.GetString(b, 0, b.Length);
// Debug.WriteLine(s);
NdefMessage ndefMessage = NdefMessage.FromByteArray(b);
foreach (NdefRecord record in ndefMessage)
{
WriteMessageText("\n----------------------------");
WriteMessageText("\nType: " + Encoding.UTF8.GetString(record.Type, 0, record.Type.Length));
if (record.CheckSpecializedType(false) == typeof(NdefUriRecord))
{
var uriRecord = new NdefUriRecord(record);
WriteMessageText("\nURI: " + uriRecord.Uri);
}
;
}
WriteMessageText("\n----------------------------\n");
}
private void InvokeKeyboardFeature(ResponseFrame frame, Exception e)
{
if (CheckForErrorsOrTimeout(frame, e))
{
return;
}
else
{
byte[] data = frame.Data;
byte[] temp = new byte[data.Length - data[1] - 2];
if (temp.Length > 0)
{
Array.Copy(data, 2 + data[1], temp, 0, temp.Length);
NdefMessage message = NdefMessage.FromByteArray(temp);
int numRecords = message.Count;
int recordNum = 1;
Action EnterKeystrokes = () =>
{
foreach (NdefRecord record in message)
{
string type = Encoding.UTF8.GetString(record.Type);
if (type.Equals("T"))
{
NdefTextRecord textRecord = new NdefTextRecord(record);
System.Windows.Forms.SendKeys.SendWait(textRecord.Text);
if (keyboardModeLineBreak)
{
System.Windows.Forms.SendKeys.SendWait("{ENTER}");
}
if (keyboardModeTab)
{
System.Windows.Forms.SendKeys.SendWait("{TAB}");
}
if (keyboardModeTabLineBreakLast)
{
if (recordNum == numRecords)
{
System.Windows.Forms.SendKeys.SendWait("{ENTER}");
}
else
{
System.Windows.Forms.SendKeys.SendWait("{TAB}");
}
}
recordNum++;
}
}
};
Dispatcher.BeginInvoke(EnterKeystrokes);
}
}
}
private void btnReadAll_Click(object sender, EventArgs e)
{
if (!connActive)
{
return;
}
string tmpStr = string.Empty;
int startBlock = 4, endBlock = 0, dataLength = 0, dataAllLength;
int dataPageIndex = 0;
byte[] recvData = new byte[6];
recvData = ReadDataFromCard(startBlock, 4);
dataLength = recvData[1];
dataAllLength = dataLength + 3;
if (dataLength > 0)
{
byte[] effectiveData = new byte[dataLength];
effectiveData[0] = recvData[2];
effectiveData[1] = recvData[3];
endBlock = dataAllLength % 4 == 0 ? dataAllLength / 4 + startBlock : dataAllLength / 4 + startBlock + 1;
for (int iBlock = startBlock + 1; iBlock < endBlock; iBlock++)
{
recvData = ReadDataFromCard(iBlock, 4);
for (int iBit = 0; iBit < 4; iBit++)
{
if ((dataPageIndex * 4 + iBit + 2) < effectiveData.Length)
{
effectiveData[dataPageIndex * 4 + iBit + 2] = recvData[iBit];
}
}
dataPageIndex++;
}
try
{
NdefMessage message = NdefMessage.FromByteArray(effectiveData);
NdefRecord record = message[0];
if (record.CheckSpecializedType(false) == typeof(NdefTextRecord))
{
//Convert and extract Smart Poster info
var textRecord = new NdefTextRecord(record);
WriteLog(3, 0, textRecord.Text);
}
}
catch
{
}
}
}
private void OnMessageReceived(ProximityDevice sender, ProximityMessage message)
{
var stopwatch = (Stopwatch)null;
if (Debug)
{
stopwatch = new Stopwatch();
stopwatch.Start();
}
var rawMessage = message.Data.ToArray();
NdefMessage ndefMessage;
try
{
ndefMessage = NdefMessage.FromByteArray(rawMessage);
}
catch (NdefException e)
{
var exceptionArgs = new DeviceStatusChangedEventArgs()
{
DeviceStatus = StatusEnum.DeviceArrived
};
if (Debug)
{
stopwatch.Stop();
exceptionArgs.ExecutionTime = stopwatch.Elapsed;
}
OnDeviceStatusChanged(this, exceptionArgs);
return;
}
var args = new MessageArrivedEventArgs()
{
DeviceStatus = StatusEnum.MessageReceived
};
foreach (NdefRecord record in ndefMessage)
{
if (NdefTextRecord.IsRecordType(record))
{
NdefTextRecord textRecord = new NdefTextRecord(record);
args.Message = textRecord.Text;
break;
}
}
if (Debug)
{
stopwatch.Stop();
args.ExecutionTime = stopwatch.Elapsed;
args.MethodName = "TagReader.OnMessageReceived";
}
OnDeviceStatusChanged(this, args);
OnMessageArrived(this, args);
}
private void ReadCard(ProximityDevice sender, ProximityMessage message)
{
var rawMsg = message.Data.ToArray();
var ndefMessage = NdefMessage.FromByteArray(rawMsg);
// Loop over all records contained in the NDEF message
foreach (NdefRecord record in ndefMessage)
{
// here we loop through the record....
}
}
private void OnNewIntentReceived(object sender, Intent e)
{
if (e.Action == Android.Nfc.NfcAdapter.ActionNdefDiscovered)
{
_tag = e.GetParcelableExtra(Android.Nfc.NfcAdapter.ExtraTag) as Android.Nfc.Tag;
var ndefMessage = NdefMessage.FromByteArray(Android.Nfc.Tech.Ndef.Get(_tag).CachedNdefMessage
.ToByteArray());
TagDetected?.Invoke(this, new NfcTagDetectedEventArgs(
BitConverter.ToString(_tag.GetId()).Replace("-", ":"),
ndefMessage));
}
}
private string getURIFromNdef(byte[] data)
{
var message = NdefMessage.FromByteArray(data);
foreach (NdefRecord record in message)
{
if (record.CheckSpecializedType(false) == typeof(NdefUriRecord))
{
var uri = new NdefUriRecord(record);
return(uri.Uri);
}
}
return(null);
}
public Dictionary <string, string> ParseNdefMessage(byte[] raw)
{
NdefMessage ndefMessage;
try
{
ndefMessage = NdefMessage.FromByteArray(raw);
}
catch (NdefException e)
{
throw new NdefHandlerException("Error parsing ndef: " + e.Message, e);
}
return(ParseNdefMessage(ndefMessage));
}
private async void messageReceivedHandler(ProximityDevice device, ProximityMessage message)
{
var rawMsg = message.Data.ToArray();
var ndefMessage = NdefMessage.FromByteArray(rawMsg);
foreach (NdefRecord record in ndefMessage)
{
if (record.CheckSpecializedType(false) == typeof(NdefTextRecord))
{
var spRecord = new NdefTextRecord(record);
var receivedOTP = spRecord.Text.Replace("YubiCryptOTP=", string.Empty);
await FillOTPCodeInput(receivedOTP);
}
}
}
private void MessageReceivedHandler(ProximityDevice device, ProximityMessage message)
{
nfcTag.IsNdefSupported = true;
nfcTag.Id = new byte[0];
nfcTag.TechList = new System.Collections.ObjectModel.ObservableCollection <string>();
var rawMsg = message.Data.ToArray();
nfcTag.NdefMessage = NdefMessage.FromByteArray(rawMsg);
if (message.MessageType == "WriteableTag")
{
nfcDevice.SubscribeForMessage("WriteableTag", WriteableTagHandler);
}
else
{
RaiseNewTag(nfcTag);
}
}
public static string getNdefFromByteArray(byte[] readData)
{
//Create Ndef message
string phone = String.Empty;
NdefMessage message = NdefMessage.FromByteArray(readData);
//Loop through the records
foreach (NdefRecord record in message)
{
if (record.CheckSpecializedType(false) == typeof(NdefTextRecord))
{
var textRecord = new NdefTextRecord(record);
phone = textRecord.Text;
}
}
return(phone);
}
// ------------------------------------------
// PRIVATE READER
// ------------------------------------------
private void MessageReceivedHandler(ProximityDevice sender, ProximityMessage message)
{
// Parse raw byte array to NDEF message
var rawMsg = message.Data.ToArray();
var ndefMessage = NdefMessage.FromByteArray(rawMsg);
// Loop over all records contained in the NDEF message
foreach (NdefRecord record in ndefMessage)
{
Console.WriteLine("Record type: " + Encoding.UTF8.GetString(record.Type, 0, record.Type.Length));
// Check the type of each record - handling a Smart Poster in this example
var specializedType = record.CheckSpecializedType(true);
// Convert and extract Smart Poster info
if (specializedType == typeof(NdefSpRecord))
{
var spRecord = new NdefSpRecord(record);
String msg = "URI: " + spRecord.Uri + "\n"
+ "Titles: " + spRecord.TitleCount() + "\n"
+ "1. Title: " + spRecord.Titles[0].Text + "\n"
+ "Action set: " + spRecord.ActionInUse();
NFCManager.getInstance().Alert(msg);
}
// Convert and extract URI record info
else if (specializedType == typeof(NdefUriRecord))
{
var uriRecord = new NdefUriRecord(record);
String msg = "URI: " + uriRecord.Uri + "\n";
NFCManager.getInstance().Alert(msg);
NFCManager.getInstance().SendRequest(uriRecord.Uri);
}
// Convert and extract Mailto record info
else if (specializedType == typeof(NdefMailtoRecord))
{
var mailtoRecord = new NdefMailtoRecord(record);
String msg = "Address: " + mailtoRecord.Address + "\n"
+ "Subject: " + mailtoRecord.Subject + "\n"
+ "Body: " + mailtoRecord.Body;
NFCManager.getInstance().Alert(msg);
}
}
}
private void MessageReceivedHandler(ProximityDevice sender, ProximityMessage message)
{
SetStatusOutput("Found proximity card");
// Convert to NdefMessage from NDEF / NFC Library
var msgArray = message.Data.ToArray();
NdefMessage ndefMessage = NdefMessage.FromByteArray(msgArray);
// Loop over all records contained in the message
foreach (NdefRecord record in ndefMessage)
{
// Check the type of each record
if (record.CheckSpecializedType(false) == typeof(NdefUriRecord))
{
// Convert and extract URI info
var uriRecord = new NdefUriRecord(record);
SetStatusOutput("NDEF URI: " + uriRecord.Uri);
}
}
}
// We have received a new NFC message, for now just see what it is.
// TODO: send it to BLE device
private void messagedReceived(ProximityDevice device, ProximityMessage m)
{
uint x = m.Data.Length;
byte[] b = new byte[x];
b = m.Data.ToArray();
NdefMessage ndefMessage = NdefMessage.FromByteArray(b);
foreach (NdefRecord record in ndefMessage)
{
if (record.CheckSpecializedType(false) == typeof(NdefTextRecord))
{
var textRecord = new NdefTextRecord(record);
Debug.WriteLine("\nTEXT: " + textRecord.Text);
NFCText = textRecord.Text;
bNFCText = true;
}
}
}
//-------------------------------------------------------------------------odczytaj wiadomosc NDEF
private void ReadMsg(ProximityDevice sender, ProximityMessage msg)
{
var rawMsg = msg.Data.ToArray();
var ndefMessage = NdefMessage.FromByteArray(rawMsg);
if (ndefMessage[0].CheckSpecializedType(false) == typeof(NdefTextRecord))
{
var firstRecord = new NdefTextRecord(ndefMessage[0]);
if (firstRecord.Text.Equals("no8g-Sj5i-i8aw6"))
{
List <String> connectionData = new List <String>();
var secondRecord = new NdefTextRecord(ndefMessage[1]);
var thirdRecord = new NdefTextRecord(ndefMessage[2]);
var fourthRecord = new NdefTextRecord(ndefMessage[3]);
connectionData.Add(secondRecord.Text);
connectionData.Add(thirdRecord.Text);
connectionData.Add(fourthRecord.Text);
Receiving(connectionData);
}
}
}
public static void MessageReceivedHandler(byte[] rawMsg)
{
// Parse raw byte array to NDEF message
//var rawMsg = message.ToArray();
var ndefMessage = NdefMessage.FromByteArray(rawMsg);
// Loop over all records contained in the NDEF message
foreach (NdefRecord record in ndefMessage)
{
Debug.WriteLine("Record type: " + Encoding.UTF8.GetString(record.Type, 0, record.Type.Length));
// 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);
Debug.WriteLine("URI: " + spRecord.Uri);
Debug.WriteLine("Titles: " + spRecord.TitleCount());
Debug.WriteLine("1. Title: " + spRecord.Titles[0].Text);
Debug.WriteLine("Action set: " + spRecord.ActionInUse());
}
}
}
private void AddNdefContent(ResponseFrame frame, Exception e)
{
if (CheckForErrorsOrTimeout(frame, e))
{
return;
}
byte[] data = frame.Data;
byte[] temp = new byte[data.Length - data[1] - 2];
if (temp.Length > 0)
{
Array.Copy(data, 2 + data[1], temp, 0, temp.Length);
NdefMessage message = NdefMessage.FromByteArray(temp);
Action update = () =>
{
foreach (NdefRecord record in message)
{
ndefData.AppendText("Ndef Record:\n\n");
if (record.TypeNameFormat == NdefRecord.TypeNameFormatType.Empty)
{
ndefData.AppendText("Empty NDEF Record");
}
else
{
string type = Encoding.UTF8.GetString(record.Type);
ndefData.AppendText($"TNF: {record.TypeNameFormat.ToString()} ({(byte)record.TypeNameFormat})\n");
ndefData.AppendText($"Type: {type}\n");
if (record.Id != null)
{
ndefData.AppendText($"Type: {BitConverter.ToString(record.Id)}\n");
}
if (type.Equals("U"))
{
NdefUriRecord uriRecord = new NdefUriRecord(record);
ndefData.AppendText($"Payload: {uriRecord.Uri}\n");
}
else if (type.Equals("T"))
{
NdefTextRecord textRecord = new NdefTextRecord(record);
ndefData.AppendText($"Encoding: {textRecord.TextEncoding.ToString()}\n");
ndefData.AppendText($"Language: {textRecord.LanguageCode}\n");
ndefData.AppendText($"Payload: {textRecord.Text}\n");
}
else if (type.Contains("text"))
{
ndefData.AppendText($"Payload: {Encoding.UTF8.GetString(record.Payload)}\n");
}
else
{
ndefData.AppendText($"Payload: {BitConverter.ToString(record.Payload)}");
}
ndefData.AppendText($"----------\n");
}
}
};
Dispatcher.BeginInvoke(update);
}
ShowSuccessStatus();
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">Event data that describes how this page was reached. The Parameter
/// property is typically used to configure the page.</param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
LuaForm.navService = this;
LuaForm.activeForm = this;
if (FirstInit)
{
FirstInit = false;
}
else if (!mainPage)
{
LuaInternalParameter lip = (LuaInternalParameter)e.Parameter;
luaId = lip["luaId"];
String initUI = lip["ui"];
if (initUI != "")
{
LuaViewInflator inflater = new LuaViewInflator(luaContext);
this.view = inflater.ParseFile(initUI, null);
Content = view.GetView();
}
else
{
LuaEngine.Instance.OnGuiEvent(this, LuaEngine.GuiEvents.GUI_EVENT_CREATE, luaContext);
}
}
#if WP8
proximityDevice = ProximityDevice.GetDefault();
if (proximityDevice != null)
{
nfcSubsId = proximityDevice.SubscribeForMessage("NDEF", (device, message) =>
{
Logger.Log(LogType.CONSOLE, LogLevel.ERROR, "**** Subs Ndef ****");
// Parse raw byte array to NDEF message
byte[] rawMsg = message.Data.ToArray();
NdefMessage ndefMessage = NdefMessage.FromByteArray(rawMsg);
Dictionary <Int32, Dictionary <String, String> > nfcData = new Dictionary <Int32, Dictionary <String, String> >();
int count = 0;
foreach (NdefRecord record in ndefMessage)
{
Dictionary <String, String> recordDict = new Dictionary <String, String>();
Type recordType = record.CheckSpecializedType(false);
if (recordType == typeof(NdefUriRecord))
{
NdefUriRecord uriRecord = new NdefUriRecord(record);
recordDict.Add("type", "uri");
recordDict.Add("uri", uriRecord.Uri);
nfcData.Add(count++, recordDict);
}
else if (recordType == typeof(NdefSmartUriRecord))
{
NdefSmartUriRecord sUriRecord = new NdefSmartUriRecord(record);
recordDict.Add("type", "spr");
recordDict.Add("title", sUriRecord.Titles[0].Text);
recordDict.Add("uri", sUriRecord.Uri);
}
}
LuaEngine.Instance.OnGuiEvent(this, LuaEngine.GuiEvents.GUI_EVENT_NFC, luaContext, nfcData);
});
}
#endif
LuaEngine.Instance.OnGuiEvent(this, LuaEngine.GuiEvents.GUI_EVENT_RESUME, luaContext);
}
public NdefMessage NDEFRead()
{
return(NdefMessage.FromByteArray(ReadAll()));
}
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();
// 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(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(NdefVcardRecordBase))
{
// --------------------------------------------------------------------------
// Convert and extract business card info
var vcardRecord = await NdefVcardRecord.CreateFromGenericBaseRecord(record);
tagContents.Append("-> Business Card record" + Environment.NewLine);
tagContents.AppendFormat("vCard Version: {0}" + Environment.NewLine,
vcardRecord.VCardFormatToWrite == VCardFormat.Version2_1 ? "2.1" : "3.0");
var contact = vcardRecord.ContactData;
var contactInfo = await contact.GetPropertiesAsync();
foreach (var curProperty in contactInfo.OrderBy(i => i.Key))
{
tagContents.Append(String.Format("{0}: {1}" + Environment.NewLine, curProperty.Key, curProperty.Value));
}
}
else
{
// Other type, not handled by this demo
tagContents.Append("NDEF record not parsed by this demo app" + Environment.NewLine);
}
}
// Update status text for UI
SetStatusOutput(string.Format(AppResources.StatusTagParsed, tagContents));
}
private void ParseTLVData(byte[] data)
{
using (MemoryStream stream = new MemoryStream(data))
using (BinaryReader reader = new BinaryReader(stream))
{
while (stream.Position < stream.Length)
{
byte tag = reader.ReadByte();
int length = 0;
byte[] val = null;
if (tag != 0x00 && tag != 0xFE)
{
length = reader.ReadByte();
if (length >= 0xFF)
{
byte[] lengthBytes = reader.ReadBytes(2);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(lengthBytes);
}
length = BitConverter.ToUInt16(lengthBytes, 0);
}
val = length > 0 ? reader.ReadBytes(length) : null;
}
switch (tag)
{
case 0x00:
StatusMessage?.Invoke("Skipping NULL TLV");
break;
case 0x01:
StatusMessage?.Invoke("Skipping Lock Control TLV");
break;
case 0x02:
StatusMessage?.Invoke("Skipping Memory Control TLV");
break;
case 0xFE:
StatusMessage?.Invoke("Reached terminator TLV");
return;
case 0x03:
if (val != null)
{
StatusMessage?.Invoke("Found NDEF TLV (" + length + " bytes)");
NdefMessage msg = NdefMessage.FromByteArray(val);
ReceiveNdefMessage?.Invoke(msg);
}
else
{
StatusMessage?.Invoke("Found empty NDEF TLV");
}
break;
default:
StatusMessage?.Invoke("Skipping unknown TLV " + BitConverter.ToString(new byte[] { tag }));
break;
}
}
}
}
private NdefMessage ReadNdef()
{
try
{
byte[] response = new byte[] { };
_lockSemaphore.Wait();
if (!_isSessionEnabled)
{
throw new Exception("NFC is not enabled");
}
// Type2 tags provide TLV data from page 0x04 to 0x84 (512 bytes).
// TLVs start on page boundaries always, hence length field is in the same page
// regardless of short or long length.
// Page 4 on there are TLVs. Get the NDEF one.
// When last page of NDEF message read, it will create interrupt on device
// that we read the NFC message.
byte ndefTlvPage = 0;
for (byte i = 4; i < 0x84; i++)
{
byte[] page = ReadBinary(0, i, 4);
if (page[0] == NdefTlv)
{
ndefTlvPage = i;
response = page;
break;
}
}
// Check if we have good NDEF msg.
if (ndefTlvPage == 0)
{
throw new Exception();
}
_ndefTlvPage = ndefTlvPage;
// Get length.
int ndefTlvLen = response[1];
int numPayloadPages = 0;
int payloadOffset = 0;
if (ndefTlvLen == 0)
{
// Len 0 means the device is in the middle of updating the memory.
throw new Exception("Invalid NDEF data");
}
else if (ndefTlvLen == 0xFF)
{
// Get length.
ndefTlvLen = response[2] << 8 | response[3];
// Calculate number of payload page still to be read.
numPayloadPages = ndefTlvLen / 4 + (ndefTlvLen % 4 == 0 ? 0 : 1);
// Payload offset.
payloadOffset = 4;
}
else
{
// Calculate number of payload page still to be read.
numPayloadPages = ndefTlvLen / 4 + (ndefTlvLen % 4 < 3 ? 0 : 1);
// Payload offset.
payloadOffset = 2;
}
// Make sure we have enough room for payload.
if (ndefTlvPage + numPayloadPages > 0x84)
{
throw new Exception();
}
// Read payload pages.
for (byte i = (byte)(ndefTlvPage + 1); i < ndefTlvPage + numPayloadPages + 1; i++)
{
byte[] page = ReadBinary(0, i, 4);
response = Combine(response, page);
}
var ndef = new byte[ndefTlvLen];
Buffer.BlockCopy(response, payloadOffset, ndef, 0, ndefTlvLen);
Debug.WriteLine($"{DateTime.Now.TimeOfDay}" + $"#### READ:" + BitConverter.ToString(ndef).
Replace("-", string.Empty));
return(NdefMessage.FromByteArray(ndef));
}
finally
{
_lockSemaphore.Release();
}
byte[] Combine(byte[] a, byte[] b)
{
byte[] c = new byte[a.Length + b.Length];
Buffer.BlockCopy(a, 0, c, 0, a.Length);
Buffer.BlockCopy(b, 0, c, a.Length, b.Length);
return(c);
}
}
private void HandleHCEClient(ICardReader reader)
{
StatusMessage?.Invoke("Attemtping to talk to Android HCE device.");
var selectCmd = new Iso7816.SelectCommand(FLAGCARRIER_HCE_AID, 0);
var res = reader.Transceive(selectCmd);
if (res.SW == 0x6a82)
{
ErrorMessage?.Invoke("Device has no idea who we are.");
return;
}
else if (!res.Succeeded)
{
ErrorMessage?.Invoke("Failed communicating with device: " + res.ToString());
return;
}
StatusMessage?.Invoke("Connected to FlagCarrier HCE device!");
byte[] challengeToken = new byte[32];
random.NextBytes(challengeToken, 0, challengeToken.Length);
var updateCmd = new Iso7816.UpdateBinaryCommand(challengeToken);
res = reader.Transceive(updateCmd);
if (res.SW == 0x6A82)
{
ErrorMessage?.Invoke("HCE Device does not have any data for us.");
return;
}
if (!res.Succeeded)
{
ErrorMessage?.Invoke("Failed sending challenge token: " + res.ToString());
return;
}
StatusMessage?.Invoke("Sent challenge token.");
byte[] ndefData = new byte[0];
const int len = 250;
int offset = 0;
do
{
var readCmd = new Iso7816.ReadBinaryCommand(len, offset);
res = reader.Transceive(readCmd);
if (!res.Succeeded)
{
ErrorMessage?.Invoke("Failed reading data at " + offset + ": " + res.ToString());
return;
}
if (res.ResponseData == null || res.ResponseData.Length == 0)
{
break;
}
Array.Resize(ref ndefData, ndefData.Length + res.ResponseData.Length);
res.ResponseData.CopyTo(ndefData, offset);
offset += res.ResponseData.Length;
} while (res.ResponseData.Length == len);
StatusMessage?.Invoke("Read " + ndefData.Length + " bytes of ndef data from device.");
NdefMessage msg = NdefMessage.FromByteArray(ndefData);
NewTagUid?.Invoke(challengeToken);
ReceiveNdefMessage?.Invoke(msg);
var eraseCmd = new Iso7816.EraseBinaryCommand();
res = reader.Transceive(eraseCmd);
if (!res.Succeeded)
{
ErrorMessage?.Invoke("Failed confirming transaction to device.");
}
}
public void KeyboardWedge(ResponseFrame frame, Exception e)
{
DetectSingleNdef repeatRead = new DetectSingleNdef(0, DetectTagSetting.Type2Type4AandMifare);
bool textEntered = false;
if (CheckForErrorsOrTimeout(frame, e))
{
tappy.SendCommand(repeatRead, InvokeKeyboardFeature);
return;
}
else if (frame.CompareCommandFamilies(new byte[] { 0x00, 0x01 }) && frame.ResponseCode == 0x02)
{
try
{
byte[] data = frame.Data;
byte[] buf = new byte[data.Length - data[1] - 2];
if (buf.Length > 0)
{
Array.Copy(data, 2 + data[1], buf, 0, buf.Length);
NdefMessage message = NdefMessage.FromByteArray(buf);
int numRecords = message.Count;
int recordNum = 1;
foreach (NdefRecord record in message)
{
string type = Encoding.UTF8.GetString(record.Type);
textEntered = false;
if (record.TypeNameFormat == NdefRecord.TypeNameFormatType.NfcRtd && type.Equals("T") && recordTypes.Contains(RecordType.TEXT))
{
NdefTextRecord textRecord = new NdefTextRecord(record);
System.Windows.Forms.SendKeys.SendWait(textRecord.Text);
textEntered = true;
}
else if ((record.TypeNameFormat == NdefRecord.TypeNameFormatType.NfcRtd && type.Equals("U") && recordTypes.Contains(RecordType.URI)) ||
(record.TypeNameFormat == NdefRecord.TypeNameFormatType.Uri && recordTypes.Contains(RecordType.URI)))
{
NdefUriRecord uriRecord = new NdefUriRecord(record);
System.Windows.Forms.SendKeys.SendWait(uriRecord.Uri);
textEntered = true;
}
else if ((record.TypeNameFormat == NdefRecord.TypeNameFormatType.ExternalRtd && recordTypes.Contains(RecordType.EXTERNAL)) ||
(record.TypeNameFormat == NdefRecord.TypeNameFormatType.Mime && recordTypes.Contains(RecordType.MIME)))
{
System.Windows.Forms.SendKeys.SendWait(Encoding.UTF8.GetString(record.Payload));
textEntered = true;
}
if (textEntered == true && formModeActive == true)
{
if (recordNum == numRecords)
{
System.Windows.Forms.SendKeys.SendWait("{ENTER}");
}
else
{
System.Windows.Forms.SendKeys.SendWait("{TAB}");
}
}
else if (textEntered == true)
{
if (controlCharacters.Contains(ControlCharacter.CRLF))
{
System.Windows.Forms.SendKeys.SendWait("{ENTER}");
}
if (controlCharacters.Contains(ControlCharacter.TAB))
{
System.Windows.Forms.SendKeys.SendWait("{TAB}");
}
}
recordNum++;
}
if (textEntered)
{
Thread.Sleep(scanStaggerMs);
}
}
tappy.SendCommand(repeatRead, InvokeKeyboardFeature);
return;
}
catch
{
Console.WriteLine("Error Parsing NDEF Response From Tappy");
}
}
else
{
Console.WriteLine("Invalid TCMP Response From Tappy (i.e not the command family and response code expected)");
}
}
private void nfcService_MessageReceivedCompleted(ProximityMessage message)
{
if (message.MessageType == "WriteableTag")
{
Int32 size = System.BitConverter.ToInt32(message.Data.ToArray(), 0);
tagSize = size;
LogMessage(AppResources.NfcWriteableTagSize + " " + size + " bytes", NfcLogItem.INFO_ICON);
}
else if (message.MessageType == "WindowsMime")
{
var buffer = message.Data.ToArray();
int mimesize = 0;
for (mimesize = 0; mimesize < 256 && buffer[mimesize] != 0; ++mimesize)
{
}
;
var mimeType = Encoding.UTF8.GetString(buffer, 0, mimesize);
string extra = AppResources.NdefRecordMimeType + ": " + mimeType;
LogMessage(AppResources.NdefMessageRecordType + ": WindowsMime", NfcLogItem.INFO_ICON, extra);
return;
}
else if (message.MessageType == "NDEF:Unknown")
{
LogMessage(AppResources.NdefMessageRecordType + ": " + AppResources.NdefUnknown, NfcLogItem.INFO_ICON);
return;
}
else if (message.MessageType == "NDEF")
{
var rawMsg = message.Data.ToArray();
var ndefMessage = NdefMessage.FromByteArray(rawMsg);
// Loop over all records contained in the NDEF message
string messageInformation = "";
foreach (NdefRecord record in ndefMessage)
{
string extra = "";
messageInformation = AppResources.NdefMessageRecordType + ": " + Encoding.UTF8.GetString(record.Type, 0, record.Type.Length);
//if the record is a Smart Poster
if (record.CheckSpecializedType(false) == typeof(NdefSpRecord))
{
// Convert and extract Smart Poster info
var spRecord = new NdefSpRecord(record);
extra = AppResources.NdefSpUri + ": " + spRecord.Uri;
extra += "\n" + AppResources.NdefSpTitles + ": " + spRecord.TitleCount();
extra += "\n" + AppResources.NdefSpTitle + ": " + spRecord.Titles[0].Text;
if (spRecord.ActionInUse())
{
extra += "\n" + AppResources.NdefSpAction + ": " + spRecord.NfcAction;
}
LogMessage(messageInformation, NfcLogItem.INFO_ICON, extra);
}
if (record.CheckSpecializedType(false) == typeof(NdefUriRecord))
{
var uriRecord = new NdefUriRecord(record);
extra = AppResources.NdefSpUri + ": " + uriRecord.Uri;
LogMessage(messageInformation, NfcLogItem.INFO_ICON, extra);
}
if (record.CheckSpecializedType(false) == typeof(NdefTextRecord))
{
var textRecord = new NdefTextRecord(record);
extra = AppResources.NdefTextRecordText + ": " + textRecord.Text;
extra += "\n" + AppResources.NdefTextRecordLanguage + ": " + textRecord.LanguageCode;
LogMessage(messageInformation, NfcLogItem.INFO_ICON, extra);
}
if (record.CheckSpecializedType(false) == typeof(NdefLaunchAppRecord))
{
var launchAppRecord = new NdefLaunchAppRecord(record);
foreach (KeyValuePair <string, string> entry in launchAppRecord.PlatformIds)
{
extra += AppResources.NdefLaunchAppRecordPlatform + ": " + entry.Key + "\n";
extra += AppResources.NdefLaunchAppRecordId + ": " + entry.Value + "\n";
}
extra = extra.TrimEnd('\n');
LogMessage(messageInformation, NfcLogItem.INFO_ICON, extra);
}
if (record.CheckSpecializedType(false) == typeof(NdefAndroidAppRecord))
{
var androidRecord = new NdefAndroidAppRecord(record);
extra = AppResources.NdefAAR + ": " + androidRecord.PackageName;
LogMessage(messageInformation, NfcLogItem.INFO_ICON, extra);
}
}
return;
}
}
