> 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/make-payment/other-payment-methods/implement-dsrp-remote-payment.md).

# Implementar pago remoto DSRP

## Resumen

Use Mastercard Digital Secure Remote Payment (DSRP) para generar datos de pago para aceptación remota, como comercio electrónico.

En este flujo, su **aplicación de billetera digital** genera datos de pago. Usted pasa esos datos a su sistema de comerciante o pasarela de pago para autorización.

Antes de comenzar, complete **Tokenización**. Vea [Tokenizar una tarjeta](/nfc-wallet-sdk-android/es/implement-nfc-wallet/tokenize-a-card.md).

{% hint style="warning" %}
El SDK de billetera NFC admite el pago remoto DSRP para **Mastercard** tarjetas digitales con el **perfil MCBP 2.x** solamente.

Si necesita pago remoto DSRP para un perfil o red de pago diferente, contacte a su equipo de entrega de Thales.
{% endhint %}

## Integración del SDK

### Comprobar requisitos previos

Confirme que la tarjeta digital admite pago remoto DSRP usando `DigitalizedCardDetails.paymentTypeSupported()`. Esta API devuelve una lista de tipos de pago compatibles. Verifique que `PaymentType.DSRP` esté presente.

```java
public boolean isDsrpSupported(DigitalizedCardDetails card) {
    final PaymentType[] supported = card.paymentTypeSupported();

    for (PaymentType p : supported) {
        if (p == PaymentType.DSRP) {
            return true;
        }
    }
    return false;
}
```

### Cree los datos de entrada de pago DSRP

Crear `PaymentInputData`. Contiene los parámetros de la transacción utilizados para generar la carga útil de pago remoto DSRP.

Use `PaymentInputData.PaymentInputBuilder` con:

* `withRemotePaymentParameters` para proporcionar `amount` y `currencyCode`
* `withMCRemotePaymentParameters` para proporcionar `countryCode`, `transactionType`, `cryptogramDataType`, y `unpredictableNumber`

Use los siguientes valores de ejemplo como marcadores de posición.

```java
long amount = 11900; // unidades menores. Ejemplo: 119.00
char currencyCode = 702; // SGD (numérico ISO 4217)
char countryCode = 702; // Singapur (numérico ISO 3166-1)
TransactionType transactionType = TransactionType.PURCHASE;
long unpredictableNumber = 12345;
PaymentInputData paymentInputData = new PaymentInputData.PaymentInputBuilder(PaymentType.DSRP)
                .withRemotePaymentParameters(amount, currencyCode)
                .withMCRemotePaymentParameters(countryCode, transactionType, CryptogramDataType.DE55, unpredictableNumber)
                .build();
```

`PaymentInputData` para el pago DSRP tiene los siguientes campos:

| Campo                 | Tipo            | Formato                                               | Requisito | Descripción                                                                                                        |
| --------------------- | --------------- | ----------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------ |
| `amount`              | `long`          | Numérico, unidades menores                            | Requerido | Establezca el monto de la transacción en unidades menores (sin separador decimal). Ejemplo: 119.00 USD es `11900`. |
| `currencyCode`        | `char` (entero) | numérico ISO 4217 de 3 dígitos                        | Requerido | Establezca el código de moneda de la transacción. Ejemplo: USD es `840`.                                           |
| `countryCode`         | `char` (entero) | numérico ISO 3166-1 de 3 dígitos                      | Requerido | Establezca el código de país del comerciante. Ejemplo: Estados Unidos es `840`.                                    |
| `transactionType`     | Enum            | `TransactionType.PURCHASE`                            | Requerido | Establezca el tipo de transacción financiera. Para pagos remotos DSRP, use `TransactionType.PURCHASE`.             |
| `cryptogramDataType`  | Enum            | `CryptogramDataType.UCAF` o `CryptogramDataType.DE55` | Requerido | Establezca el formato de criptograma devuelto por el SDK.                                                          |
| `unpredictableNumber` | `long`          | Numérico                                              | Requerido | Proporcione un número aleatorio generado por el comerciante o la pasarela de pago.                                 |

### Genere un criptograma de pago remoto

En su aplicación de billetera digital, llame a `PaymentBusinessService.generateApplicationCryptogram()` con `PaymentType.DSRP` para generar datos de pago para aceptación remota (por ejemplo, comercio electrónico).

Debe implementar un `RemotePaymentServiceListener`.

```java
final PaymentBusinessService pbs = PaymentBusinessManager.getPaymentBusinessService();
pbs.generateApplicationCryptogram(
        PaymentType.DSRP, 
        paymentInputData, 
        remotePaymentServiceListener);
```

### Implemente `RemotePaymentServiceListener`

El listener de pago remoto maneja eventos durante la generación del criptograma DSRP.

El listener tiene tres callbacks:

* `onAuthenticationRequired`

  El SDK indica que se requiere verificación CDCVM. Vea [Realizar la verificación CDCVM](/nfc-wallet-sdk-android/es/implement-nfc-wallet/make-payment/implement-contactless-payments/5.-perform-cdcvm-verification.md).
* `onDataReadyForPayment`

  Los datos de salida de pago remoto están listos. Recupérelos usando `PaymentService.getRemotePaymentData()`.

  Desactive el servicio de pago después de recuperar los datos. Si omite la desactivación, la siguiente generación puede fallar con `REMOTE_PAYMENT_WRONG_STATE`.
* `onError`

  El SDK encontró una falla durante la generación de pago remoto.

  Desactive el servicio de pago para restablecer el estado antes de reintentar.

El siguiente fragmento de código muestra una implementación básica del listener:

{% code expandable="true" %}

```java
public class MyRemotePaymentPaymentServiceListener implements RemotePaymentServiceListener{
    /**********************************************************/
    /*                Listener del Servicio de Pago                */
    /**********************************************************/
    @Override
    public void onAuthenticationRequired(PaymentService paymentService, CHVerificationMethod chVerificationMethod, long cvmResetTimeout) {
        toggleProgress(false);
        if (chVerificationMethod == CHVerificationMethod.BIOMETRICS
                || chVerificationMethod == CHVerificationMethod.DEVICE_KEYGUARD) {
            Intent intent = new Intent(this, DeviceCVMActivity.class);
            intent.putExtra(DeviceCVMActivity.EXTRA_CVM, chVerificationMethod);
            overridePendingTransition(0, 0);
            startActivityForResult(intent, REQ_CODE_FINGERPRINT);
        } else {
            // NOTA: No se admiten otros métodos de verificación
            AppLogger.e(TAG, "¡Método de verificación " + chVerificationMethod + " no soportado actualmente!");
            deactivatePaymentService();
        }
    }

    @Override
    public void onDataReadyForPayment(PaymentService paymentService, TransactionContext transactionContext) {
        toggleProgress(false);
        RemotePaymentOutputData remotePaymentData = paymentService.getRemotePaymentData();
        Toast.makeText(this, " Los datos de pago DSRP son " +remotePaymentData.getCryptogramData(), Toast.LENGTH_LONG).show();
        deactivatePaymentService();
    }

    @Override
    public void onError(SDKError<PaymentServiceErrorCode> sdkPaymentServiceErrorCode) {
        AppLogger.e(TAG, "Error al generar datos de pago DSRP con el código de error " + sdkPaymentServiceErrorCode.getErrorCode());
        Toast.makeText(this, "Error al generar datos de pago DSRP con el código de error " + sdkPaymentServiceErrorCode.getErrorCode(), Toast.LENGTH_SHORT).show();
        deactivatePaymentService();
    }
}
```

{% endcode %}

Pase su instancia de listener cuando llame a `generateApplicationCryptogram(...)`.

### Obtener datos de pago DSRP

Obtener `RemotePaymentOutputData` cuando `RemotePaymentServiceListener.onDataReadyForPayment()` se desencadena.

`RemotePaymentOutputData` contiene los siguientes campos.

| Campo                  | Descripción                                                                                                                 |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------- |
| `cryptogramData`       | Array de bytes que contiene la respuesta formateada. Esto es ya sea datos UCAF o TLV para que el comerciante rellene DE-55. |
| `dpan`                 | DPAN con cualquier `F` relleno eliminado (si está presente).                                                                |
| `dpanSequenceNumber`   | Número de secuencia DPAN (PSN) de la tarjeta utilizada.                                                                     |
| `track2EquivalentData` | Datos equivalentes a Pista 2, según ISO/IEC 7813, excluyendo el centinela de inicio, el centinela de fin y LRC.             |
| `PAR`                  | Referencia de cuenta de pago (PAR), si la proporciona la red de pago.                                                       |
| `dPanexpirationDate`   | Fecha de expiración del DPAN.                                                                                               |
| `cryptogramDataType`   | Formato de criptograma devuelto (`UCAF` o `DE55`).                                                                          |

`track2EquivalentData` incluye:

* Número de Cuenta Primario
* Separador de campo (hex `D`)
* Fecha de expiración (`YYMM`)
* Código de servicio
* Datos discrecionales (definidos por la red de pago)
* Relleno opcional con hex `F` para alinear a un byte completo

### Manejar errores

Cuando `RemotePaymentServiceListener.onError(...)` se activa, el SDK proporciona un `PaymentServiceErrorCode`.

Siempre llame a `PaymentBusinessService.deactivate()` en `onError(...)` para restablecer el estado del servicio de pago antes de reintentar.

`PaymentBusinessService.generateApplicationCryptogram(...)` lanza `IllegalArgumentException` si `paymentInputData` es `null` o si el listener es `null`.

| Código de error del servicio de pago | Descripción                                                               | Acción recomendada                                                                                                               |
| ------------------------------------ | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| REMOTE\_PAYMENT\_WRONG\_STATE        | El servicio de pago ya está activado al intentar realizar un pago remoto. | Llamar `PaymentBusinessService.deactivate()` después de cada generación. Llámelo cuando el usuario final cancele CDCVM.          |
| REMOTE\_PAYMENT\_OUTPUT\_INVALID     | Los datos de salida no se pueden analizar y no están disponibles.         | Reintente la transacción.                                                                                                        |
| REMOTE\_PAYMENT\_NOT\_SUPPORTED      | La tarjeta predeterminada no admite pago remoto.                          | Compruebe `DigitalizedCardDetails.paymentTypeSupported()` antes del pago. Use una tarjeta digital que admita `PaymentType.DSRP`. |
| REMOTE\_PAYMENT\_INPUT\_INVALID      | Los datos de entrada existen pero algunos campos no son válidos.          | Reconstruya `PaymentInputData` con valores válidos. Asegúrese de que todos los campos requeridos estén establecidos.             |
| NO\_DEFAULT\_CARD                    | No hay una tarjeta predeterminada.                                        | Establezca una tarjeta predeterminada antes de generar un criptograma.                                                           |
| CARD\_OUT\_OF\_PAYMENT\_KEYS         | No hay credenciales de pago disponibles.                                  | Reabastezca las credenciales de pago antes de volver a intentarlo.                                                               |


---

# 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, and the optional `goal` query parameter:

```
GET https://docs.payments.thalescloud.io/nfc-wallet-sdk-android/es/implement-nfc-wallet/make-payment/other-payment-methods/implement-dsrp-remote-payment.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
