/// <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);
            }
        }
        /// <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);
            }
        }
        /// <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)
        {
            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(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);
            }
        }
Example #6
0
        /// <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);
            }
        }
Example #7
0
        /// <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);
            }
        }