Crear vinculación de dispositivo (flujo amarillo)

Vinculación de dispositivo con Visa Cloud Token Framework (CTF) flujo amarillo ocurre cuando el emisor requiere autenticación de escalado usando un ID&V método.

Este flujo comienza de la misma manera que el Crear vinculación de dispositivo (flujo verde), luego se pausa hasta que el usuario final complete la autenticación de escalado.

Prerrequisitos:

La tarjeta de pago ya está tokenizada.
Tienes un vProvisionedTokenId.
El usuario final puede autenticarse en el dispositivo (PIN, código de acceso, huella dactilar, Face ID, etc.).
El usuario final puede completar el método ID&V seleccionado (por ejemplo, OTP).

Flujo

Paso

Descripción

Inicia el flujo de vinculación de dispositivo desde la aplicación del comerciante usando el SDK de Thales.

El SDK de Thales genera un ID de dispositivo y un par de claves CTF, luego almacena de forma segura el par de claves CTF en el dispositivo.

El SDK de Thales desencadena la autenticación del usuario final en el dispositivo.

El SDK de Thales genera y firma la carga útil definida por Visa.

El SDK de Thales envía la carga útil firmada y la clave pública CTF al backend de Thales.

El backend de Thales convierte la clave pública en un certificado usando una CA de Visa.

El backend de Thales registra el dispositivo y solicita la vinculación del dispositivo a VTS.

VTS verifica la decisión del emisor.

El emisor requiere autenticación de escalado y proporciona métodos ID&V compatibles (por ejemplo, OTP o app-to-app).

El backend de Thales es informado sobre la decisión del emisor.

El SDK de Thales obtiene la lista de métodos ID&V y los pasa a la aplicación del comerciante.

La aplicación del comerciante muestra las distintas opciones al usuario final.

Integración del SDK

Crear una vinculación

Llamar createBinding desde el SDK de Thales.

Si el emisor requiere autenticación de escalado, el SDK devuelve un IDVSession en:

onIssuerAuthenticationRequired (Android)
idvSessionHandler (iOS)

public void createBinding(VisaCTFHelper visaCTFHelper, FragmentActivity activity) {

    // 1. Iniciar create binding
    visaCTFHelper.createBinding("vProvisionTokenID", "x-correlationId", new TokenBindingListener() {
        
        @Override
        public void onDeviceAuthentication(DeviceAuthentication deviceAuthentication) {
            // Realizar la 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 onIssuerAuthenticationReady(IDVSession pendingBindingSession, OtpActivationStatus otpActivationStatus) {
            // esperar el OTP e introducir el OTP
            String otp = "";

            // 4. Enviar el OTP
            pendingBindingSession.activateBinding(otp);
        }

        @Override
        public void onIssuerAuthenticationRequired(IDVSession pendingBindingSession) {
            List<IDVMethod> idvMethods = pendingBindingSession.getIdvMethods();
            // Lógica para mostrar la interfaz de usuario para seleccionar idvMethod
            IDVMethod idvMethod = idvMethods.get(0);

            // 3. Enviar el IDV seleccionado
            pendingBindingSession.selectIdvMethod(idvMethods.get(0));
        }

        @Override
        public void onIssuerAuthenticationError(@Nullable IDVSession pendingBindingSession, TMGClientException e) {
            // Manejar error
        }


        @Override
        public void onSuccess() {
            // 5. Manejo de éxito
        }

        @Override
        public void onError(TMGClientException e) {
            // Manejo de errores
        }
    });
}

// La clase singleton para mantener las propiedades necesarias para el flujo de Visa
class VisaService {
    static var shared = VisaService()
    var idvSession: VisaCTFHelper.IDVSession? = nil
    var completionHandler: ((VisaCTFHelper.IDVSession?, TMGError?) -> Void)? = nil
}

let vProvisionedTokenID: String = ""
let correlationID: String = ""
// 1. Iniciar create binding
visaCTFHelper.createBinding(forVProvisionedTokenID: vProvisionedTokenID,
                            correlationID: correlationID,
    deviceAuthenticationHandler: { auth in
        // 2. Autenticación del dispositivo (por ejemplo, Face ID)
        let customMessage = "" // Pase el mensaje personalizado. por ejemplo: "Authenticate with Face ID"
        auth.startAuthentication(withMessage: customMessage)
    }, idvSessionHandler: { session in
        // 3. Mantener la sesión IDV localmente
        VisaService.shared.idvSession = session
        // Continuar con la selección y activación de ID&V
        
    }, completionHandler: { session, error in
        // 4. Manejar la finalización (éxito o error)
        VisaService.shared.completionHandler?(session, error)
    })

Obtener la lista de métodos ID&V

La lista de métodos ID&V puede recuperarse del IDVSession objeto.

Usa el IDVSession objeto para llamar a getIdvMethods para obtener la lista de ID&V métodos compatibles.

visaCTFHelper.createBinding(vProvisionTokenId, 
                              correlationId, 
                              new TokenBindingListener() {

          

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

          

      });

Usa el IDVSession objeto que se devuelve desde la createBinding función para llamar a idvMethods para obtener la lista de ID&V métodos compatibles.

guard let idvSession = VisaService.shared.idvSession else {
    // no hay sesión idv
    return
}
// 1. Mostrar lista de métodos idv
do {
    let idvMethods = try idvSession.idvMethods
} catch let error {
    // 2. manejar error
}

Seleccionar un método ID&V

visaCTFHelper.createBinding(vProvisionTokenId, 
                            correlationId, 
                            new TokenBindingListener() {

        

        @Override
        public void onIssuerAuthenticationRequired(IDVSession idvSession) { 
            // Enviar el método idv seleccionado
            IDVMethod selectedIdvMethod;
            idvSession.selectIdvMethod(selectedIdvMethod);
        }

        @Override
        public void onIssuerAuthenticationReady(IDVSession idvSession, 
                                                @Nullable OtpActivationStatus status) { 
            // Comprobar el estado de activación del otp
            int maxOtpVerificationAllowed = otpActivationStatus.getMaxOtpVerificationAllowed();
            int maxOtpRequestsAllowed = otpActivationStatus.getMaxOtpRequestsAllowed();
            int otpExpiration = otpActivationStatus.getOtpExpiration();
        }

       

    });

Si el método seleccionado se basa en OTP, el SDK llama a onIssuerAuthenticationReady y proporciona OtpActivationStatus.

OtpActivationStatus se devuelve solo para OTP_EMAIL, OTP_SMS, y OTP_ONLINE_BANKING.

guard let idvSession = VisaService.shared.idvSession else {
    // no hay sesión idv
    return
}
// 1. Mostrar lista de métodos idv
do {
    let idvMethods = try idvSession.idvMethods
    let selectedIdvMethod = idvMethods[0] // el usuario selecciona 1 de los idvMethods disponibles
    
    // 2. Enviar el método idv
    idvSession.selectIDVMethod(selectedIdvMethod) { (result) in
        if let otpActivationStatus = result {
            // 3.1. Mostrar página para introducir el valor OTP
        
        } else {
            // 3.2. Manejar el idv seleccionado que no está relacionado con OTP, por ejemplo, solicitar Atención al Cliente

        }
    }
} catch let error {
    // manejar error
}

// 4. El fallo en el paso 2, selectIDVMethod, se gestionará en completionHandler.
VisaService.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 {
        VisaService.shared.idvSession = session
        // 6. Reintentar el flujo IDV.
    }
}

Para los métodos basados en OTP, selectIDVMethod devuelve OtpActivationStatus. De lo contrario devuelve nil.

Los errores se devuelven en completionHandler.

OtpActivationStatus se devuelve solo para OTP_EMAIL, OTP_SMS, y OTP_ONLINE_BANKING.

Activar la vinculación

Activar la vinculación en función del método ID&V seleccionado:

APP_TO_APP: ver Activar la vinculación del dispositivo con app-to-app.
CUSTOMER_SERVICE: ver Flujo de servicio al cliente.
OTP_EMAIL, OTP_SMS, y OTP_ONLINE_BANKING: ver Flujo OTP.

Si el flujo se interrumpe mientras el estado de la vinculación es PENDING_ACTIVATION, reanúdalo usando resumeBinding.

Reanudar una vinculación pendiente

Use resumeBinding cuando el estado de la vinculación es PENDING_ACTIVATION.

Obtener el `IDVSession` objeto

// Obtener el objeto IDVSession
IDVSession bindingState = visaCTFHelper.resumeBinding(vProvisionedTokenId,
                                                                  new TokenBindingListener() {
              
    ......

    @Override
    public void onError(TMGClientException exception) { 
        // Comprobar error
        int errorCode = exception.getErrorCode();
        int errorMessage = exception.getMessage();
    }
});

En los casos en que ocurra un error, el onError callback será llamado, de lo contrario se devolverá un IDVSession objeto.

let vProvisionedTokenID: String = ""
// 1. Iniciar resume binding
visaCTFHelper.resumeBinding(forVProvisionedTokenID: vProvisionedTokenID,
                            idvSessionHandler: { session in
        // 2. Mantener la sesión IDV localmente
        VisaService.shared.idvSession = session
        // 3. Continuar con la selección y activación de ID&V
        
    }, completionHandler: { session, error in
        // 4. vinculación exitosa
        if error == nil {
            
        }
    })

Después de resumeBinding devuelve un IDVSession, úsalo para obtener la lista de métodos ID&V, seleccionar uno y activar la vinculación como se mencionó arriba.

Opcional: ejemplos de reanudación de flujo (Android/iOS)

List<IDVMethod> idvMethods = idvSession.getIdvMethods();guard let idvSession = VisaService.shared.idvSession else { // no hay sesión idv return}// 1. Mostrar lista de métodos idvdo { let idvMethods = try idvSession.idvMethods} catch let error { // 2. manejar error}

Seleccionar un método ID&V

IDVMethod selectedIdvMethod;idvSession.selectIdvMethod(selectedIdvMethod);Una vez que la aplicación envía el método ID&V seleccionado, el callback onIssuerAuthenticationReady será devuelto a la aplicación.guard let idvSession = VisaService.shared.idvSession else { // no hay sesión idv return}// 1. Mostrar lista de métodos idvdo { let idvMethods = try idvSession.idvMethods let selectedIdvMethod = idvMethods[0] // el usuario selecciona 1 de los idvMethods disponibles // 2. enviar el método idv idvSession.selectIDVMethod(selectedIdvMethod) { (result) in if let otpActivationStatus = result { // 3.1. mostrar página para introducir el valor OTP } else { // 3.2. manejar el idv seleccionado que no está relacionado con otp, por ejemplo, solicitar Atención al Cliente } }} catch let error { // manejar error}// 4. El fallo en el paso 2, selectIDVMethod, se gestionará en completionHandler.VisaService.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 { VisaService.shared.idvSession = session // 6. Reintentar el flujo IDV. }}TMGError ilustrado arriba no es exhaustivo. Usa el código de error más apropiado para tu caso.

Activar la vinculación

La activación de la vinculación se puede hacer siguiendo los pasos para el método seleccionado:

APP_TO_APP: ver Activar la vinculación con app-to-app.
CUSTOMER_SERVICE: ver Flujo de servicio al cliente.
OTP_EMAIL, OTP_SMS, y OTP_ONLINE_BANKING: ver Flujo OTP.

AnteriorCrear vinculación de dispositivo (flujo verde)SiguienteActivar vinculación con app a app

Última actualización hace 3 meses

¿Te fue útil?