private static async void InitCard()
{
WriteToLog("InitCard");
try
{
if (_card == null)
{
//if (_isInfoNoCardShow)
// return;
//throw new Exception("No card!");
WriteToLog("ERROR!!! No card!");
return;
}
_cardIdentification = await _card.GetCardInfo();
WriteToLog("Connected to card\r\nPC/SC device class: " + _cardIdentification.PcscDeviceClass +
"\r\nCard name: " + _cardIdentification.PcscCardName);
}
catch (Exception e)
{
WriteToLog("InitCard ERROR!!!\r\n" + e.Message);
//throw;
}
}
public async void OnCardAdded(SmartCardReader sender, CardAddedEventArgs args)
{
// カード検索
var card = args.SmartCard;
if (card == null)
{
return;
}
Log("Card OK");
// カードタイプ判別
using (var con = await card.ConnectAsync())
{
IccDetection detection = new IccDetection(card, con);
await detection.DetectCardTypeAync();
Log(" CardName : " + detection.PcscCardName.ToString());
Log(" DeviceClass : " + detection.PcscDeviceClass.ToString());
if (detection.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
detection.PcscCardName == Pcsc.CardName.FeliCa)
{
new Controller.FelicaController(con);
}
}
}
private void HandleSmartCard(String readerName)
{
using (ISCardContext ctx = contextFactory.Establish(SCardScope.System))
using (ICardReader reader = ctx.ConnectReader(readerName, SCardShareMode.Shared, SCardProtocol.Any))
{
StatusMessage?.Invoke("Connected to tag");
IccDetection cardIdent = new IccDetection(reader);
cardIdent.DetectCardType();
StatusMessage?.Invoke("Device class: " + cardIdent.PcscDeviceClass.ToString());
StatusMessage?.Invoke("Card name: " + cardIdent.PcscCardName.ToString());
StatusMessage?.Invoke("ATR: " + BitConverter.ToString(cardIdent.Atr));
if (cardIdent.PcscDeviceClass == DeviceClass.StorageClass &&
(cardIdent.PcscCardName == CardName.MifareUltralight ||
cardIdent.PcscCardName == CardName.MifareUltralightC ||
cardIdent.PcscCardName == CardName.MifareUltralightEV1))
{
HandleMifareUL(reader);
}
else if (cardIdent.PcscDeviceClass == DeviceClass.StorageClass &&
(cardIdent.PcscCardName == CardName.MifareStandard1K ||
cardIdent.PcscCardName == CardName.MifareStandard4K))
{
HandleMifareStandard(reader);
}
else
{
HandleHCEClient(reader);
}
}
}
public async Task <IccDetection> GetCardInfo()
{
var atrbytes = await GetAnswerToResetAsync();
var cardIdentification = new IccDetection(atrbytes);
return(cardIdentification);
}
public async Task <IccDetection> GetCardInfo()
{
if (cardInfo == null)
{
cardInfo = await Reader.GetCardInfo();
}
return(cardInfo);
}
private void Initialize()
{
sectors = new Sector[MaxSectors];
mad = null;
mad2 = null;
cardInfo = null;
ActiveSector = -1;
}
/// <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);
}
}
}
public async Task ConnectAsync(SmartCard smartcard)
{
_MifareSmartCard = smartcard;
var newConnection = await smartcard.ConnectAsync();
lock (CardConnectionLock)
{
if (_MifareSmartCardConnection != null)
{
_MifareSmartCardConnection.Dispose();
}
_MifareSmartCardConnection = newConnection;
}
mfStdAccess = new Mifare.AccessHandler(_MifareSmartCardConnection);
IccDetection cardIdentification = new IccDetection(_MifareSmartCard, _MifareSmartCardConnection);
await cardIdentification.DetectCardTypeAync();
CurrentCardName = cardIdentification.PcscCardName;
if (!(CurrentCardName == CardName.MifareStandard1K || CurrentCardName == CardName.MifareStandard4K))
{
throw new Mifare.Exceptions.CardTypeException("this Card is not mifare classic card");
}
}
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());
}
}
public async Task <Tuple <CardName, DeviceClass> > DetectCardType()
{
try
{
if (connection == null)
{
throw new Exception("Card connection not initialised");
}
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
return(Tuple.Create(cardIdentification.PcscCardName, cardIdentification.PcscDeviceClass));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
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(connection);
// 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));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var felicaAccess = new Felica.AccessHandler(connection);
var uid = await felicaAccess.GetUidAsync();
LogMessage("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
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
LogMessage("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);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
LogMessage("Failure getting UID of card, " + apduRes.ToString());
}
else
{
LogMessage("UID: " + BitConverter.ToString(apduRes.ResponseData));
}
}
}
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
public void FindCard(int timeoutInSecs = 10,
CancellationTokenSource tokenSource = null)
{
Task findCardTask = Task.Factory.StartNew(async() =>
{
// SmartCardReaderを取得
var deviceInfo = await SmartCardReaderUtils.GetFirstSmartCardReaderInfo(SmartCardReaderKind.Nfc);
this.IsSupported = deviceInfo != null;
this.IsEnabled = (deviceInfo != null) && deviceInfo.IsEnabled;
if (!this.IsSupported)
{
throw new FelicaReaderNotSupportedException("NFC is not supported");
}
else if (!this.IsEnabled)
{
throw new FelicaReaderNotEnabledException("NFC is not enabled");
}
this.reader = await SmartCardReader.FromIdAsync(deviceInfo.Id);
// Felicaカードを探索
var cts = tokenSource ?? new CancellationTokenSource();
try
{
var task = this.FindSmartCard(this.reader, cts.Token);
task.Wait(timeoutInSecs * 1000);
if (task.Status == TaskStatus.RanToCompletion)
{
var smartCard = task.Result;
SmartCardConnection connection = await smartCard.ConnectAsync();
IccDetection cardIdentification = new IccDetection(smartCard, connection);
await cardIdentification.DetectCardTypeAync();
if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
this.felicaCardSubject.OnNext(new FelicaCardMediaImplementation(connection));
}
else
{
throw new UnknownCardException(
String.Format("Unknown device: PcscDeviceClass={0}, PcscCardName={1}",
cardIdentification.PcscDeviceClass,
cardIdentification.PcscCardName));
}
}
else if (task.Status == TaskStatus.Canceled)
{
throw new FelicaReaderTimeoutException("Read Timeout");
}
else
{
// Timeoutが発生した場合
throw new FelicaReaderTimeoutException("Read Timeout");
}
}
catch (AggregateException)
{
throw new FelicaReaderException();
}
});
return;
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
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(connection);
await mifareULAccess.ReadCapsAsync();
if (!mifareULAccess.isNTag21x)
{
var ignored1 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
var msgbox = new Windows.UI.Popups.MessageDialog("This application only works with the NXP NTAG21x line of NFC chips. Sorry.");
msgbox.Commands.Add(new Windows.UI.Popups.UICommand("OK"));
await msgbox.ShowAsync();
});
return;
}
bool authenticated = false;
byte[] password = await ParseField(passwordBox, 4);
byte[] passwordAck = await ParseField(passwordAckBox, 2);
if (password != null && passwordAck != null)
{
try
{
await mifareULAccess.AuthenticateWithPassword(password, passwordAck);
authenticated = true;
}
catch (Exception ex)
{
Debug.WriteLine("Exception sending provisioning password: "******"Exception sending provisioning password: "******"ReadCount: " + responseAccess.ToString());
var ignored2 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
accessCount.Text = responseAccess.ToString();
});
accessCountEnabled = true;
}
catch (Exception ex)
{
Debug.WriteLine("Exception sending Getting Access Count: " + ex);
}
if (!accessCountEnabled)
{
var ignored3 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
accessCount.Text = " ";
accessCountEnable.Visibility = Visibility.Visible;
});
if (autoProvision.IsChecked == true)
{
await mifareULAccess.EnableAccessCountAsync();
}
}
for (byte i = 0; i < mifareULAccess.Blocks; i++)
{
byte[] response = await mifareULAccess.ReadAsync((byte)(4 * i));
for (byte y = 0; y < 4; y++)
{
byte[] buf4 = new byte[4];
Array.Copy(response, y * 4, buf4, 0, 4);
LogMessage((i * 4 + y).ToString("x2") + ": " + BitConverter.ToString(buf4));
}
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
string uidString = BitConverter.ToString(responseUid);
LogMessage("UID: " + uidString);
var ignored4 = this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
uid.Text = uidString;
UidPanel.Visibility = Visibility.Visible;
});
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception handling card: " + ex.ToString());
}
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
//MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
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(connection);
// 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));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var cyberneticsAccess = new Cybernetics.AccessHandler(connection);
var cardinfo = null as Cybernetics.CardInfo;
var histories = new List <Cybernetics.HistoryInfo>();
var gateHistories = new List <Cybernetics.GateHistoryInfo>();
var sfHistory = null as Cybernetics.SFEntryInfo;
var IDm = await cyberneticsAccess.GetUidAsync(); // ok
LogMessage("IDm: " + BitConverter.ToString(IDm));
await cyberneticsAccess.SelectFileAsync(new byte[] { 0x8B, 0x00 });
var block008B = await cyberneticsAccess.ReadBinaryAsync(0x00);
LogMessage("Card Type: " + BitConverter.ToString(block008B));
cardinfo = Cybernetics.CardInfo.FromBytes(block008B);
await cyberneticsAccess.SelectFileAsync(new byte[] { 0x0F, 0x09 });
for (byte block = 0; block < 20; ++block)
{
var block090F = await cyberneticsAccess.ReadBinaryAsync(block);
LogMessage("History: " + BitConverter.ToString(block090F));
histories.Add(Cybernetics.HistoryInfo.FromBytes(block090F));
}
var histList = new List <ICHistoryReader.Core.Cybernetics.HistoryInfo>();
var prevHist = null as ICHistoryReader.Core.Cybernetics.HistoryInfo;
foreach (var hist in histories)
{
var h = ICHistoryReader.Core.Cybernetics.HistoryInfo.From(hist, m_stationCodeList);
histList.Add(h);
if (prevHist != null)
{
// 前の履歴から精算額を計算
prevHist.Amount = h.Balance - prevHist.Balance;
}
prevHist = h;
}
histList = histList.SkipLast(1).ToList();
await cyberneticsAccess.SelectFileAsync(new byte[] { 0x8F, 0x10 });
for (byte block = 0; block < 3; ++block)
{
var block108F = await cyberneticsAccess.ReadBinaryAsync(block);
LogMessage("Gate: " + BitConverter.ToString(block108F));
gateHistories.Add(Cybernetics.GateHistoryInfo.FromBytes(block108F));
}
await cyberneticsAccess.SelectFileAsync(new byte[] { 0xCB, 0x10 });
var temp = new List <byte>();
for (byte block = 0; block < 2; ++block)
{
var block10CB = await cyberneticsAccess.ReadBinaryAsync(block);
LogMessage("SF: " + BitConverter.ToString(block10CB));
temp.AddRange(block10CB);
}
sfHistory = Cybernetics.SFEntryInfo.FromBytes(temp.ToArray());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard1K || cardIdentification.PcscCardName == Pcsc.CardName.MifareStandard4K))
{
// Handle MIFARE Standard/Classic
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
LogMessage("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);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
LogMessage("Failure getting UID of card, " + apduRes.ToString());
}
else
{
LogMessage("UID: " + BitConverter.ToString(apduRes.ResponseData));
}
}
}
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
/// <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);
}
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
var connection = await card.ConnectAsync();
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card 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(connection);
// 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));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var felicaAccess = new Felica.AccessHandler(connection);
var uid = await felicaAccess.GetUidAsync();
LogMessage("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
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
LogMessage("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);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
LogMessage("UID: " + BitConverter.ToString(uid));
}
connection.Dispose();
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card, SmartCardReader sender)
{
string UID = "";
Int64 id = 0;
try
{
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
LogMessage("ATR: " + BitConverter.ToString(cardIdentification.Atr));
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(connection);
// 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));
LogMessage("Block " + (4 * i).ToString() + " to Block " + (4 * i + 3).ToString() + " " + BitConverter.ToString(response));
}
byte[] responseUid = await mifareULAccess.GetUidAsync();
UID = BitConverter.ToString(responseUid);
//await Notify("UID: " + BitConverter.ToString(responseUid));
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
cardIdentification.PcscCardName == Pcsc.CardName.FeliCa)
{
// Handle Felica
LogMessage("Felica card detected");
var felicaAccess = new Felica.AccessHandler(connection);
var uid = await felicaAccess.GetUidAsync();
UID = BitConverter.ToString(uid);
//await Notify("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
LogMessage("MIFARE Standard/Classic card detected");
var mfStdAccess = new MifareStandard.AccessHandler(connection);
var uid = await mfStdAccess.GetUidAsync();
UID = BitConverter.ToString(uid);;
//await Notify("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);
LogMessage("Block " + address.ToString() + " " + BitConverter.ToString(response));
}
}
else if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.StorageClass &&
(cardIdentification.PcscCardName == Pcsc.CardName.ICODE1 ||
cardIdentification.PcscCardName == Pcsc.CardName.ICODESLI ||
cardIdentification.PcscCardName == Pcsc.CardName.iCodeSL2))
{
// Handle ISO15693
LogMessage("ISO15693 card detected");
var iso15693Access = new Iso15693.AccessHandler(connection);
var uid = await iso15693Access.GetUidAsync();
UID = BitConverter.ToString(uid);
//await Notify("UID: " + BitConverter.ToString(uid));
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
LogMessage("Failure getting UID of card, " + apduRes.ToString());
}
else
{
LogMessage("UID: " + BitConverter.ToString(apduRes.ResponseData));
UID = BitConverter.ToString(apduRes.ResponseData);
}
}
// START MANAGING SUP STOCK
// UID
if (UID != "")
{
id = ToUID(UID);
bool found = false;
int i = 0;
// check if ID is in left list
foreach (var it in AwaySUP)
{
i++;
if (it.IsSameID(id))
{
found = true;
// set price according to dT
int Price = it.GetPrice();
//wait for validation, then move from left to stock
await Notify("! Arrivé, durée = " + it.strTime + " Prix: " + Price + " CHF");
//move from Left to Stock
try
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
// Your UI update code goes here
StockSUP.Add(it);
AwaySUP.Remove(it);
StockShow.UpdateLayout();
LeftShow.UpdateLayout();
}
);
}
catch (Exception ex)
{
await Notify("Error swapping from away to stock" + ex.ToString());
}
}
}
i = 0;
// check if ID is in stock list
if (!found)
{
foreach (var it in StockSUP)
{
i++;
if (it.IsSameID(id))
{
found = true;
// start time
await Notify("! Valide, près à partir !", "Départ");
i = 0;
it.StartTimer();
//move from stock to left list
try
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
// Your UI update code goes here!
AwaySUP.Add(it);
StockSUP.Remove(it);
StockShow.UpdateLayout();
LeftShow.UpdateLayout();
}
);
}
catch (Exception ex)
{
await Notify("Error swapping from stock to away" + ex.ToString());
}
}
}
}
// else, adding to stock list
if (!found)
{
if (isNewTagNewSUP)
{
await Notify("! Nouvelle planche ajoutée.");
isNewTagNewSUP = false;
try
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
// Your UI update code goes here!
StockSUP.Add(new SUP(id, SUPCategory[selN]));
}
);
}
catch (Exception ex)
{
await Notify("Error adding to stock" + ex.ToString());
}
showNbStock.Text = StockSUP.Count.ToString();
StockShow.UpdateLayout();
LeftShow.UpdateLayout();
}
else
{
await Notify("! Cette planche n'est pas répértoriée !");
}
}
}
}
}
catch (Exception ex)
{
LogMessage("Exception handling card: " + ex.ToString(), NotifyType.ErrorMessage);
}
}
private void Initialize()
{
sectors = new Sector[MaxSectors];
mad = null;
mad2 = null;
cardInfo = null;
ActiveSector = -1;
}
public async Task<IccDetection> GetCardInfo()
{
if (cardInfo == null)
cardInfo = await Reader.GetCardInfo();
return cardInfo;
}
/// <summary>
/// Sample code to hande a couple of different cards based on the identification process
/// </summary>
/// <returns>None</returns>
private async Task HandleCard(SmartCard card)
{
try
{
// Clear the messages
//MainPage.Current.NotifyUser(String.Empty, NotifyType.StatusMessage, true);
// Connect to the card
using (SmartCardConnection connection = await card.ConnectAsync())
{
// Try to identify what type of card it was
IccDetection cardIdentification = new IccDetection(card, connection);
await cardIdentification.DetectCardTypeAync();
//Connected to card
//LogMessage("Connected to card\r\nPC/SC device class: " + cardIdentification.PcscDeviceClass.ToString());
//Card name
//LogMessage("Card name: " + cardIdentification.PcscCardName.ToString());
//If card is "MIFARE DEFIRE" (our case)
if (cardIdentification.PcscDeviceClass == Pcsc.Common.DeviceClass.MifareDesfire)
{
// Handle MIFARE DESfire
Desfire.AccessHandler desfireAccess = new Desfire.AccessHandler(connection);
// Get all data from card
Desfire.CardDetails desfire = await desfireAccess.ReadCardDetailsAsync();
// Get UID from object desfire
var UID = BitConverter.ToString(desfire.UID);
//LogMessage(UID, NotifyType.StatusMessage);
ShowToastNotification(UID);
PerformAuthentication();
//LogMessage("DesFire Card Details: " + Environment.NewLine + desfire.ToString());
}
else
{
// Unknown card type
// Note that when using the XDE emulator the card's ATR and type is not passed through, so we'll
// end up here even for known card types if using the XDE emulator
// Some cards might still let us query their UID with the PC/SC command, so let's try:
var apduRes = await connection.TransceiveAsync(new Pcsc.GetUid());
if (!apduRes.Succeeded)
{
ShowToastNotification("Failure getting UID of card, " + apduRes.ToString());
}
else
{
ShowToastNotification("UID: " + BitConverter.ToString(apduRes.ResponseData));
}
}
}
}
catch (Exception ex)
{
ShowToastNotification("Exception handling card: " + ex.ToString());
}
}
