Interfejsy API eUICC

Na Androidzie 9 interfejsy API do zarządzania profilami (publiczne @SystemApi) są dostępne za pośrednictwem klasy EuiccManager. Komunikacja eUICC Interfejsy API (tylko @SystemApi) są dostępne za pośrednictwem klasy EuiccCardManager.

Informacje o eUICC

Operatorzy mogą tworzyć aplikacje operatora za pomocą EuiccManagera do zarządzania profilami, jak pokazano na ilustracji na rys. 1. Aplikacje operatora nie muszą być aplikacjami systemowymi, ale muszą korzystać z usług operatora uprawnienia przyznane przez profile eUICC. An Aplikacja LPA (LUI i LPA) backend), musi być aplikacją systemową (tzn. dodaną do obrazu systemu), aby wywołać @SystemApi.

Telefon z Androidem z aplikacją operatora i produktem LPA OEM

Rysunek 1. Telefony z Androidem z aplikacją operatora i produktem LPA OEM

Oprócz logiki wywoływania funkcji EuiccCardManager i rozmowy z eUICC, aplikacje LPA musi implementować te elementy:

  • Klient SM-DP+ komunikujący się z serwerem SM-DP+ w celu uwierzytelnienia pobierz profile
  • [Opcjonalnie] SM-DS, aby uzyskać więcej potencjalnych profili do pobrania
  • Obsługa powiadomień w celu wysyłania powiadomień do serwera zaktualizuj stan profilu
  • [Opcjonalnie] Zarządzanie przedziałami, w tym przełączanie się między kartami eSIM i pSIM. Jest to opcjonalne, jeśli telefon jest wyposażony tylko w chip eSIM.
  • eSIM OTA

Na telefonie z Androidem może znajdować się więcej niż 1 aplikacja LPA, ale tylko jedna można wybrać jako rzeczywistą działającą LPA na podstawie priorytetu zdefiniowanego w AndroidManifest.xml każdej aplikacji.

Użyj EuiccManagera

Interfejsy LPA API są publiczne w usłudze EuiccManager (w ramach pakietu) android.telephony.euicc). Aplikacja operatora może pobrać instancję EuiccManager, i wywołaj metody w EuiccManager, aby uzyskać informacje eUICC i zarządzać subskrypcji (określanych jako profile w dokumentach GSMA RSP) jako Instancje SubscriptionInfo.

Aby wywoływać publiczne interfejsy API, w tym pobierać, przełączać i usuwać subskrypcję aplikacja operatora musi mieć wymagane uprawnienia. Operator są dodawane przez operatora sieci komórkowej w metadanych profilu. (eUICC) Interfejs API odpowiednio wymusza reguły uprawnień operatora.

Platforma Androida nie obsługuje reguł zasad dotyczących profilu. Jeśli reguła zasad jest zadeklarowana w metadanych profilu, LPA może wybrać, jak obsłużyć pobierania i instalacji profilu. Na przykład możliwe, że tag zewnętrzna reklama LPA OEM do obsługi reguł zasad za pomocą specjalnego kodu błędu (błąd jest przekazywany do platformy z LPA OEM, a potem przekazuje do numeru LUI OEM).

Informacje na temat wielu włączonych interfejsów API profili znajdziesz w artykule Wiele włączonych profili

Interfejsy API

Poniższe interfejsy API można znaleźć w Dokumentacja referencyjna EuiccManager oraz EuiccManager.java

Pobranie instancji (publicznej)

Pobiera instancję EuiccManager do Context#getSystemService. Więcej informacji: getSystemService

EuiccManager mgr = (EuiccManager) context.getSystemService(Context.EUICC_SERVICE);

Sprawdzanie włączone (publiczne)

Sprawdza, czy osadzona subskrypcja jest włączona. To pole należy zaznaczyć przed uzyskaniem dostępu do interfejsów LPA API. Więcej informacji: isEnabled

boolean isEnabled = mgr.isEnabled();
if (!isEnabled) {
    return;
}

Pobierz EID (publiczny)

Pobiera identyfikator EID identyfikujący sprzęt eUICC. Może mieć wartość null, jeśli eUICC to nie jest gotowy. Rozmówca musi mieć uprawnienie operatora lub Uprawnienie READ_PRIVILEGED_PHONE_STATE. Więcej informacji: getEid

String eid = mgr.getEid();
if (eid == null) {
  // Handle null case.
}

Pobierz EuiccInfo (publiczne)

Pobiera informacje o eUICC. Zawiera ona wersję systemu operacyjnego. Więcej informacji: zobacz getEuiccInfo

EuiccInfo info = mgr.getEuiccInfo();
String osVer = info.getOsVersion();

Pobierz subskrypcję (publiczną)

Pobiera daną subskrypcję (określaną na GSMA RSP jako „profil”) dokumenty). Subskrypcję można utworzyć za pomocą kodu aktywacyjnego. Dla: na przykład kod aktywacyjny można przeanalizować z kodu QR. Pobieranie subskrypcja to operacja asynchroniczna.

Wywołujący musi mieć uprawnienie WRITE_EMBEDDED_SUBSCRIPTIONS lub mieć uprawnienia operatora na potrzeby subskrypcji docelowej. Więcej informacji: downloadSubscription

// Register receiver.
String action = "download_subscription";
BroadcastReceiver receiver =
        new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (!action.equals(intent.getAction())) {
                    return;
                }
                resultCode = getResultCode();
                detailedCode = intent.getIntExtra(
                    EuiccManager.EXTRA_EMBEDDED_SUBSCRIPTION_DETAILED_CODE,
                    0 /* defaultValue*/);
                resultIntent = intent;
            }
        };
context.registerReceiver(
        receiver,
        new IntentFilter(action),
        "example.broadcast.permission" /* broadcastPermission*/, null /* handler */);

// Download subscription asynchronously.
DownloadableSubscription sub =
        DownloadableSubscription.forActivationCode(code /* encodedActivationCode*/);
Intent intent = new Intent(action);
PendingIntent callbackIntent = PendingIntent.getBroadcast(
        getContext(), 0 /* requestCode */, intent, PendingIntent.FLAG_UPDATE_CURRENT);
mgr.downloadSubscription(sub, true /* switchAfterDownload */, callbackIntent);

Zmień subskrypcję (publiczną)

Przełącza na (włącza) daną subskrypcję. Osoba wywołująca musi mieć albo WRITE_EMBEDDED_SUBSCRIPTIONS lub masz uprawnienia operatora w przypadku obecnej włączonych i docelowych subskrypcji. Więcej informacji: switchToSubscription

// Register receiver.
String action = "switch_to_subscription";
BroadcastReceiver receiver =
        new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (!action.equals(intent.getAction())) {
                    return;
                }
                resultCode = getResultCode();
                detailedCode = intent.getIntExtra(
                    EuiccManager.EXTRA_EMBEDDED_SUBSCRIPTION_DETAILED_CODE, 0 /* defaultValue*/);
                resultIntent = intent;
            }
        };
context.registerReceiver(receiver, new IntentFilter(action),
        "example.broadcast.permission" /* broadcastPermission*/, null /* handler */);

// Switch to a subscription asynchronously.
Intent intent = new Intent(action);
PendingIntent callbackIntent = PendingIntent.getBroadcast(
        getContext(), 0 /* requestCode */, intent, PendingIntent.FLAG_UPDATE_CURRENT);
mgr.switchToSubscription(1 /* subscriptionId */, callbackIntent);

Przełącz subskrypcję z portem (publicznym)

(Dostępne na Androidzie 13) Przełącza na (włącza) danej subskrypcji z określonym indeksem portów. Rozmówca musi korzystać z sieci WRITE_EMBEDDED_SUBSCRIPTIONS lub korzystać z sieci operatora uprawnienia dotyczące obecnie włączonej i docelowej subskrypcji. Więcej informacji: switchToSubscription

// Register receiver.
String action = "switch_to_subscription";
BroadcastReceiver receiver =
        new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (!action.equals(intent.getAction())) {
                    return;
                }
                resultCode = getResultCode();
                detailedCode = intent.getIntExtra(
                    EuiccManager.EXTRA_EMBEDDED_SUBSCRIPTION_DETAILED_CODE, 0 /* defaultValue*/);
                resultIntent = intent;
            }
        };
context.registerReceiver(receiver, new IntentFilter(action),
        "example.broadcast.permission" /* broadcastPermission*/, null /* handler */);

// Switch to a subscription asynchronously.
Intent intent = new Intent(action);
PendingIntent callbackIntent = PendingIntent.getBroadcast(
        getContext(), 0 /* requestCode */, intent, PendingIntent.FLAG_UPDATE_CURRENT);
mgr.switchToSubscription(1 /* subscriptionId */, 0 /*portIndex*/, callbackIntent);

Czy port SIM jest dostępny (publiczny)

public boolean isSimPortAvailable(int portIndex)

(Dostępne w Androidzie 13) Zwraca, czy dostępny jest indeks portów. Port jest dostępny, jeśli nie ma włączonej subskrypcji lub aplikacja do połączeń ma uprawnienia operatora do subskrypcja zainstalowana na wybranym porcie. Więcej informacji: isSimPortAvailable

Usuń subskrypcję (publiczną)

Usuwa subskrypcję z jej identyfikatorem. Jeśli subskrypcja jest obecnie jest aktywne, najpierw zostaje wyłączone. Osoba wywołująca musi mieć jedną z tych Uprawnienia WRITE_EMBEDDED_SUBSCRIPTIONS lub operatora w przypadku celu subskrypcji. Więcej informacji: deleteSubscription

// Register receiver.
String action = "delete_subscription";
BroadcastReceiver receiver =
        new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (!action.equals(intent.getAction())) {
                    return;
                }
                resultCode = getResultCode();
                detailedCode = intent.getIntExtra(
                    EuiccManager.EXTRA_EMBEDDED_SUBSCRIPTION_DETAILED_CODE,
                    0 /* defaultValue*/);
                resultIntent = intent;
            }
        };
context.registerReceiver(receiver, new IntentFilter(action),
        "example.broadcast.permission" /* broadcastPermission*/,
        null /* handler */);

// Delete a subscription asynchronously.
Intent intent = new Intent(action);
PendingIntent callbackIntent = PendingIntent.getBroadcast(
        getContext(), 0 /* requestCode */, intent, PendingIntent.FLAG_UPDATE_CURRENT);
mgr.deleteSubscription(1 /* subscriptionId */, callbackIntent);

Wykasuj wszystkie subskrypcje (systemowy interfejs API)

Wymazuje wszystkie subskrypcje z urządzenia. Pierwsze kroki na Androidzie 11, musisz podać EuiccCardManager#ResetOption wartości wyliczeniowej określającej, czy usunąć wszystkie typy danych testowych, operacyjnych czy oba typy subskrypcji. Wywołujący musi mieć uprawnienie WRITE_EMBEDDED_SUBSCRIPTIONS.

// Register receiver.
String action = "delete_subscription";
BroadcastReceiver receiver =
        new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                if (!action.equals(intent.getAction())) {
                    return;
                }
                resultCode = getResultCode();
                detailedCode = intent.getIntExtra(
                    EuiccManager.EXTRA_EMBEDDED_SUBSCRIPTION_DETAILED_CODE,
                    0 /* defaultValue*/);
                resultIntent = intent;
            }
        };
context.registerReceiver(receiver, new IntentFilter(action),
        "example.broadcast.permission" /* broadcastPermission*/,
        null /* handler */);

// Erase all operational subscriptions asynchronously.
Intent intent = new Intent(action);
PendingIntent callbackIntent = PendingIntent.getBroadcast(
        getContext(), 0 /* requestCode */, intent, PendingIntent.FLAG_UPDATE_CURRENT);
mgr.eraseSubscriptions(
        EuiccCardManager.RESET_OPTION_DELETE_OPERATIONAL_PROFILES, callbackIntent);

Rozpocznij rozwiązywanie problemu (publiczne)

Rozpoczyna działanie, aby naprawić błąd, który może zostać rozwiązany przez użytkownika. Jeśli operacja zwraca EuiccManager#EMBEDDED_SUBSCRIPTION_RESULT_RESOLVABLE_ERROR, można użyć tej metody: aby zachęcić użytkownika do rozwiązania problemu. Tę metodę można wywołać tylko dla konkretnego błędu.

...
mgr.startResolutionActivity(getActivity(), 0 /* requestCode */, resultIntent, callbackIntent);

Stałe

Aby zobaczyć listę stałych public w funkcji EuiccManager, zobacz Stałe.