O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

APIs eUICC

Em Android 9, APIs de gerenciamento de perfil (públicas e @SystemApi) estão disponíveis através da classe EuiccManager . APIs de comunicação eUICC (somente @SystemApi) estão disponíveis através da classe EuiccCardManager .

Sobre eUICC

As operadoras podem fazer aplicativos de operadora usando EuiccManager para gerenciar perfis, conforme mostrado na Figura 1. Os aplicativos de operadora não precisam ser aplicativos do sistema, mas precisam ter privilégios de operadora concedidos por perfis eUICC. Um LPA aplicativo (Lui e LPA backend) precisa ser um aplicativo do sistema (ou seja, incluído na imagem do sistema) para chamar a @SystemApi.

Telefone Android com Carrier App e OEM LPA

Telefones Figura 1. Android com aplicativo transportadora e OEM LPA

Além da lógica de chamar EuiccCardManager e conversando com eUICC, apps LPA deve implementar o seguinte:

  • Cliente SM-DP + conversando com o servidor SM-DP + para autenticar e baixar perfis
  • [Opcional] SM-DS para obter mais perfis possíveis para download
  • Tratamento de notificações para enviar notificações ao servidor para atualizar o estado do perfil
  • [Opcional] Gerenciamento de slots, incluindo alternância entre a lógica eSIM e pSIM. Isso é opcional se o telefone tiver apenas um chip eSIM.
  • eSIM OTA

Apesar de mais de um aplicativo LPA pode estar presente em um telefone Android, apenas um LPA pode ser selecionado para ser o LPA de trabalho real com base na prioridade definida no AndroidManifest.xml arquivo de cada aplicativo.

Usando EuiccManager

As APIs LPA são públicos através EuiccManager (sob pacote android.telephony.euicc ). Um aplicativo portador pode obter a instância de EuiccManager , e chamar os métodos em EuiccManager para obter as informações eUICC e gerenciar assinaturas (referidas como perfis em documentos GSMA RSP) como instâncias SubscriptionInfo.

Para chamar APIs públicas, incluindo operações de download, troca e exclusão de assinatura, o aplicativo da operadora deve ter os privilégios necessários. Os privilégios da operadora são adicionados pela operadora móvel nos metadados do perfil. A API eUICC impõe as regras de privilégio da operadora de acordo.

A plataforma Android não lida com as regras de política de perfil. Se uma regra de política for declarada nos metadados do perfil, o LPA pode escolher como lidar com o download do perfil e o procedimento de instalação. Por exemplo, é possível para um OEM LPA de terceiros lidar com regras de política usando um código de erro especial (o código de erro é passado do OEM LPA para a plataforma e, em seguida, a plataforma passa o código para o OEM LUI).

APIs

As seguintes APIs podem ser encontrados na EuiccManager documentação de referência e EuiccManager.java .

Obter instância (público)

Obtém a instância de EuiccManager através Context#getSystemService .

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

Verificação habilitada (público)

Verifica se a assinatura incorporada está habilitada. Isso deve ser verificado antes de acessar as APIs LPA.

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

Obter EID (público)

Obtém o EID que identifica o hardware eUICC. Isso pode ser nulo se o eUICC não estiver pronto. O chamador deve ter privilégio transportador ou o READ_PRIVILEGED_PHONE_STATE permissão.

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

Obter EuiccInfo (público)

Obtém informações sobre o eUICC. Contém a versão do sistema operacional.

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

Baixar assinatura (público)

Faz o download da assinatura fornecida (referida como "perfil" nos documentos GSMA RSP). A assinatura pode ser criada a partir de um código de ativação. Por exemplo, um código de ativação pode ser analisado a partir de um código QR. O download de uma assinatura é uma operação assíncrona.

O chamador deve quer ter o WRITE_EMBEDDED_SUBSCRIPTIONS permissão ou ter privilégios transportadora para a assinatura de destino.

// 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);

Mudar de assinatura (público)

Alterna para (ativa) a assinatura fornecida. O chamador deve quer ter WRITE_EMBEDDED_SUBSCRIPTIONS ou ter privilégios transportadora para a atual habilitado subscrição e subscrição alvo.

// 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);

Excluir assinatura (pública)

Exclui uma assinatura com um ID de assinatura. Se a assinatura estiver atualmente ativa, ela será primeiro desabilitada. O chamador deve ter ou WRITE_EMBEDDED_SUBSCRIPTIONS ou privilégios transportadora para a assinatura de destino.

// 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);

Apagar todas as assinaturas (API do sistema)

Apaga todas as assinaturas em um dispositivo. A partir de Android 11, você deve fornecer uma EuiccCardManager#ResetOption valor de enumeração para especificar se pretende apagar todos os testes, operacional, ou ambos os tipos de assinaturas. O chamador deve ter WRITE_EMBEDDED_SUBSCRIPTIONS permissão.

// 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);

Iniciar atividade de resolução (público)

Inicia uma atividade para resolver um erro resolvido pelo usuário. Se uma operação retorna EuiccManager#EMBEDDED_SUBSCRIPTION_RESULT_RESOLVABLE_ERROR , este método pode ser chamado para solicitar ao usuário para resolver o problema. Este método só pode ser chamado uma vez para um erro específico.

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

Constantes

Para ver uma lista dos public constantes na EuiccManager , consulte Constantes .