> For the complete documentation index, see [llms.txt](https://docs.payments.thalescloud.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.payments.thalescloud.io/nfc-wallet-sdk-android/es/implement-nfc-wallet/manage-digital-cards/display-digital-cards.md).

# Mostrar tarjetas digitales

## Resumen

Después de **Tokenización**, su **aplicación de billetera digital** debe mostrar el **usuario final** sus tarjetas digitales.

Proporcione una vista de lista y una vista de detalles.

Use el estado de la tarjeta, el arte de la tarjeta y los metadatos para impulsar la IU.

## Integración del SDK

### Use `DigitalizedCardManager` <a href="#digitalizedcardmanager" id="digitalizedcardmanager"></a>

Después de **Tokenización** completa, use `DigitalizedCardManager` para acceder al **inicialización del SDK NFC Wallet** datos persistentes y recuperar tarjetas digitales.

`DigitalizedCardManager` admite llamadas asíncronas y bloqueantes:

* `AsyncHandler`: Recibir resultados mediante callbacks.
* `AsyncToken`: Bloquear el hilo que llama hasta que la operación termine.

{% hint style="warning" %}
`AsyncToken` bloquea el hilo que llama. Evítelo en el hilo de la IU.
{% endhint %}

### Recuperar lista de tarjetas

Después de **Tokenización** completa, use `DigitalizedCardManager.getAllCards()` para recuperar todos los **IDs de tarjeta tokenizada**.

Para la diferencia entre identificadores, consulte [ID de tarjeta tokenizada frente a ID de tarjeta digital](#tokenized-card-id-versus-digital-card-id).

Los ejemplos a continuación muestran cómo recuperar IDs de tarjeta tokenizada con `AsyncHandler` y `AsyncToken`.

{% tabs %}
{% tab title="AsyncHandler" %}
{% code title="Recuperar IDs de tarjeta tokenizada usando AsyncHandler" %}

```java
// Instanciar un HandlerThread para evitar trabajo en el hilo de la IU.
HandlerThread cardDisplayThread = new HandlerThread("getAllCards");
cardDisplayThread.start();

Looper looper = cardDisplayThread.getLooper();

AbstractAsyncHandler<String[]> handler = new AbstractAsyncHandler<String[]>(looper) {
    @Override
    public void onComplete(AsyncResult<String[]> result) {
        if (result.isSuccessful()) {
            String[] tokenizedCardIds = result.getResult();
            // TODO: mostrar las tarjetas
        } else {
            // TODO: manejar error
        }
    }
};

DigitalizedCardManager.getAllCards(handler);
```

{% endcode %}
{% endtab %}

{% tab title="AsyncToken" %}
{% code title="Recuperar IDs de tarjeta tokenizada usando AsyncToken (bloqueante)" %}

```java
AsyncToken<String[]> token = DigitalizedCardManager.getAllCards(null);
AsyncResult<String[]> result = token.waitToComplete();

if (result.isSuccessful()) {
    String[] tokenizedCardIds = result.getResult();
    // TODO: mostrar las tarjetas
} else {
    // TODO: manejar error
}
```

{% endcode %}
{% endtab %}
{% endtabs %}

### ID de tarjeta tokenizada frente a ID de tarjeta digital <a href="#tokenized-card-id-versus-digital-card-id" id="tokenized-card-id-versus-digital-card-id"></a>

`DigitalizedCardManager` enumera y recupera tarjetas usando un **ID tokenizado de la tarjeta**.

`DigitalizedCard.getTokenizedCardID()` devuelve el **ID de tarjeta tokenizada.**

Este identificador no es el mismo que el **ID de tarjeta digital**.

{% hint style="warning" %}
El **inicialización del SDK NFC Wallet** usa dos identificadores para la misma tarjeta:

* **ID de tarjeta tokenizada**: Generado durante el aprovisionamiento seguro. También conocido como ID de token CPS. Consulte [Desencadenar aprovisionamiento](/nfc-wallet-sdk-android/es/implement-nfc-wallet/tokenize-a-card/trigger-provisioning.md).
* **ID de tarjeta digital**: Generado durante la digitalización. También conocido como ID de tarjeta MG. Consulte [Digitalizar una tarjeta](/nfc-wallet-sdk-android/es/implement-nfc-wallet/tokenize-a-card/digitize-a-card.md).
  {% endhint %}

Use estos métodos auxiliares para convertir identificadores:

* `DigitalizedCardManager.getDigitalCardId()`: Obtener el ID de tarjeta digital a partir de un ID de tarjeta tokenizada.
* `DigitalizedCardManager.getTokenizedCardId()`: Obtener el ID de tarjeta tokenizada a partir de un ID de tarjeta digital.

{% hint style="info" %}
Un TSP también proporciona su propio identificador de tarjeta digital.

Recupérelo en [Metadatos de la tarjeta](#card-metadata).

Úselo al solucionar problemas con el TSP (VTS/MDES).

Este identificador es diferente del ID de tarjeta tokenizada y del ID de tarjeta digital.
{% endhint %}

### Recuperar información de la tarjeta digital

#### Use `DigitalizedCard`

`DigitalizedCard` representa una tarjeta digitalizada y expone datos de la tarjeta, tales como:

* `DigitalizedCardStatus`
  * Estado de la tarjeta: `ACTIVA`, `SUSPENDIDA`
  * Estado de las claves de pago: Úselo para detectar necesidades de reabastecimiento.
* `DigitalizedCardDetails`
  * Últimos cuatro dígitos del FPAN
  * Últimos cuatro dígitos del DPAN
  * Fecha de expiración del FPAN
  * Red de pago (Visa, Mastercard, PURE)

Compruebe si una tarjeta tiene co-brand usando `DigitalizedCard.hasAuxiliaryScheme()`.

Recuperar un `DigitalizedCard` de `DigitalizedCardManager` usando el **ID tokenizado de la tarjeta**.

#### Metadatos de la tarjeta

Use `MGCardEnrollmentService.getCardMetaData()` y el **ID de tarjeta digital** para recuperar metadatos de la tarjeta, como:

* Nombre del emisor TSP
* ID de TSP (VTS, MDES u otro identificador)
* PAR (referencia de cuenta de pago)
* ID de tarjeta digital del TSP (`tokenId`)

Para la cobertura completa de campos, consulte la referencia de la API del SDK.

{% hint style="info" %}
ID de tarjeta digital del TSP (`tokenId`) se mapea a:

* Mastercard (MDES): `tokenUniqueReference`
* Visa (VTS): `tokenReferenceID`
  {% endhint %}

#### Arte de la tarjeta

Use `MobileGatewayManager.getCardArt()` y el **ID de tarjeta digital** para recuperar `CardArt`.

Use `CardArt.getBitmap()` para recuperar las imágenes de la tarjeta:

* `LOGO_DEL_BANCO`: Logo del emisor
* `FONDO_DE_TARJETA`: Fondo de la tarjeta
* `FONDO_DE_TARJETA_COMBINADO`: Fondo de la tarjeta combinado con la red de pago
* `ICONO_DE_TARJETA`: Ícono de la tarjeta

{% hint style="warning" %}
Recuperar el arte de la tarjeta desencadena solicitudes de red. Cachee las imágenes en el **aplicación de billetera digital**.
{% endhint %}

La aplicación de ejemplo demuestra un enfoque simple de cacheo local:

{% code title="Cachear arte de tarjeta localmente" %}

```java
public void getCardArt(final Context context, final String digitalCardId) {
    // Primero verifique si ya tenemos la imagen localmente.
    final byte[] imageBytes = readFromFile(context, digitalCardId);

    if (imageBytes.length > 0) {
        final Drawable image = new BitmapDrawable(
                context.getResources(),
                BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length)
        );
        // TODO: devolver la imagen
        return;
    }

    // Descargar datos del arte de la tarjeta desde el backend.
    final MobileGatewayManager gatewayManager = MobileGatewayManager.INSTANCE;
    try {
        final CardArt cardArt = gatewayManager.getCardArt(digitalCardId);
        cardArt.getBitmap(
                CardArtType.CARD_BACKGROUND_COMBINED,
                new AsyncHandlerCardBitmap(new AsyncHandlerCardBitmap.Delegate() {
                    @Override
                    public void onSuccess(final CardBitmap value) {
                        // Almacenar los datos actuales para uso futuro.
                        writeToFile(context, digitalCardId, value.getResource());

                        final Drawable image = new BitmapDrawable(
                                context.getResources(),
                                BitmapFactory.decodeByteArray(value.getResource(), 0, value.getResource().length)
                        );
                        // TODO: devolver la imagen
                    }

                    @Override
                    public void onError(final String error) {
                        // TODO: registrar error
                    }
                })
        );
    } catch (final NoSuchCardException exception) {
        // TODO: registrar error
    }
}
```

{% endcode %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.payments.thalescloud.io/nfc-wallet-sdk-android/es/implement-nfc-wallet/manage-digital-cards/display-digital-cards.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.