API eUICC

In Android 9, le API di gestione dei profili (pubbliche e @SystemApi) sono disponibili tramite il corso EuiccManager. Comunicazione eUICC Le API (solo @SystemApi) sono disponibili tramite il corso EuiccCardManager.

Informazioni sull'eUICC

Gli operatori possono creare le app dell'operatore utilizzando EuiccManager per gestire i profili, come mostrato come mostrato nella Figura 1. Le app dell'operatore non devono necessariamente essere app di sistema, ma devono avere un operatore i privilegi concessi dai profili eUICC. Un App LPA (LUI e LPA backend) deve essere un'app di sistema (ad esempio inclusa nell'immagine di sistema) da chiamare @SystemApi.

Telefono Android con app operatore e LPA OEM

Figura 1. Smartphone Android con app dell'operatore e LPA OEM

Oltre alla logica per chiamare EuiccCardManager e parlare con eUICC, le app LPA deve implementare quanto segue:

  • Client SM-DP+ che interagisce con il server SM-DP+ per autenticare e scarica profili
  • [Facoltativo] SM-DS per ottenere altri potenziali profili scaricabili
  • Gestione delle notifiche per l'invio di notifiche al server a aggiorna lo stato del profilo
  • [Facoltativo] Gestione degli slot, incluso il passaggio dalla logica eSIM a pSIM e viceversa. Questa operazione è facoltativa se lo smartphone ha solo un chip eSIM.
  • OTA eSIM

Sebbene in uno smartphone Android possano essere presenti più app LPA, solo un LPA può essere selezionato come LPA funzionante in base alla priorità definita il file AndroidManifest.xml di ogni app.

Utilizzare EuiccManager

Le API LPA sono pubbliche fino al giorno EuiccManager (nel pacchetto android.telephony.euicc). Un'app dell'operatore può recuperare l'istanza di EuiccManager, e chiamare i metodi in EuiccManager per ottenere le informazioni eUICC e gestire abbonamenti (indicati come profili nei documenti RSP GSMA) con SubscriptionInfo.

Per chiamare le API pubbliche, inclusi download, cambio ed eliminazione dell'abbonamento. operazioni, l'app dell'operatore deve disporre dei privilegi necessari. Corriere vengono aggiunti dall'operatore di telefonia mobile nei metadati del profilo. eUICC L'API applica le regole relative ai privilegi dell'operatore di conseguenza.

La piattaforma Android non gestisce le regole dei criteri del profilo. Se una regola del criterio viene dichiarato nei metadati del profilo, l'LPA può scegliere come la procedura di download e installazione del profilo. Ad esempio, è possibile che un LPA dell'OEM di terze parti per gestire le regole dei criteri utilizzando un codice di errore speciale (l'errore il codice viene trasmesso dall'LPA dell'OEM alla piattaforma, che poi trasmette il codice alla LUI dell'OEM).

Per informazioni sulle API di più profili abilitate, consulta Più profili abilitati.

API

Le API riportate di seguito sono disponibili nella Documentazione di riferimento di EuiccManager e EuiccManager.java.

Ottieni istanza (pubblica)

Ottiene l'istanza di EuiccManager tramite Context#getSystemService. Per maggiori dettagli, vedi getSystemService

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

Seleziona abilitata (pubblica)

Controlla se l'abbonamento incorporato è abilitato. Questa opzione deve essere selezionata prima di accedere alle API LPA. Per maggiori dettagli, vedi isEnabled

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

Ottieni EID (pubblico)

Recupera l'EID che identifica l'hardware eUICC. Potrebbe essere null se la eUICC è non è pronta. Il chiamante deve disporre dei privilegi di operatore o Autorizzazione READ_PRIVILEGED_PHONE_STATE. Per maggiori dettagli, vedi getEid

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

Ottieni EuiccInfo (pubblico)

Recupera informazioni sulla eUICC. Questo file contiene la versione del sistema operativo. Per maggiori dettagli, vedi getEuiccInfo

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

Scarica abbonamento (pubblico)

Scarica l'abbonamento specificato (indicato come "profilo" in GSMA RSP) documenti). L'abbonamento può essere creato da un codice di attivazione. Per Ad esempio, un codice di attivazione può essere analizzato da un codice QR. Il download di un è un'operazione asincrona.

Il chiamante deve disporre dell'autorizzazione WRITE_EMBEDDED_SUBSCRIPTIONS oppure Disporre dei privilegi dell'operatore per l'abbonamento di destinazione. Per maggiori dettagli, vedi 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);

Cambia abbonamento (pubblico)

Imposta su (attiva) l'abbonamento specificato. Il chiamante deve avere WRITE_EMBEDDED_SUBSCRIPTIONS o disponi dei privilegi dell'operatore per l'attuale e la sottoscrizione di destinazione. Per maggiori dettagli, vedi 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);

Cambia abbonamento con porta (pubblica)

(Disponibile da Android 13) Passa a (attiva) la sottoscrizione specificata con l'indice di porta specificato. Il chiamante deve avere WRITE_EMBEDDED_SUBSCRIPTIONS o un operatore privilegi per l'abbonamento attualmente abilitato e l'abbonamento di destinazione. Per maggiori dettagli, vedi 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);

La porta della SIM è disponibile (pubblica)

public boolean isSimPortAvailable(int portIndex)

(Disponibile da Android 13) Indica se la proprietà è disponibile l'indice di portabilità di passaggio. Una porta è disponibile se non ha l'abbonamento attivo o l'app per le chiamate ha il privilegio di operatore su abbonamento installato sulla porta selezionata. Per maggiori dettagli, vedi isSimPortAvailable

Elimina sottoscrizione (pubblica)

Elimina una sottoscrizione con un ID abbonamento. Se l'abbonamento è attualmente viene prima disattivato. Il chiamante deve avere WRITE_EMBEDDED_SUBSCRIPTIONS o privilegi dell'operatore per il target abbonamento. Per maggiori dettagli, vedi 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);

Cancellare tutti gli abbonamenti (API di sistema)

Cancella tutti gli abbonamenti su un dispositivo. A partire da Android 11, devi fornire un EuiccCardManager#ResetOption enum per specificare se cancellare tutti i tipi di test, operativi o entrambi abbonamenti. Il chiamante deve avere l'autorizzazione 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);

Avvia attività di risoluzione (pubblico)

Avvia un'attività per risolvere un errore risolvibile dall'utente. Se un'operazione restituisce EuiccManager#EMBEDDED_SUBSCRIPTION_RESULT_RESOLVABLE_ERROR, questo metodo può essere per chiedere all'utente di risolvere il problema. Questo metodo può essere chiamato solo una volta per un determinato errore.

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

Costanti

Per visualizzare un elenco delle costanti public in EuiccManager, consulta Costanti.