Udostępnij za pośrednictwem


Tworzenie aplikacji karty inteligentnej NFC

Ważne

Ten temat dotyczy tylko systemu Windows 10 Mobile.

W tym temacie opisano, jak używać emulacji karty hosta (HCE) do bezpośredniej komunikacji z czytnikiem kart zbliżeniowych (NFC) i umożliwiać klientom dostęp do usług za pośrednictwem telefonu (zamiast karty fizycznej) bez operatora sieci komórkowej (MNO).

Co jest potrzebne do opracowania aplikacji HCE

Aby utworzyć aplikację emulacji kart opartych na technologii HCE, należy zainstalować program Microsoft Visual Studio 2015 (zobacz stronę pobierania programu Visual Studio) (w tym narzędzia deweloperskie systemu Windows) i emulator systemu Windows 10 Mobile.

Aby uzyskać więcej informacji na temat konfiguracji, zobacz Przetestuj przy użyciu emulatora Microsoft dla systemu Windows 10 Mobile.

Opcjonalnie, jeśli chcesz przetestować rzeczywiste urządzenie z systemem Windows 10 Mobile zamiast dołączonego emulatora systemu Windows 10 Mobile, potrzebne będą również następujące elementy.

  • Urządzenie z systemem Windows 10 Mobile z obsługą technologii NFC HCE.
  • Terminal czytnika obsługujący protokoły ISO/IEC 14443-4 i ISO/IEC 7816-4

System Windows 10 Mobile implementuje usługę HCE, która zapewnia następujące funkcje.

  • Aplikacje mogą rejestrować identyfikatory apletów (AID) dla kart, które chcą emulować.
  • Rozwiązywanie konfliktów i przekierowywanie par poleceń i odpowiedzi jednostki danych protokołu aplikacji (APDU) do jednej z zarejestrowanych aplikacji na podstawie wyboru karty przez czytnik zewnętrzny i preferencji użytkownika.
  • Obsługa zdarzeń i powiadomień do aplikacji w wyniku akcji użytkownika.

System Windows 10 obsługuje emulację kart inteligentnych opartych na ISO-DEP (ISO-IEC 14443-4) i komunikuje się przy użyciu jednostek APDU zgodnie z definicją w specyfikacji ISO-IEC 7816-4. System Windows 10 obsługuje technologię ISO/IEC 14443-4 typu A dla aplikacji HCE. Typ B, typ F i technologie inne niżISO-DEP (np. MIFARE) są domyślnie kierowane do karty SIM.

Tylko urządzenia z systemem Windows 10 Mobile są włączone z funkcją emulacji karty. Emulacja kart opartych na protokole SIM i HCE nie jest dostępna w innych wersjach systemu Windows 10.

Architektura obsługi emulacji kart HCE i SIM jest pokazana na poniższym diagramie.

Architektura emulacji kart HCE i SIM

Wybór aplikacji i trasowanie AID

Aby opracować aplikację HCE, musisz zrozumieć, jak urządzenia z systemem Windows 10 Mobile kierują identyfikatory AID do określonej aplikacji, ponieważ użytkownicy mogą instalować wiele różnych aplikacji HCE. Każda aplikacja może zarejestrować wiele kart HCE i SIM.

Gdy użytkownik naciągnie swoje urządzenie z systemem Windows 10 Mobile do terminalu, dane są automatycznie kierowane do odpowiedniej aplikacji zainstalowanej na urządzeniu. Ten routing jest oparty na identyfikatorze apletu (AID), który jest identyfikatorem 5–16 bajtów. Podczas naciśnięcia terminal zewnętrzny będzie przesyłać polecenie SELECT APDU, aby określić AID, do których mają być kierowane wszystkie kolejne polecenia APDU. Kolejne polecenia SELECT ponownie zmienią routing. Na podstawie identyfikatorów AID zarejestrowanych przez aplikacje i ustawienia użytkownika ruch APDU jest kierowany do określonej aplikacji, która wyśle odpowiedź APDU. Pamiętaj, że terminal może chcieć komunikować się z kilkoma różnymi aplikacjami podczas tego samego naciśnięcia. Dlatego należy zadbać o to, by zadanie w tle aplikacji zakończyło się najszybciej, jak to możliwe po dezaktywacji, aby zwolnić miejsce dla zadania w tle innej aplikacji, które musi zareagować na APDU. W dalszej części tego tematu omówimy zadania w tle.

Aplikacje HCE muszą zarejestrować się z określonymi AID-ami, które mogą obsługiwać, aby otrzymywać jednostki APDU dla danego AID-u. Aplikacje deklarują identyfikatory AID przy użyciu grup AID. Grupa AID jest koncepcyjnie równoważna indywidualnej karcie fizycznej. Na przykład jedna karta kredytowa jest zadeklarowana z grupą AID, a druga karta kredytowa z innego banku jest zadeklarowana z inną, drugą grupą AID, mimo że obie mogą mieć tę samą AID.

Rozwiązywanie konfliktów dla grup wsparcia płatności

Gdy aplikacja rejestruje karty fizyczne (grupy AID), może zadeklarować kategorię grupy AID jako "Płatność" lub "Inne". Chociaż w danym momencie może istnieć wiele grup pomocy płatniczej, tylko jedna z tych grup pomocy płatniczej może być włączona dla opcji Tap i Pay w danym momencie, która jest wybierana przez użytkownika. Takie zachowanie istnieje, ponieważ użytkownik oczekuje, że będzie miał kontrolę nad świadomym wyborem jednej płatności za pomocą karty kredytowej lub debetowej, aby nie płacić inną, niezamierzoną kartą podczas przykładania urządzenia do terminala.

Jednak wiele grup AID zarejestrowanych jako "Inne" można włączyć jednocześnie bez interakcji z użytkownikiem. To zachowanie istnieje, ponieważ oczekuje się, że inne typy kart, takich jak lojalność, kupony lub tranzyt, będą działać po prostu bez wysiłku lub monitowania za każdym razem, gdy naciskają swój telefon.

Wszystkie grupy AID zarejestrowane jako "Płatność" są wyświetlane na liście kart na stronie Ustawienia NFC, gdzie użytkownik może wybrać domyślną kartę płatniczą. Po wybraniu domyślnej karty płatniczej aplikacja, która zarejestrowała tę grupę identyfikatorów płatności (AID), staje się domyślną aplikacją do płatności. Domyślne aplikacje do płatności mogą włączać lub wyłączać dowolne grupy AID bez interakcji z użytkownikiem. Jeśli użytkownik odrzuci domyślny monit aplikacji do płatności, bieżąca domyślna aplikacja do płatności (jeśli istnieje) będzie nadal domyślna. Poniższy zrzut ekranu przedstawia stronę Ustawienia NFC.

Zrzut ekranu przedstawiający stronę ustawień NFC

Korzystając z przykładowego zrzutu ekranu powyżej, jeśli użytkownik zmieni domyślną kartę płatniczą na inną kartę, która nie jest zarejestrowana przez aplikację HCE 1, system tworzy monit o potwierdzenie zgody użytkownika. Jeśli jednak użytkownik zmieni domyślną kartę płatniczą na inną kartę zarejestrowaną przez aplikację "Aplikacja HCE 1", system nie utworzy monitu o potwierdzenie dla użytkownika jako "Aplikacja HCE Application1" jest już domyślną aplikacją do płatności.

Rozwiązywanie konfliktów dla grup pomocy niepłatnej

Karty niepłatne sklasyfikowane jako "Inne" nie są wyświetlane na stronie ustawień NFC.

Aplikacja może tworzyć, rejestrować i włączać grupy pomocy niepłatnej w taki sam sposób jak grupy pomocy płatniczej. Główną różnicą jest to, że dla niepłatnych grup AID kategoria emulacji jest ustawiona na "Inne", w przeciwieństwie do "Płatność". Po zarejestrowaniu grupy AID w systemie należy włączyć grupę AID w celu odbierania ruchu NFC. Podczas próby umożliwienia grupie AID niebędących płatnościami odbioru ruchu, użytkownik nie jest proszony o potwierdzenie, chyba że wystąpi konflikt z jednym z identyfikatorów AID zarejestrowanych w systemie przez inną aplikację. Jeśli wystąpi konflikt, użytkownik zostanie poproszony o podanie informacji o tym, która karta i skojarzona aplikacja zostanie wyłączona, jeśli użytkownik zdecyduje się włączyć nowo zarejestrowaną grupę AID.

Współistnienie z aplikacjami NFC opartymi na protokole SIM

W systemie Windows 10 Mobile system konfiguruje tabelę routingu kontrolera NFC używaną do podejmowania decyzji dotyczących routingu w warstwie kontrolera. Tabela zawiera informacje o routingu dla następujących elementów.

  • Indywidualne trasy pomocy.
  • Trasa oparta o protokół (ISO-DEP).
  • Routing oparty na technologii (NFC-A/B/F).

Gdy czytnik zewnętrzny wysyła polecenie "SELECT AID", kontroler NFC najpierw sprawdza trasy AID w tabeli routingu pod kątem dopasowania. Jeśli nie ma dopasowania, użyje trasy opartej na protokole jako trasy domyślnej dla ruchu ISO-DEP (14443-4-A). W przypadku innych ruchów innych niżISO-DEP będzie korzystać z routingu opartego na technologii.

System Windows 10 Mobile udostępnia opcję menu "Karta SIM" na stronie Ustawienia NFC, aby nadal korzystać ze starszych aplikacji opartych na karcie SIM systemu Windows Phone 8.1, które nie rejestrują swoich identyfikatorów AID w systemie. Jeśli użytkownik wybierze "kartę SIM" jako domyślną kartę płatniczą, trasa ISO-DEP zostanie ustawiona na UICC, natomiast dla wszystkich innych opcji w menu rozwijanym trasa ISO-DEP skierowana jest do hosta.

Trasa ISO-DEP jest ustawiona na "Karta SIM" dla urządzeń, które mają kartę SIM z włączoną funkcją SE przy pierwszym uruchomieniu urządzenia z systemem Windows 10 Mobile. Gdy użytkownik zainstaluje aplikację z włączoną usługą HCE i aplikacja włączy rejestracje grup HCE AID, trasa ISO-DEP zostanie skierowana do hosta. Nowe aplikacje oparte na protokole SIM muszą zarejestrować identyfikatory AID w karcie SIM w celu wypełnienia określonych tras AID w tabeli routingu kontrolera.

Tworzenie aplikacji opartej na HCE

Aplikacja HCE ma dwie części.

  • Główna aplikacja pierwszego planu na potrzeby interakcji użytkownika.
  • Zadanie w tle uruchamiane przez system do przetwarzania APDU dla danego AID.

Ze względu na bardzo ścisłe wymagania dotyczące wydajności ładowania zadania w tle w odpowiedzi na naciśnięcie NFC zalecamy zaimplementowanie całego zadania w tle w kodzie natywnym C++/CX (w tym zależności, odwołań lub bibliotek, od których zależysz), a nie w języku C# lub zarządzanym kodzie. Mimo że język C# i kod zarządzany zwykle działają dobrze, istnieje obciążenie, takie jak ładowanie środowiska CLR platformy .NET, którego można uniknąć, zapisując go w języku C++/CX.

Utwórz i zarejestruj swoje zadanie w tle

Musisz utworzyć proces w tle w aplikacji HCE na potrzeby przetwarzania i odpowiadania na komendy APDU przekazywane do niej przez system. Podczas pierwszego uruchomienia aplikacji pierwszy plan rejestruje zadanie w tle HCE, które implementuje interfejs IBackgroundTaskRegistration, jak pokazano w poniższym kodzie.

var taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = bgTaskName;
taskBuilder.TaskEntryPoint = taskEntryPoint;
taskBuilder.SetTrigger(new SmartCardTrigger(SmartCardTriggerType.EmulatorHostApplicationActivated));
bgTask = taskBuilder.Register();

Zwróć uwagę, że wyzwalacz zadania jest ustawiony na SmartCardTriggerType. EmulatorHostApplicationActivated. Oznacza to, że za każdym razem, gdy system operacyjny otrzyma polecenie SELECT AID APDU skierowane do Twojej aplikacji, zostanie uruchomione zadanie w tle.

Odbieranie i reagowanie na jednostki APDU

Jeśli aplikacja ma docelową jednostkę APDU, system uruchomi zadanie w tle. Zadanie w tle odbiera APDU przekazywane przez obiekt SmartCardEmulatorApduReceivedEventArgs w właściwości CommandApdu i odpowiada na APDU przy użyciu metody TryRespondAsync tego samego obiektu. Rozważ utrzymanie zadania w tle dla prostych operacji ze względów wydajnościowych. Na przykład natychmiast odpowiedz na APDU i zakończ zadanie w tle po zamknięciu przetwarzania. Ze względu na charakter transakcji NFC użytkownicy mają tendencję do przechowywania swoich urządzeń na czytniku tylko przez bardzo krótki czas. Zadanie w tle będzie nadal odbierać ruch z czytnika do momentu dezaktywowania połączenia, w tym przypadku otrzymasz obiekt SmartCardEmulatorConnectionDeactivatedEventArgs. Połączenie można dezaktywować z następujących powodów, jak wskazano we właściwości SmartCardEmulatorConnectionDeactivatedEventArgs.Reason .

  • Jeśli połączenie zostanie dezaktywowane z wartością ConnectionLost, oznacza to, że użytkownik odsunął urządzenie od czytnika. Jeśli aplikacja wymaga, aby użytkownik przytrzymał dłużej terminal, warto rozważyć wyświetlenie informacji zwrotnej. Należy szybko zakończyć zadanie w tle (poprzez zakończenie odroczenia), aby upewnić się, że ponowne naciśnięcie nie będzie opóźnione przez oczekiwanie na zakończenie poprzedniego zadania w tle.
  • Jeśli połączenie jest dezaktywowane poprzez ConnectionRedirected, oznacza to, że terminal wysłał nowe polecenie SELECT AID APDU skierowane do innego identyfikatora aplikacji (AID). W takim przypadku aplikacja powinna natychmiast zamknąć zadanie w tle (przez zakończenie odroczenia), aby umożliwić uruchomienie innego zadania w tle.

Zadanie w tle powinno również zarejestrować się w anulowane zdarzeniew interfejsie IBackgroundTaskInstance, a także szybko zakończyć zadanie w tle (przez zakończenie odroczenia), ponieważ to zdarzenie jest uruchamiane przez system po zakończeniu zadania w tle. Poniżej znajduje się kod, który demonstruje zadanie w tle aplikacji HCE.

void BgTask::Run(
    IBackgroundTaskInstance^ taskInstance)
{
    m_triggerDetails = static_cast<SmartCardTriggerDetails^>(taskInstance->TriggerDetails);
    if (m_triggerDetails == nullptr)
    {
        // May be not a smart card event that triggered us
        return;
    }

    m_emulator = m_triggerDetails->Emulator;
    m_taskInstance = taskInstance;

    switch (m_triggerDetails->TriggerType)
    {
    case SmartCardTriggerType::EmulatorHostApplicationActivated:
        HandleHceActivation();
        break;

    case SmartCardTriggerType::EmulatorAppletIdGroupRegistrationChanged:
        HandleRegistrationChange();
        break;

    default:
        break;
    }
}

void BgTask::HandleHceActivation()
{
 try
 {
        auto lock = m_srwLock.LockShared();
        // Take a deferral to keep this background task alive even after this "Run" method returns
        // You must complete this deferral immediately after you have done processing the current transaction
        m_deferral = m_taskInstance->GetDeferral();

        DebugLog(L"*** HCE Activation Background Task Started ***");

        // Set up a handler for if the background task is cancelled, we must immediately complete our deferral
        m_taskInstance->Canceled += ref new Windows::ApplicationModel::Background::BackgroundTaskCanceledEventHandler(
            [this](
            IBackgroundTaskInstance^ sender,
            BackgroundTaskCancellationReason reason)
        {
            DebugLog(L"Cancelled");
            DebugLog(reason.ToString()->Data());
            EndTask();
        });

        if (Windows::Phone::System::SystemProtection::ScreenLocked)
        {
            auto denyIfLocked = Windows::Storage::ApplicationData::Current->RoamingSettings->Values->Lookup("DenyIfPhoneLocked");
            if (denyIfLocked != nullptr && (bool)denyIfLocked == true)
            {
                // The phone is locked, and our current user setting is to deny transactions while locked so let the user know
                // Denied
                DoLaunch(Denied, L"Phone was locked at the time of tap");

                // We still need to respond to APDUs in a timely manner, even though we will just return failure
                m_fDenyTransactions = true;
            }
        }
        else
        {
            m_fDenyTransactions = false;
        }

        m_emulator->ApduReceived += ref new TypedEventHandler<SmartCardEmulator^, SmartCardEmulatorApduReceivedEventArgs^>(
            this, &BgTask::ApduReceived);

        m_emulator->ConnectionDeactivated += ref new TypedEventHandler<SmartCardEmulator^, SmartCardEmulatorConnectionDeactivatedEventArgs^>(
                [this](
                SmartCardEmulator^ emulator,
                SmartCardEmulatorConnectionDeactivatedEventArgs^ eventArgs)
            {
                DebugLog(L"Connection deactivated");
                EndTask();
            });

  m_emulator->Start();
        DebugLog(L"Emulator started");
 }
 catch (Exception^ e)
 {
        DebugLog(("Exception in Run: " + e->ToString())->Data());
        EndTask();
 }
}

Tworzenie i rejestrowanie grup AID

Podczas pierwszego uruchamiania aplikacji podczas aprowizowania karty utworzysz i zarejestrujesz grupy AID w systemie. System określa aplikację, z którą zewnętrzny czytnik chce się komunikować, i odpowiednio kieruje jednostki APDU na podstawie zarejestrowanych AID oraz ustawień użytkownika.

Większość kart płatniczych jest rejestrowana dla tej samej AID, Proximity Payment System Environment (PPSE), wraz z dodatkowymi, specyficznymi dla sieci płatniczej identyfikatorami AID. Każda grupa AID reprezentuje kartę, a gdy użytkownik włączy kartę, wszystkie identyfikatory AID w grupie są włączone. Podobnie, gdy użytkownik dezaktywuje kartę, wszystkie identyfikatory AID w grupie są wyłączone.

Aby zarejestrować grupę AID, należy utworzyć obiekt SmartCardAppletIdGroup i ustawić jego właściwości, aby odzwierciedlić, że jest to karta płatnicza oparta na HCE. Nazwa wyświetlana powinna być opisowa dla użytkownika, ponieważ pojawi się w menu ustawień NFC oraz w komunikatach użytkownika. W przypadku kart płatniczych HCE właściwość SmartCardEmulationCategory powinna być ustawiona na Wartość Payment , a właściwość SmartCardEmulationType powinna być ustawiona na Wartość Host.

public static byte[] AID_PPSE =
        {
            // File name "2PAY.SYS.DDF01" (14 bytes)
            (byte)'2', (byte)'P', (byte)'A', (byte)'Y',
            (byte)'.', (byte)'S', (byte)'Y', (byte)'S',
            (byte)'.', (byte)'D', (byte)'D', (byte)'F', (byte)'0', (byte)'1'
        };

var appletIdGroup = new SmartCardAppletIdGroup(
                        "Example DisplayName",
                                new List<IBuffer> {AID_PPSE.AsBuffer()},
                                SmartCardEmulationCategory.Payment,
                                SmartCardEmulationType.Host);

W przypadku kart spoza płatności HCE właściwość SmartCardEmulationCategory powinna być ustawiona na wartość Inne, a właściwość SmartCardEmulationType powinna być ustawiona na wartość Host.

public static byte[] AID_OTHER =
        {
            (byte)'1', (byte)'2', (byte)'3', (byte)'4',
            (byte)'5', (byte)'6', (byte)'7', (byte)'8',
            (byte)'O', (byte)'T', (byte)'H', (byte)'E', (byte)'R'
        };

var appletIdGroup = new SmartCardAppletIdGroup(
                        "Example DisplayName",
                                new List<IBuffer> {AID_OTHER.AsBuffer()},
                                SmartCardEmulationCategory.Other,
                                SmartCardEmulationType.Host);

Można uwzględnić maksymalnie 9 identyfikatorów AID (o długości 5–16 bajtów każdy) na grupę AID.

Użyj metody RegisterAppletIdGroupAsync , aby zarejestrować grupę AID w systemie, która zwróci obiekt SmartCardAppletIdGroupRegistration . Domyślnie właściwość ActivationPolicy obiektu rejestracji jest ustawiona na wartość Wyłączone. Oznacza to, że mimo iż identyfikatory AID są zarejestrowane w systemie, nie zostały jeszcze aktywowane i nie będą odbierać ruchu.

reg = await SmartCardEmulator.RegisterAppletIdGroupAsync(appletIdGroup);

Zarejestrowane karty (grupy AID) można włączyć przy użyciu metody RequestActivationPolicyChangeAsync metodySmartCardAppletIdGroupRegistration, jak pokazano poniżej. Ponieważ w systemie można włączyć tylko jedną kartę płatniczą, ustawienie ActivationPolicy grupy płatności AID na Włączone jest takie samo jak ustawienie domyślnej karty płatniczej. Użytkownik zostanie poproszony o zezwolenie na tę kartę jako domyślną kartę płatniczą, niezależnie od tego, czy jest już wybrana domyślna karta płatnicza, czy nie. To stwierdzenie nie jest prawdziwe, jeśli Twoja aplikacja jest już domyślną aplikacją płatniczą i jedynie zmienia się między własnymi grupami AID. Możesz zarejestrować maksymalnie 10 grup AID na aplikację.

reg.RequestActivationPolicyChangeAsync(AppletIdGroupActivationPolicy.Enabled);

Możesz wysłać zapytanie do zarejestrowanych grup AID aplikacji przy użyciu systemu operacyjnego i sprawdzić ich zasady aktywacji przy użyciu metody GetAppletIdGroupRegistrationsAsync .

Użytkownicy będą monitowani po zmianie zasad aktywacji karty płatniczej z Wyłączone na Włączone, tylko wtedy, gdy aplikacja nie jest jeszcze domyślną aplikacją do płatności. Użytkownicy zostaną powiadomieni tylko po zmianie zasad aktywacji karty niepłatniczej z Wyłączone na Włączone, jeśli występuje konflikt AID.

var registrations = await SmartCardEmulator.GetAppletIdGroupRegistrationsAsync();
    foreach (var registration in registrations)
    {
registration.RequestActivationPolicyChangeAsync (AppletIdGroupActivationPolicy.Enabled);
    }

Powiadomienie o zdarzeniach po zmianie zasad aktywacji

W zadaniu w tle możesz zarejestrować się, aby otrzymywać zdarzenia, gdy polityka aktywacji jednej z rejestracji grupy AID zmienia się poza Twoją aplikacją. Na przykład użytkownik może zmienić domyślną aplikację płatności za pomocą menu ustawień NFC z jednej z kart na inną kartę hostowaną przez inną aplikację. Jeśli aplikacja musi wiedzieć o tej zmianie w celu konfiguracji wewnętrznej, takiej jak aktualizowanie aktywnych kafelków, możesz otrzymywać powiadomienia o tym zdarzeniu i podjąć odpowiednie działania w aplikacji.

var taskBuilder = new BackgroundTaskBuilder();
taskBuilder.Name = bgTaskName;
taskBuilder.TaskEntryPoint = taskEntryPoint;
taskBuilder.SetTrigger(new SmartCardTrigger(SmartCardTriggerType.EmulatorAppletIdGroupRegistrationChanged));
bgTask = taskBuilder.Register();

Zachowanie zastępowania pierwszego planu

Możesz zmienić ActivationPolicy dowolnej rejestracji grupy AID na ForegroundOverride, gdy aplikacja znajduje się na pierwszym planie bez monitowania użytkownika. Gdy użytkownik naciągnie swoje urządzenie do terminalu, gdy aplikacja znajduje się na pierwszym planie, ruch jest kierowany do aplikacji, nawet jeśli żadna z kart płatniczych nie została wybrana przez użytkownika jako domyślną kartę płatniczą. Po zmianie zasad aktywacji karty na ForegroundOverride ta zmiana jest tymczasowa tylko do momentu opuszczenia pierwszego planu przez aplikację i nie zmieni bieżącej domyślnej karty płatniczej ustawionej przez użytkownika. Możesz zmienić ActivationPolicy kart płatniczych lub niepłatniczych z aplikacji działającej na pierwszym planie w następujący sposób. Należy pamiętać, że metoda RequestActivationPolicyChangeAsync może być wywoływana tylko z aplikacji pierwszego planu i nie może być wywoływana z zadania w tle.

reg.RequestActivationPolicyChangeAsync(AppletIdGroupActivationPolicy.ForegroundOverride);

Ponadto można zarejestrować grupę AID składającą się z pojedynczej AID o długości 0, co spowoduje, że system będzie kierować wszystkie polecenia APDU niezależnie od AID, w tym wszystkie polecenia APDU wysłane przed odebraniem polecenia SELECT AID. Jednak taka grupa AID działa tylko wtedy, gdy aplikacja znajduje się na pierwszym planie, ponieważ można ją ustawić tylko na foregroundOverride i nie można ją trwale włączyć. Ponadto ten mechanizm działa zarówno dla wartości Host, jak i UICC w enumeracji SmartCardEmulationType, aby przekierować cały ruch do zadania w tle HCE lub do karty SIM.

public static byte[] AID_Foreground =
        {};

var appletIdGroup = new SmartCardAppletIdGroup(
                        "Example DisplayName",
                                new List<IBuffer> {AID_Foreground.AsBuffer()},
                                SmartCardEmulationCategory.Other,
                                SmartCardEmulationType.Host);
reg = await SmartCardEmulator.RegisterAppletIdGroupAsync(appletIdGroup);
reg.RequestActivationPolicyChangeAsync(AppletIdGroupActivationPolicy.ForegroundOverride);

Sprawdzanie obsługi technologii NFC i HCE

Aplikacja powinna sprawdzić, czy urządzenie ma sprzęt NFC, obsługuje funkcję emulacji kart i obsługuje emulację kart hosta przed oferowaniem takich funkcji użytkownikowi.

Funkcja emulacji kart inteligentnych NFC jest włączona tylko w systemie Windows 10 Mobile, więc próba użycia interfejsów API emulatora karty inteligentnej w innych wersjach systemu Windows 10 spowoduje błędy. Obsługę interfejsu API karty inteligentnej można sprawdzić w poniższym fragmencie kodu.

Windows.Foundation.Metadata.ApiInformation.IsTypePresent("Windows.Devices.SmartCards.SmartCardEmulator");

Ponadto możesz sprawdzić, czy urządzenie ma sprzęt NFC zdolny do emulacji karty, sprawdzając, czy metoda SmartCardEmulator.GetDefaultAsync zwraca wartość null. Jeśli tak, na urządzeniu nie jest obsługiwana emulacja kart NFC.

var smartcardemulator = await SmartCardEmulator.GetDefaultAsync();<

Obsługa routingu HCE i bazowanego na AID UICC jest dostępna tylko na niedawno wprowadzonych na rynek urządzeniach, takich jak Lumia 730, 830, 640 i 640 XL. Wszystkie nowe urządzenia obsługujące komunikację NFC z systemem Windows 10 Mobile i nowszych wersjach powinny obsługiwać technologię HCE. Aplikacja może sprawdzić obsługę HCE w następujący sposób.

Smartcardemulator.IsHostCardEmulationSupported();

Zachowanie ekranu blokady i wyłączania ekranu

System Windows 10 Mobile ma ustawienia emulacji kart na poziomie urządzenia, które można ustawić przez operatora sieci komórkowej lub producenta urządzenia. Domyślnie przełącznik "naciśnij, aby zapłacić" jest wyłączony, a zasada "włączania na poziomie urządzenia" jest ustawiona na "Always", chyba że wartości te zostaną nadpisane przez MO lub OEM.

Aplikacja może przeprowadzać zapytania dotyczące wartości EnablementPolicy na poziomie urządzenia i podejmować działania w każdym przypadku w zależności od pożądanego zachowania aplikacji w danym stanie.

SmartCardEmulator emulator = await SmartCardEmulator.GetDefaultAsync();

switch (emulator.EnablementPolicy)
{
case Never:
// you can take the user to the NFC settings to turn "tap and pay" on
await Windows.System.Launcher.LaunchUriAsync(new Uri("ms-settings-nfctransactions:"));
break;

 case Always:
return "Card emulation always on";

 case ScreenOn:
 return "Card emulation on only when screen is on";

 case ScreenUnlocked:
 return "Card emulation on only when screen unlocked";
}

Zadanie w tle Twojej aplikacji zostanie uruchomione nawet wtedy, gdy telefon jest zablokowany i/lub ekran jest wyłączony, ale tylko wtedy, gdy czytnik zewnętrzny wybierze AID przypisane do Twojej aplikacji. Możesz odpowiedzieć na polecenia czytelnika w zadaniu w tle, ale jeśli potrzebujesz danych wejściowych od użytkownika lub jeśli chcesz wyświetlić użytkownikowi komunikat, możesz uruchomić aplikację w pierwszym planie z określonymi argumentami. Zadanie działające w tle może uruchomić aplikację pierwszego planu z następującym zachowaniem.

  • Na ekranie blokady urządzenia (użytkownik zobaczy aplikację w tle dopiero po odblokowaniu urządzenia)
  • Nad ekranem blokady urządzenia (gdy użytkownik odrzuci aplikację, urządzenie jest nadal w stanie zablokowanym)
        if (Windows::Phone::System::SystemProtection::ScreenLocked)
        {
            // Launch above the lock with some arguments
            var result = await eventDetails.TryLaunchSelfAsync("app-specific arguments", SmartCardLaunchBehavior.AboveLock);
        }

Rejestracja AID i inne aktualizacje aplikacji opartych na karcie SIM

Aplikacje emulacji kart używające karty SIM jako bezpieczny element mogą zarejestrować się w usłudze systemu Windows w celu zadeklarowania identyfikatorów AID obsługiwanych na karcie SIM. Ta rejestracja jest bardzo podobna do rejestracji aplikacji opartej na technologii HCE. Jedyną różnicą jest SmartCardEmulationType, która powinna być ustawiona na wartość Uicc dla aplikacji opartych na protokole SIM. W wyniku rejestracji karty płatniczej nazwa wyświetlana karty zostanie również wypełniona w menu ustawień NFC.

var appletIdGroup = new SmartCardAppletIdGroup(
                        "Example DisplayName",
                                new List<IBuffer> {AID_PPSE.AsBuffer()},
                                SmartCardEmulationCategory.Payment,
                                SmartCardEmulationType.Uicc);