Migrar de 2.x a 3.0

A partir de TMG SDK 3.0.0, varias API públicas se simplifican.

Inicializar el SDK

El SDK elimina TMGClientConfiguration.Builder y mueve la configuración al TMGClientConfiguration inicializador:

• Eliminado: TMGClientConfiguration.Builder

• Usar en su lugar: TMGClientConfiguration

Qué cambió

• Obsoleto certificatePins. El SDK ahora gestiona el pinning de certificados internamente.

• Renombrado serverUrl a serverURL.

• Renombrado serverKeyId a serverKeyID.

Antes de 3.0.0

let serverUrl;
let serverCertificate;
let keyIdentifier;
let configurationBuilder = TMGClientConfiguration.Builder(serverUrl: serverUrl, 
                                                          serverCertificate: Data(serverCertificate.utf8), 
                                                          serverKeyId: keyIdentifier)
let configuration: TMGClientConfiguration = TMGClientConfiguration(builder: configurationBuilder)

3.0.0

let serverURL = ""
let serverCertificate = ""
let serverKeyID = ""
let configuration = TMGClientConfiguration(serverURL: serverURL,
                                           serverCertificate: Data(serverCertificate.utf8),
                                           serverKeyID: serverKeyID)

Inicializar VisaCTFHelper

En TMG SDK 3.0.0, createVisaCTFHelper cambia de asíncrono a síncrono. Esto simplifica el manejo de errores y el flujo de control.

Antes de 3.0.0

let tmgClient = TMGClient.sharedInstance
tmgClient.createVisaCTFHelper(tmgClientConfiguration: configuration,
                              completion: { (visaCTFHelper, error) in
  // Obtiene el objeto VisaCTFHelper
  // Verifica el error
})

3.0.0

do {
    let visaCTFHelper = try TMGClient.sharedInstance.createVisaCTFHelper(withConfiguration: configuration)
} catch let error {
    // Manejar el error
}

Actualizar los flujos de vinculación de dispositivo (verde y amarillo)

La vinculación de dispositivo abarca la autenticación del dispositivo, Identificación y Verificación (ID&V), y la finalización de la vinculación. En TMG SDK 3.0.0, el flujo:

• Estandarizó el uso de completionHandler.

• Eliminó la mezcla de delegate y completionHandler.

• Eliminó la necesidad de manejar el éxito de la vinculación en múltiples lugares.

• Optimizado el flujo de control.

Al migrar desde versiones anteriores del SDK, tenga en cuenta estos cambios de nombre en la API:

• PendingBindingSession ahora es VisaCTFHelper.IDVSession.

• DeviceAuthenticationDelegate ahora es DeviceAuthentication.

• IdvMethod ahora es IDVMethod.

• IdvType ahora es IDVType.

• OtpActivationStatus ahora es OTPActivationStatus.

  • maxOtpRequestsAllowed ahora es maxOTPRequestsAllowed.

  • maxOtpVerificationAllowed ahora es maxOTPVerificationAllowed.

Use el código a continuación para actualizar su integración de vinculación de dispositivo:

Antes de 3.0.0

// 1. conforme al DeviceAuthenticationDelegate (esto es para la autenticación del dispositivo)
class DeviceAuthenticationDelegateImplementation: DeviceAuthenticationDelegate {

    let authenticationMessage

    func shouldStartAuthentication(startHandler: (String?, Bool) -> Void) {
        //3. Iniciar la autenticación del usuario 
        startHandler(authenticationMessage, YES)
    }
}

var pendingBindingSession: PendingBindingSession?
let deviceId
let correlationId
let deviceAuthenticationDelegate = DeviceAuthenticationDelegateImplementation()
// 2. Iniciar crear vinculación
visaCTFHelper.createBinding(vProvisionedTokenId: vProvisionedTokenId,
                            correlationId: correlationId,
                            deviceAuthenticationDelegate: deviceAuthenticationDelegate) { session, error in
    // 4. Éxito al vincular [Escenario 1]
    if error == nil && session == nil {

    }
    // 5. Almacenar localmente la sesión para el flujo amarillo
    pendingBindingSession = session
}
// MARK: flujo idv
// 6. Obtener lista de métodos idv (flujo Amarillo)
pendingBindingSession.idvMethods(completion: { idvMethods, error in
    if error == nil {
        let listOfIdvMethod = idvMethods
    }
})

//7. Enviar el método idv seleccionado (flujo OTP)
let selectedIdvMethod
pendingBindingSession.submitIdvMethod(idvMethod: selectedIdvMethod,
                                      completion: { otpActivationStatus, error in
     // Verificar que no haya error
    if error == nil {
        let maxOtpVerificationAllowed = otpActivationStatus.maxOtpRequestsAllowed
        let maxOtpRequestsAllowed = otpActivationStatus.maxOtpVerificationAllowed
        let otpExpiration = otpActivationStatus.maxOtpVerificationAllowed
    }
    // 8. reintentar si hay error
    
})

//9. Activar vinculación
let otp
pendingBindingSession.activateBinding(otp: otp, 
                                      completion: { error in
    // 4.1 Éxito al vincular [Escenario 2]
    if error == nil {

    }
    // 10. Reintentar si hay error
})

3.0.0

// La clase singleton para mantener las propiedades requeridas 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 crear vinculación
visaCTFHelper.createBinding(forVProvisionedTokenID: vProvisionedTokenID,
                            correlationID: correlationID,
    deviceAuthenticationHandler: { auth in
        // 2. Iniciar la autenticación del usuario
        let customMessage = "" // Pasar el mensaje personalizado. p.ej.: "Autentíquese con Face ID"
        auth.startAuthentication(withMessage: customMessage)
    }, idvSessionHandler: { session in
        // 3. Almacenar localmente la sesión para el flujo amarillo
        VisaService.shared.idvSession = session

    }, completionHandler: { session, error in
        // 4. mantener el manejador de finalización localmente
        VisaService.shared.completionHandler?(session, error)
    })

// MARK: flujo idv
do {
    guard let session = VisaService.shared.idvSession else {
        return
    }
    // 5. Obtener lista de métodos idv (flujo Amarillo)
    let idvMethods = try session.idvMethods
    // 6. Enviar el método idv seleccionado (flujo OTP)
    session.selectIDVMethod(idvMethods[0]) { otp in
        // Verificar estado de activación OTP
    }
} catch let error {
    // error en la lista de métodos idv
}

// 7. Activar Vinculación
let otp = ""
VisaService.shared.idvSession?.activateBinding(withValue: otp)

// 8. Manejar éxito o error.
// Puede escuchar completionHandler para éxito o error
VisaService.shared.completionHandler = {(session, error) in
    // 9. Éxito al vincular
    if error == nil {
        
    } else if let error, let session {
        // 10. Reintentar si hay error
        if error.description == TMGError.invalidOTPMessage.description {
            VisaService.shared.idvSession = session
        }
    } else {
        // 11. Manejar error
    }
}

Reanudar una vinculación (resumeBinding)

El resumeBinding flujo no cambia respecto a versiones anteriores. Solo los IDVSession pasos de (ID&V) cambian.

Antes de 3.0.0

var pendingBindingSession: PendingBindingSession?
// 1. Iniciar reanudar vinculación
visaCTFHelper.resumeBinding(vProvisionedTokenId: vProvisionedTokenId) { session, error in
    // 2. Almacenar localmente la sesión para el flujo amarillo
    if error == nil { 
        pendingBindingSession = session
    }
    // Verificar error
}

// 3. MARK: flujo idv (consulte el flujo idv de crear vinculación en el fragmento de código)

3.0.0

// La clase singleton para mantener las propiedades requeridas 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 = ""
// 1. Iniciar reanudar vinculación
visaCTFHelper.resumeBinding(forVProvisionedTokenID: vProvisionedTokenID,
                            idvSessionHandler: { session in
        // 2. Almacenar localmente la sesión para el flujo amarillo
        VisaService.shared.idvSession = session        
    }, completionHandler: { session, error in
        // 3. mantener el manejador de finalización localmente
        VisaService.shared.completionHandler?(session, error)
    })
// 4. MARK: flujo idv (consulte el flujo idv de crear vinculación en el fragmento de código)

Obtener el estado de la vinculación (bindingState)

En TMG SDK 3.0.0, bindingState cambia de asíncrono a síncrono. Esto simplifica el manejo de errores y el flujo de control.

Antes de 3.0.0

let vProvisionedTokenId = ""
visaCTFHelper.bindingState(vProvisionedTokenId: vProvisionedTokenId) { (bindingState, error) in 
}

3.0.0

let vProvisionedTokenID = ""
do {
    let state = try visaCTFHelper.bindingState(forVProvisionedTokenID: vProvisionedTokenID)
} catch let error {
    // Manejar el error
}

Autenticar una transacción

La autenticación de transacciones cubre la autenticación del dispositivo y la devolución de la carga útil de Visa. En TMG SDK 3.0.0, el flujo:

• Estandarizó el uso de completionHandler.

• Eliminó la mezcla de delegate y completionHandler.

Use el código a continuación para actualizar su integración de autenticación de transacciones:

Antes de 3.0.0

// 1. conforme al DeviceAuthenticationDelegate (esto es para la autenticación del dispositivo)
class DeviceAuthenticationDelegateImplementation: DeviceAuthenticationDelegate {

    let authenticationMessage

    func shouldStartAuthentication(startHandler: (String?, Bool) -> Void) {
        //3. Iniciar la autenticación del usuario 
        startHandler(authenticationMessage, YES)
    }
}

let deviceAuthenticationDelegate = DeviceAuthenticationDelegateImplementation()

// 2. Iniciar autenticación de transacción
visaCTFHelper.authenticateTransaction(vProvisionedTokenId: vProvisionedTokenID,
                                      deviceAuthenticationDelegate: deviceAuthenticationDelegate,
                                      completion: { visaPayload, error in
    // 4. Generar la carga útil con éxito
    if error == nil {
    
    } else {
        // Manejar error
    } 
})

3.0.0

let vProvisionedTokenID: String = ""
        
// 1. Iniciar autenticación de transacción
visaCTFHelper.authenticateTransaction(forVProvisionedTokenID: vProvisionedTokenID,
                                        deviceAuthenticationHandler: { auth in
        // 2. Iniciar la autenticación del usuario 
        let customMessage = "" // Pasar el mensaje personalizado. p.ej.: "Autentíquese con Face ID"
        auth.startAuthentication(withMessage: customMessage)
    }, completionHandler: { (visaPayload, error) in
        // 3. Éxito al generar la carga útil
        if error == nil {
            
        } else {
            // Manejar error
        }    
})

Eliminar una vinculación (removeBinding)

removeBinding ahora requiere un correlationID.

Antes de 3.0.0

// 1. Iniciar eliminar vinculación
visaCTFHelper.removeBinding(vProvisionedTokenId: vProvisionedTokenID,
                            completion: { error in
    // 2. Éxito al eliminar vinculación
    if error == nil {
        
    } else {
        // Manejar error
    }
})

3.0.0

let vProvisionedTokenID: String = ""
let correlationID: String = ""

// 1. Iniciar eliminar vinculación
visaCTFHelper.removeBinding(forVProvisionedTokenID: vProvisionedTokenID,
                            correlationID: correlationID) { error in
    // 2. Éxito al eliminar vinculación
    if error == nil {
        
    } else {
        // Manejar error
    } 
}

Sincronizar estado de vinculación (syncBindingState)

syncBindingState ahora requiere un correlationID.

Antes de 3.0.0

// 1. Iniciar sincronización del estado de vinculación
visaCTFHelper.syncBindingState(vProvisionedTokenId: vProvisionedTokenID,
                               completion: { bindingState, error in
    // 2. Éxito al sincronizar el estado de vinculación
    if error == nil {
        
    } else {
        // Manejar error
    }  
})

3.0.0

let vProvisionedTokenID: String = ""
let correlationID: String = ""

// 1. Iniciar sincronización del estado de vinculación
visaCTFHelper.syncBindingState(forVProvisionedTokenID: vProvisionedTokenID,
                                correlationID: correlationID) { (state, error) in
    // 2. Éxito al sincronizar el estado de vinculación
    if error == nil {
        
    } else {
        // Manejar error
    }   
}

Leer el método ID&V previamente seleccionado

Además de las IDVSession funciones utilizadas en el createBinding flujo, puede leer el método ID&V previamente seleccionado. En TMG SDK 3.0.0, previouslySelectedIDVMethod cambia de asíncrono a síncrono. Esto simplifica el manejo de errores y el flujo de control.

Antes de 3.0.0

// 1. Obtener el método idv previamente seleccionado
pendingBindingSession.previouslySelectedIdvMethod(completion: { idvMethod, error in
    // 2. obtener con éxito el método idv previamente seleccionado
    if error == nil {
        let prevIDVMethod = idvMethod
    } else {
        // Manejar error
    } 
})

3.0.0

guard let idvSession = VisaService.shared.idvSession else {
    // no hay sesión idv
    return
}
// 1. Obtener el método idv previamente seleccionado
do {
    let prevIDVMethod = try idvSession.previouslySelectedIDVMethod
} catch let error {
    // 2. manejar error
}