private static void GetCardID(SmartCardReader sender, CardAddedEventArgs args)
{
byte[] byteCardID = Get7ByteCardID(args).Result;
string decimalCardID = Convert7ByteCardIDToDecimal(byteCardID);
CopyPaste(decimalCardID);
}
private async void CardReader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
// Handle Card
//await HandleCard(args.SmartCard);
//ShowToastNotification("Card Added");
System.Diagnostics.Debug.WriteLine("Card Added");
ShowToastNotification("Card Added");
await HandleCard(args.SmartCard);
}
private void Reader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
// A card has been inserted into the sender SmartCardReader.
this.Frame.Navigate(typeof(AuthorizingPage));
});
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(CardAddedEventArgs args)
{
try
{
card?.Dispose();
card = args.SmartCard.CreateMiFareCard();
var cardIdentification = await card.GetCardInfo();
DisplayText("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString() + "\r\nCard name: " + cardIdentification.PcscCardName.ToString());
if (cardIdentification.PcscDeviceClass == MiFare.PcSc.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == CardName.MifareStandard1K || cardIdentification.PcscCardName == CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
DisplayText("MIFARE Standard/Classic card detected");
var uid = await card.GetUid();
DisplayText("UID: " + BitConverter.ToString(uid));
// 16 sectors, print out each one
for (var sector = 0; sector < 16; sector++)
{
try
{
var data = await card.GetData(sector, 0, 48);
string hexString = "";
for (int i = 0; i < data.Length; i++)
{
hexString += data[i].ToString("X2") + " ";
}
DisplayText(string.Format("Sector '{0}':{1}", sector, hexString));
}
catch (Exception)
{
DisplayText("Failed to load sector: " + sector);
}
}
}
}
catch (Exception e)
{
PopupMessage("HandleCard Exception: " + e.Message);
}
}
void HandleCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
// This event handler will not be invoked on the UI thread. Hence,
// to perform UI operations we need to post a lambda to be executed
// back on the UI thread; otherwise we may access objects which
// are not marshalled for the current thread, which will result in an
// exception due to RPC_E_WRONG_THREAD.
uiContext.Post((object ignore) =>
{
rootPage.NotifyUser("Card added to reader " + reader.Name + ".", NotifyType.StatusMessage);
}, null);
}
/// <summary>
/// Card added event handler gets triggered when card enters nfc field
/// </summary>
/// <returns>None</returns>
public async void CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
try
{
ChangeTextBlockFontColor(TextBlock_Header, Windows.UI.Colors.Green);
await HandleCard(args);
}
catch (Exception e)
{
PopupMessage("CardAdded Exception: " + e.Message);
}
}
private void Stack_CardAdded(object sender, CardAddedEventArgs e)
{
if (!fetcedCards.ContainsKey(e.CardIndex))
{
Vector3 position = lastAddedCardPosition;
if (fetcedCards.Count > 0)
{
position += offset;
}
AddCard(position, e.CardIndex, fetcedCards.Count);
}
}
/// <summary>
/// Card added event handler gets triggered when card enters nfc field
/// </summary>
/// <returns>None</returns>
public async void CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
try
{
ChangeTextBlockFontColor(TextBlock_Header, Windows.UI.Colors.Green);
await HandleCard(args);
}
catch (Exception e)
{
PopupMessage("CardAdded Exception: " + e.Message);
}
}
private static async Task <byte[]> Get7ByteCardUID(CardAddedEventArgs args)
{
byte[] byteReadUID = new byte[] { (byte)0xFF, (byte)0xCA,
(byte)0x00, (byte)0x00, (byte)0x00 };
SmartCardConnection cardConnection = await args.SmartCard.ConnectAsync();
IBuffer bufferResultUID = await cardConnection.TransmitAsync(byteReadUID.AsBuffer());
CryptographicBuffer.CopyToByteArray(bufferResultUID, out byte[] byteResultUID);
return(byteResultUID);
}
private async void CardAdded(object sender, CardAddedEventArgs args)
{
Debug.WriteLine("Card Added");
try
{
ChangeTextBlockFontColor(TextBlock_Header, Windows.UI.Colors.Green);
await HandleCard(args);
}
catch (Exception ex)
{
PopupMessage("CardAdded Exception: " + ex.Message);
}
}
protected virtual async void CardReader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
try
{
card = args.SmartCard;
connection = await card.ConnectAsync();
//Tuple<CardName, DeviceClass> cardType = await DetectCardType();
OnCardPutInField(new EventArgs());
}
catch (Exception ex)
{
LogMessage(ex.Message);
}
}
private static void Reader_CardAdded(object sender, CardAddedEventArgs ev)
{
WriteToLog("Reader_CardAdded");
try
{
_card?.Dispose();
_card = ev.SmartCard.CreateMiFareCard();
_cardBadSectors = ReadBadsFromFileSector();
}
catch (Exception e)
{
WriteToLog($"Reader_CardAdded ERROR!!!\r\n {e}");
throw;
}
}
private async void SmartCardReaderOnCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
SetStatusOutput("Found smart card");
// Get Answer to Reset (ATR) according to ISO 7816
// ATR = info about smart card's characteristics, behaviors, and state
// https://en.wikipedia.org/wiki/Answer_to_reset
var info = await args.SmartCard.GetAnswerToResetAsync();
var infoArray = info.ToArray();
SetStatusOutput("Answer to Reset: " + BitConverter.ToString(infoArray));
// Connect to the card
// var connection = await args.SmartCard.ConnectAsync();
// ...
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void cardEV_Tap(SmartCardReader sender, CardAddedEventArgs args)
{
CardStatus = ScanningStatus.CardScanning;
try
{
System.Diagnostics.Debug.WriteLine("Got card tap event.");
// woooot
using (SmartCardConnection connection = await args.SmartCard.ConnectAsync())
{
// figure out what kind of card this is.
IccDetection cardIdentification = new IccDetection(args.SmartCard, connection);
await cardIdentification.DetectCardTypeAync();
System.Diagnostics.Debug.WriteLine("FOUND CARD");
System.Diagnostics.Debug.WriteLine(cardIdentification.PcscDeviceClass.ToString());
if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
Pcsc.Desfire.AccessHandler desfireAccess = new Pcsc.Desfire.AccessHandler(connection);
PhysicalCard.Desfire.DesfireCard _card = await ZaibatsuPass.PhysicalCard.Desfire.DesfireCard.SnapshotAsync(desfireAccess);
var ignored = Dispatcher.RunAsync(
Windows.UI.Core.CoreDispatcherPriority.Normal,
() => {
// try to parse the card
tCard = _card;
TransitCard.TransitCard parsedCard = TransitCard.TransitCardParser.parseTransitCard(tCard);
if (parsedCard == null)
{
CardStatus = ScanningStatus.ScanningFailure;
}
else
{
(Window.Current.Content as Frame).Navigate(typeof(DetailsPage), parsedCard);
}
});
CardStatus = ScanningStatus.ScanningSuccess;
}
}
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(" ** OOPS: " + e.ToString());
CardStatus = ScanningStatus.ScanningFailure;
}
}
public static async void OnCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
// カード検索
var card = args.SmartCard;
if (card == null)
{
return;
}
Debug.WriteLine("Card OK");
// カードタイプ判別
using (var connection = await card.ConnectAsync())
{
IccDetection detection = new IccDetection(card, connection);
await detection.DetectCardTypeAync();
Debug.WriteLine("CardName : " + detection.PcscCardName.ToString());
if (detection.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass && detection.PcscCardName == Pcsc.CardName.FeliCa)
{
var felicaAccess = new Felica.AccessHandler(connection);
byte[] commandPacket = new byte[] { 0x00, 0x00, 0xff, 0xff, 0x01, 0x0f };
commandPacket[0] = (byte)commandPacket.Length;
byte[] result = await felicaAccess.TransparentExchangeAsync(commandPacket);
byte[] idm = new byte[8];
Array.Copy(result, 2, idm, 0, idm.Length);
byte[] systemCode = new byte[2];
Array.Copy(result, 18, systemCode, 0, systemCode.Length);
string strIdm = BitConverter.ToString(idm);
string strSystemCode = BitConverter.ToString(systemCode);
Debug.WriteLine("IDm : " + strIdm);
Debug.WriteLine("SystemCode : " + strSystemCode);
}
}
}
private async void Reader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): CardAdded event fired.");
try
{
TravelCard card = await CardOperations.ReadTravelCardAsync(args.SmartCard);
if (card != null)
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Successful read card.");
Task updateCardTask = SharedState.SetAsync(SharedState.LastSeenCard, card.RawValues);
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): LastSeenCard updated.");
Task updateTimestampTask = SharedState.SetAsync(SharedState.LastSeenTimestamp, DateTimeOffset.UtcNow);
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): LastSeenTimestamp updated.");
if (await SharedState.GetAsync <bool>(SharedState.IsApplicationInForeground))
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Application is in the foreground. Changed Progress value.");
_taskInstance.Progress = 2;
}
else
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Application is in the background. Post toast notification.");
PostToastNotification(card);
}
}
}
catch (Exception ex)
{
await SharedState.LogAsync($"BackgroundScanner ({_taskInstance.InstanceId}): Failed to read travel card! Exception: {ex}\nStack trace: {ex.StackTrace}");
}
}
private static async void OnCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
try
{
await HandleCard(args.SmartCard);
// Raise on UI thread
context.Post(_ =>
{
var evt = cardAdded;
if (evt != null)
{
evt(sender, EventArgs.Empty);
}
}, null);
}
catch (Exception ex)
{
// TODO: Add logging
Debug.WriteLine(ex);
}
}
private async void cardReader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
SmartCard smartCard = args.SmartCard;
try
{
await LogMessageAsync("カードを検知しました", true);
using (SmartCardConnection connection = await smartCard.ConnectAsync())
{
IccDetection cardIdentification = new IccDetection(smartCard, connection);
await cardIdentification.DetectCardTypeAync();
await LogMessageAsync("PC/SCデバイスクラス: " + cardIdentification.PcscDeviceClass.ToString());
await LogMessageAsync("カード名: " + cardIdentification.PcscCardName.ToString());
if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == CardName.FeliCa)
{
await LogMessageAsync("FelicaCardがみつかりました");
if (isEDYChecked)
{
await ReadEdyAsync(connection);
}
else
{
await ReadSuicaAsync(connection);
}
}
}
}
catch (Exception ex)
{
await LogMessageAsync("例外が発生: " + ex.ToString());
}
}
private async void cardReader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
await HandleCard(args.SmartCard);
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(CardAddedEventArgs args)
{
try
{
var newConnection = await args.SmartCard.ConnectAsync();
lock (CardConnectionLock)
{
if (CardConnection != null)
{
CardConnection.Dispose();
}
CardConnection = newConnection;
}
IccDetection cardIdentification = new IccDetection(args.SmartCard, CardConnection);
await cardIdentification.DetectCardTypeAync();
DisplayText("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString() + "\r\nCard name: " + cardIdentification.PcscCardName.ToString());
if ((cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass) &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightC ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralight ||
cardIdentification.PcscCardName == Pcsc.CardName.MifareUltralightEV1))
{
// Handle MIFARE Ultralight
MifareUltralight.AccessHandler mifareULAccess = new MifareUltralight.AccessHandler(CardConnection);
// Each read should get us 16 bytes/4 blocks, so doing
// 4 reads will get us all 64 bytes/16 blocks on the card
for (byte i = 0; i < 4; i++)
{
byte[] response = await mifareULAccess.ReadAsync((byte)(4 * i));
DisplayText("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
DisplayText("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(CardConnection);
Desfire.CardDetails card = await desfireAccess.ReadCardDetailsAsync();
DisplayText("DesFire Card Details: " + Environment.NewLine + card.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
DisplayText("Felica card detected");
var felicaAccess = new Felica.AccessHandler(CardConnection);
var uid = await felicaAccess.GetUidAsync();
DisplayText("UID: " + BitConverter.ToString(uid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard1K || cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
DisplayText("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(CardConnection);
var uid = await mfStdAccess.GetUidAsync();
DisplayText("UID: " + BitConverter.ToString(uid));
ushort maxAddress = 0;
switch (cardIdentification.PcscCardName)
{
case Pcsc.CardName.MifareStandard1K:
maxAddress = 0x3f;
break;
case Pcsc.CardName.MifareStandard4K:
maxAddress = 0xff;
break;
}
await mfStdAccess.LoadKeyAsync(MifareStandard.DefaultKeys.FactoryDefault);
for (ushort address = 0; address <= maxAddress; address++)
{
var response = await mfStdAccess.ReadAsync(address, Pcsc.GeneralAuthenticate.GeneralAuthenticateKeyType.MifareKeyA);
DisplayText("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
}
catch (Exception e)
{
PopupMessage("HandleCard Exception: " + e.Message);
}
}
private async void cardReader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
await HandleCard(args.SmartCard);
}
private void Reader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
ReadCard(args.SmartCard);
}
void HandleCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
// This event handler will not be invoked on the UI thread. Hence,
// to perform UI operations we need to post a lambda to be executed
// back on the UI thread; otherwise we may access objects which
// are not marshalled for the current thread, which will result in an
// exception due to RPC_E_WRONG_THREAD.
uiContext.Post((object ignore) =>
{
rootPage.NotifyUser(
"Card added to reader " + reader.Name + ".",
NotifyType.StatusMessage);
}, null);
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(CardAddedEventArgs args)
{
try
{
card?.Dispose();
card = args.SmartCard.CreateMiFareCard();
var cardIdentification = await card.GetCardInfo();
DisplayText("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString() + "\r\nCard name: " + cardIdentification.PcscCardName.ToString());
if (cardIdentification.PcscDeviceClass == MiFare.PcSc.DeviceClass.StorageClass
&& (cardIdentification.PcscCardName == CardName.MifareStandard1K || cardIdentification.PcscCardName == CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
DisplayText("MIFARE Standard/Classic card detected");
var uid = await card.GetUid();
DisplayText("UID: " + BitConverter.ToString(uid));
// 16 sectors, print out each one
for (var sector = 0; sector < 16; sector++)
{
try
{
var data = await card.GetData(sector, 0, 48);
string hexString = "";
for (int i = 0; i < data.Length; i++)
{
hexString += data[i].ToString("X2") + " ";
}
DisplayText(string.Format("Sector '{0}':{1}", sector, hexString));
}
catch (Exception)
{
DisplayText("Failed to load sector: " + sector);
}
}
}
}
catch (Exception e)
{
PopupMessage("HandleCard Exception: " + e.Message);
}
}
private async void Reader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
var cards = await sender.FindAllCardsAsync();
if (cards.Count < 1)
{
return;
}
var card = cards[0];
const int READ_AMOUNT = 80;
SmartCardConnection connection;
try
{
connection = await card.ConnectAsync();
}
catch (Exception) // This is literally the most specific exception sent for this error
{
// Couldn't open reader because tag was lifted too early
return;
}
using (connection)
{
const byte START_BLOCK = 4;
const byte MAX_READ_SIZE = 16;
byte[] data = new byte[READ_AMOUNT];
for (int i = 0; i < Math.Ceiling((float)READ_AMOUNT / MAX_READ_SIZE); i++)
{
byte[] command = { 0xFF, 0xB0, 0x00, (byte)(START_BLOCK + i * 4), MAX_READ_SIZE };
var response = await connection.TransmitAsync(command.AsBuffer());
if (response.Length != MAX_READ_SIZE + 2) // 2 bytes for command execution status
{
Debug.WriteLine("Tag lifted too early");
return;
}
uint length = response.Length;
response.CopyTo(0, data, i * MAX_READ_SIZE, MAX_READ_SIZE);
}
// Parse TLV blocks
for (int i = 0; i < data.Length; i++)
{
if (data[i] == 0x00)
{
// NULL TLV
continue;
}
else if (data[i] == 0x01)
{
// Lock control TLV
i++;
i += data[i]; // Skip over block according to its length
}
else if (data[i] == 0x03)
{
// NDEF TLV
i++;
byte length = data[i];
byte[] ndefData = new byte[length];
Array.Copy(data, i + 1, ndefData, 0, length);
string uri = getURIFromNdef(ndefData);
OnBadgeTapped(new BadgeEventArgs(uri));
i += length + 1; // Also skip over trailing 0xFE
}
}
}
}
private async void SmartCardReaderOnCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
SetStatusOutput("Found smart card");
// Get Answer to Reset (ATR) according to ISO 7816
// ATR = info about smart card's characteristics, behaviors, and state
// https://en.wikipedia.org/wiki/Answer_to_reset
var info = await args.SmartCard.GetAnswerToResetAsync();
var infoArray = info.ToArray();
SetStatusOutput("Answer to Reset: " + BitConverter.ToString(infoArray));
// Connect to the card
// var connection = await args.SmartCard.ConnectAsync();
// ...
}
private void PlayerDeck_CardAdded(object sender, CardAddedEventArgs e)
{
//Check for valid move.
controller.ChangeState(RummyPlayerDiscardState.Instance);
}
void HandleCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
// Note that this event is raised from a background thread.
// However, the NotifyUser method is safe to call from background threads.
rootPage.NotifyUser("Card added to reader " + reader.Name + ".", NotifyType.StatusMessage);
}
private static void Reader_CardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
card = args.SmartCard.CreateMiFareCard();
RaiseStatusUpdate(true);
}
