> 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/merchant-tokenization/es/taf-de-mastercard/implement-taf/create-device-binding.md).

# Crear vinculación del dispositivo

Mastercard Token Authentication Framework (TAF) comienza con la vinculación del dispositivo.

Requisitos previos:

* La tarjeta ya ha completado la tokenización. El comerciante ya tiene un `srcDigitalTokenId` del backend de Thales.
* El dispositivo admite autenticación del dispositivo, como huella dactilar o Face ID.

Antes de vincular el token al dispositivo, el backend del emisor autentica al usuario final (ID\&V). El backend del emisor envía un OTP al usuario final. El usuario final introduce el OTP en la aplicación del comerciante.

## La aplicación del comerciante inicia el flujo de crear vinculación

<figure><img src="/files/302ddaa318d71a69e0cb3efe16c4b0653e2c1adc" alt=""><figcaption><p>Iniciar un flujo de vinculación.</p></figcaption></figure>

<table><thead><tr><th width="100">Paso</th><th>Descripción</th></tr></thead><tbody><tr><td>1-2</td><td>El usuario final (a través de la aplicación del comerciante) inicia el flujo de ID&#x26;V llamando al SDK de Thales con <code>tokenId</code> y un nuevo <code>correlationId</code> (para solucionar problemas).</td></tr><tr><td>3-7</td><td>El SDK de Thales llama al backend de Thales, que llega a Mastercard para recuperar los métodos de ID&#x26;V disponibles.</td></tr><tr><td>8-9</td><td>La aplicación del comerciante muestra los métodos de ID&#x26;V disponibles y pide al usuario final que seleccione uno. Las opciones son SMS o correo electrónico.</td></tr></tbody></table>

Puede recuperar la lista de métodos de ID\&V desde el `IDVSession` objeto.

{% tabs %}
{% tab title="Android" %}
Use el `IDVSession` objeto para llamar a `getIdvMethods` para obtener la lista de `ID&V` métodos admitidos.

```java
public void createBinding(@NonNull MastercardTAFHelper mastercardTAFHelper, @NonNull String tokenID, @NonNull String correlationID) {

    mastercardTAFHelper.createBinding(tokenID,
            correlationID,
            new TokenBindingListener() {

                @Override
                public void onIssuerAuthenticationReady(@NonNull IDVSession idvSession) {

                }

                @Override
                public void onIssuerAuthenticationRequired(IDVSession idvSession) {
                    // Obtener la lista de métodos de idv
                    List<IDVMethod> idvMethods = idvSession.getIdvMethods();
                }

                @Override
                public void onIssuerAuthenticationError(@NonNull IDVSession pendingBindingSession, TMGClientException tmgClientException) {
                    // Comprobar el error o reintentar
                }

                @Override
                public void onDeviceAuthentication(DeviceAuthentication deviceAuthentication) {
                    // Realizar autenticación del dispositivo usando biometría
                }

                @Override
                public void onSuccess() {
                    // Gestionar la interfaz de usuario del éxito de crear vinculación
                }

                @Override
                public void onError(TMGClientException exception) {
                    // Comprobar si hay algún error
                }
            });
}
```

{% endtab %}

{% tab title="iOS" %}
Use el `IDVSession` objeto para llamar a `idvMethods` para obtener la lista de `ID&V` métodos admitidos.

```swift
// La clase singleton para almacenar las propiedades requeridas para el flujo de Mastercard
class MastercardService {
    static var shared = MastercardService()
    var idvSession: MastercardTAFHelper.IDVSession? = nil
    var completionHandler: ((MastercardTAFHelper.IDVSession?, TMGError?) -> Void)? = nil
}

let tokenID: String = ""
let correlationID: String = ""
// Iniciar crear vinculación
mastercardTAFHelper.createBinding(forTokenID: tokenID, correlationID: correlationID, 
    idvSessionHandler: { idvSession in
        // guardar la sesión idv localmente
        MastercardService.shared.idvSession = idvSession
        // Lista de métodos de idv
        let methods = idvSession.idvMethods
        // Mostrar los métodos de idv al usuario
    },
    deviceAuthenticationHandler: { auth in
        // Face ID
        let customMessage = "" // Introduzca el mensaje personalizado. p. ej.: "Autentíquese con Face ID"
        auth.startAuthentication(withMessage: customMessage)
    }, 
    completionHandler: { session, error in
        // guardar el controlador de finalización localmente
        MastercardService.shared.completionHandler?(session, error)
        // vinculación exitosa
        if error == nil {
            
        }
        // Gestionar el error o reintentar la sesión idv cuando haya un fallo
    }
)
```

{% endtab %}
{% endtabs %}

## Selección del usuario final y envío del OTP <a href="#end-user-selection-and-otp-sending" id="end-user-selection-and-otp-sending"></a>

<figure><img src="/files/9f112b646538d24e38f707fcb41c0da22a6e6db7" alt=""><figcaption><p>El usuario final selecciona un método de ID&#x26;V y recibe el OTP.</p></figcaption></figure>

| Paso | Descripción                                                                                                                                                                             |
| ---- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 1-2  | El usuario final selecciona un método de ID\&V. La aplicación del comerciante proporciona la selección al SDK de Thales.                                                                |
| 3-7  | El SDK de Thales llama al backend de Thales, que llega a Mastercard, para generar un OTP. El backend del emisor envía entonces el OTP al usuario final a través del canal seleccionado. |

{% tabs %}
{% tab title="Android" %}

```java
public void selectIDVMethod(@NonNull MastercardTAFHelper mastercardTAFHelper, @NonNull String tokenID, @NonNull String correlationID, @NonNull FragmentActivity activity) {
    mastercardTAFHelper.createBinding(tokenID,
            correlationID,
            new TokenBindingListener() {

                @Override
                public void onIssuerAuthenticationReady(@NonNull IDVSession idvSession) {
                    // validar OTP
                }

                @Override
                public void onIssuerAuthenticationRequired(IDVSession idvSession) {
                    // Obtener la lista de métodos de idv
                    List<IDVMethod> idvMethods = idvSession.getIdvMethods();

                    // Enviar el método de idv seleccionado
                    IDVMethod selectedIdvMethod = idvMethods.get(0);
                    idvSession.selectIDVMethod(selectedIdvMethod);
                }

                @Override
                public void onIssuerAuthenticationError(@NonNull IDVSession pendingBindingSession, TMGClientException tmgClientException) {
                    // Comprobar el error o reintentar
                }

                @Override
                public void onDeviceAuthentication(DeviceAuthentication deviceAuthentication) {
                    // Realizar autenticación del dispositivo usando biometría
                }

                @Override
                public void onSuccess() {
                    // Gestionar la interfaz de usuario del éxito de crear vinculación
                }

                @Override
                public void onError(TMGClientException exception) {
                    // Comprobar si hay algún error
                }
            });
}
```

{% endtab %}

{% tab title="iOS" %}

```swift
guard let idvSession = MastercardService.shared.idvSession else {
    // no hay sesión idv
    return
}
// 1. Mostrar la lista de métodos de idv
do {
    let idvMethods = try idvSession.idvMethods
    let selectedIdvMethod = idvMethods[0] // el usuario selecciona 1 de los métodos de idv disponibles
    
    // 2. enviar el método de idv
    idvSession.selectIDVMethod(selectedIdvMethod) {
        // 3. mostrar la página para introducir el valor del OTP
    }
} catch let error {
    // gestionar el error
}
        
// 4. El fallo en el paso 2, selectIDVMethod, se gestionará en completionHandler.
MastercardService.shared.completionHandler = { (session, error) in
    // 5. Comprobar si es un error de selectIDVMethod.
    if let session = session,
        let error = error,
        error.description == TMGError.invalidIdvMethod.description {
        MastercardService.shared.idvSession = session
        // 6. Reintentar el flujo de IDV.
    }
}
```

{% endtab %}
{% endtabs %}

El SDK devuelve el resultado de la activación de la vinculación a través de `onSuccess` o `onIssuerAuthenticationError`. Si la activación falla, conserve la `IDVSession` instancia devuelta en `onIssuerAuthenticationError`. Úsela para reintentar el flujo de ID\&V.

## Verificación del OTP

<figure><img src="/files/03ffd9f17bfe577683bd750bae8a30bd38537dd7" alt=""><figcaption></figcaption></figure>

<table><thead><tr><th width="100">Paso</th><th>Descripción</th></tr></thead><tbody><tr><td>1-2</td><td>El usuario final introduce el OTP en la aplicación del comerciante, que lo envía al SDK de Thales.</td></tr><tr><td>3-7</td><td>El SDK transmite de forma segura el OTP a Mastercard para su verificación y luego devuelve el resultado a la aplicación del comerciante.</td></tr></tbody></table>

{% tabs %}
{% tab title="Android" %}

```java
public void validateOTP(@NonNull MastercardTAFHelper mastercardTAFHelper, @NonNull String tokenID, @NonNull String correlationID, @NonNull FragmentActivity activity) {
    mastercardTAFHelper.createBinding(tokenID,
            correlationID,
            new TokenBindingListener() {

                @Override
                public void onIssuerAuthenticationReady(@NonNull IDVSession idvSession) {
                    // Activar vinculación
                    String otp = "12345";
                    idvSession.validateOTP(otp);

                }

                @Override
                public void onIssuerAuthenticationRequired(IDVSession idvSession) {
                    // Obtener la lista de métodos de idv
                }

                @Override
                public void onIssuerAuthenticationError(@NonNull IDVSession pendingBindingSession, TMGClientException tmgClientException) {
                    // Comprobar el error o reintentar
                }

                @Override
                public void onDeviceAuthentication(DeviceAuthentication deviceAuthentication) {
                    // Realizar autenticación del dispositivo usando biometría
                    CharSequence title = "title"; // título que se mostrará en la ventana emergente de autenticación biométrica.
                    CharSequence subTitle = "subTitle"; // subtítulo que se mostrará en la ventana emergente de autenticación biométrica.
                    CharSequence description = "description"; // descripción que se mostrará en la ventana emergente de autenticación biométrica.
                    CharSequence negativeButtonText = "negativeButtonText"; // texto del botón negativo que se mostrará en la ventana emergente de autenticación biométrica.
                    deviceAuthentication.startAuthentication(activity,
                            title,
                            subTitle,
                            description,
                            negativeButtonText);
                }

                @Override
                public void onSuccess() {
                    // Gestionar la interfaz de usuario del éxito de crear vinculación
                }

                @Override
                public void onError(TMGClientException exception) {
                    // Comprobar si hay algún error
                }
            });
}
```

{% endtab %}

{% tab title="iOS" %}

```swift
guard let idvSession = MastercardService.shared.idvSession else {
    // no hay sesión idv
    return
}
do {
    let otp = "123456" // OTP introducido por el usuario
    // 1. enviar el valor del otp
    idvSession.validateOTP(otp)
} catch let error {
    // gestionar el error
}
        
// 2. El fallo en el paso 1, validateOTP, se gestionará en completionHandler.
MastercardService.shared.completionHandler = { (session, error) in
    // 3. Comprobar si es un error de validateOTP.
    if let session = session,
        let error = error,
        error.description == TMGError.invalidOTPMessage.description {
        MastercardService.shared.idvSession = session
        // 4. Reintentar el flujo de IDV.
    }
}
```

{% endtab %}
{% endtabs %}


---

# 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/merchant-tokenization/es/taf-de-mastercard/implement-taf/create-device-binding.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.